Not translated yet — showing English.
Access Control
Every entity says who may read it and who may write it, and every function says who may run it. Access is set per caller: your game's client, your servers, and your cloud functions. For a player-owned entity, ownership then narrows a client to its own records. Entity access is set in Schema, in the entity's editor; function access, in the function's manifest.
Who is calling
| Caller | Who it is |
|---|---|
| Client | Your game, signed in with a client key (pk_…), as an anonymous or signed-in player. |
| Server | Your own servers and tools, with a server key (sk_…). |
| Backend | Your cloud functions, calling back into the platform with their own identity. |
The Backoffice itself isn't subject to these settings.
Read and Write
Each entity has a Read and a Write switch for each caller. Write covers every change: creating, updating and deleting records alike. There is no separate delete permission.
| Caller | Read | Write |
|---|---|---|
| Client | Off | Off |
| Server | On | On |
| Backend | On | On |
These are the defaults of a new entity: closed to the client, open to your servers and functions. A client can neither read nor write a new entity until you allow it.
Access is decided in a fixed order: first whether the caller may read or write the entity at all, then, for a client on a player-owned entity, which records it may touch.
Set access in the Backoffice
Open the entity's editor
In Schema, select the entity and click the pencil next to its name. For a new entity, the same settings are in New ▾ → Entity.
Set Read and Write
Under Access control, tick Read and Write for each caller.
Stage and apply
Click Apply changes to stage the edit, then review and apply the migration. Access changes go live with the migration.
Client Write on a shared entity lets any player change any record
On an entity that isn't player-owned, client Write isn't narrowed to anything: every player may change or delete every record. Allow it only for data that is meant to be shared, and use a player-owned entity for each player's own data.
Set access from code
An entity defined in your Unity project sets its access on the [PlayServSchema] attribute, and the SDK's schema tool pushes it with the schema. Each switch is Default, Allow or Deny:
using Playserv.Schema;
[PlayServSchema("Pilots",
OwnedBy = PlayServSchemaOwner.Player,
Read = PlayServSchemaReadPolicy.Owner,
OnPlayerDelete = PlayServPlayerDeletePolicy.Anonymise,
ClientRead = PlayServSchemaAccess.Allow,
ClientWrite = PlayServSchemaAccess.Allow)]
public class Pilots
{
public string Callsign;
public int Level;
}
ServerRead, ServerWrite, BackendRead and BackendWrite set the other callers the same way. Access set from code and access set in the Backoffice are stored and enforced the same way. An entity pushed from code is read-only in the Backoffice, access included: change it in code.
Player-owned entities
On a player-owned entity, Read and Write still decide whether a client may touch it; ownership decides which records.
| A client… | Read access Owner | Read access Public |
|---|---|---|
| Reads | Only its own records. Without a signed-in player, it is refused. | Every record. |
| Creates | A record owned by its player. Without a signed-in player, it is refused. | The same. |
| Updates or deletes | Only its own records. | Only its own records. |
Server and backend calls aren't narrowed: they read, update and delete any record. To create a record in a player-owned entity, they act on behalf of a player, who becomes its owner.
A record owned by another player is invisible to a client rather than forbidden: reading, updating or deleting it answers 404, exactly like a record that doesn't exist. Client code can't tell the two apart, by design.
Checks in the game client
The platform always decides. The Unity SDK also checks access before sending a request: when it knows the entity is closed to the client, it refreshes its copy of the access settings once, and if the entity is still closed, fails the call locally with an access-denied error instead of sending it.
Function Execute
Each function says which callers may run it, in the execute setting of its manifest: client, server and backend, each true or false, all allowed by default. A caller without Execute is refused with 403.
Execute is separate from the function's auth setting, which decides whether a client call needs a signed-in player (player, the default) or not (none). The function's Settings tab in the Backoffice shows its auth setting; the Execute settings are only in the manifest.
When a call is refused
| Answer | When | What to check |
|---|---|---|
403 table_read_forbidden | The caller may not read the entity. | The entity's Read switch for that caller. |
403 table_write_forbidden | The caller may not write the entity. | The entity's Write switch for that caller. |
403 owner_read_requires_player | A client without a signed-in player reads an entity whose read access is Owner. | Sign the player in first. |
422 acting_player_required | A record is created in a player-owned entity without a player to own it. | Sign the player in, or create it on a player's behalf. |
404 | A client touches another player's record, or a record that doesn't exist. | Whether the record belongs to the signed-in player. |
403 function_execute_forbidden | The caller may not run the function. | The function's execute setting. |
401 player_auth_required | A client calls a function that needs a player, with no player signed in. | The function's auth setting, or sign the player in. |
403 player_read_forbidden | A client reads a player's account that isn't its own, or has no signed-in player. | Read only the signed-in player's account. |
Most refusals come down to two settings
If a client write is refused, check the entity's client Write switch first, then whether the entity is player-owned and the record belongs to the signed-in player.
Next steps
- Schema Object Reference — every entity setting, ownership included
- Building a Game Schema — apply access changes with a migration
- Writing Records — the writes these rules decide
Last updated on 16 Oct 2026