Skip to main content
Data & Schema

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

CallerWho it is
ClientYour game, signed in with a client key (pk_…), as an anonymous or signed-in player.
ServerYour own servers and tools, with a server key (sk_…).
BackendYour 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.

CallerReadWrite
ClientOffOff
ServerOnOn
BackendOnOn

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.

Call + credential→ subjectauthorityRead / Write flagno → 403 forbiddenrow scopeClient on owned tableown rows onlyForeign row404 — invisible

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 OwnerRead access Public
ReadsOnly its own records. Without a signed-in player, it is refused.Every record.
CreatesA record owned by its player. Without a signed-in player, it is refused.The same.
Updates or deletesOnly 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

AnswerWhenWhat to check
403 table_read_forbiddenThe caller may not read the entity.The entity's Read switch for that caller.
403 table_write_forbiddenThe caller may not write the entity.The entity's Write switch for that caller.
403 owner_read_requires_playerA client without a signed-in player reads an entity whose read access is Owner.Sign the player in first.
422 acting_player_requiredA 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.
404A 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_forbiddenThe caller may not run the function.The function's execute setting.
401 player_auth_requiredA 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_forbiddenA 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

Last updated on 16 Oct 2026