Packet index

Carries the player's identity: an Xbox-authenticated JWT chain (or a PlayFab multiplayer token on 1.26.x clients) plus a client-data JWT with skin, device and locale claims.

Tells the client the result of login, or that it may spawn into the world. Sent unencrypted after ServerToClientHandshake is answered, then once more when chunks are ready.

Starts encryption. Carries a single ES384-signed JWT whose header holds the server's public key and whose payload holds the salt used to derive the shared AES key.

Empty packet confirming the client enabled encryption — the first encrypted packet on the wire.

Ends the connection. The reason code drives the Ore UI disconnect screen; unless the screen is skipped, an optional message is shown with it.

Split-screen: a second player joining over the main client's connection sends the same connection request blob the LoginPacket carries.

Tells the client to open a websocket connection to the given server, which may then run commands on the client's behalf and listen for the events it fires.

Deprecated round-trip probe over the whole network stack. Fed the in-game debug graph's ping and Realms latency telemetry; sent by both sides.

Tells the server whether the client supports the chunk blob cache. Sent once during login, before StartGame.

Periodic cache update from the client: which blob hashes it has (found) and which it lacks (missing).

Any missing blob should just be thrown into one of these packet ASAP and sent. This is actually how chunk data gets to the client the first time.

Server response to RequestNetworkSettings. It fixes the compression algorithm and threshold for every following batch, plus the render-distance throttle the client applies to other players.

Sent when a packet fails to parse: names the offending packet id, the violation type/severity and a context string. Mostly produced by the client's deserializer.

Server-side timing statistics the server reports to the client.

The very first game packet a client sends, uncompressed and unencrypted. It announces the protocol version the client speaks so the server can reply with compression settings — or reject it with a PlayStatus version-mismatch code.

Lists the resource packs the client must or may download before joining, with sizes, content keys and sub-pack information.

Defines the order the accepted packs are applied in, the base game version the stack falls back to, and the experiments the world runs.

The client's step in the pack handshake: which packs it still wants, then twice more to say the download and the stack are done.

The header for one pack's download: how its bytes will be chunked, how large the archive is, and the hash the client checks the reassembled file against.

One chunk of a pack the client is downloading: the pack the chunk belongs to, the chunk's index in the sequence, and its offset into the pack file.

Chat, system messages, popups, tips, whispers and translations. Since the 1.26.40 cereal migration the per-type body is a tagged variant instead of a flat type byte + conditionals.

Controls the boss health bar: bind it to an entity, set its percentage, color, overlay or remove it. Also used for the raid bar.

The command tree the client renders for autocomplete: enums, soft enums, constraints and per-command overloads with argument types.

Player or server origin request to run a slash command; the command line includes the leading slash.

Sent when you close the command block screen on the client.

Result of a CommandRequest: success flag, output type (toast/chat/box/modal) and formatted message lines with parameters.

Title/subtitle/actionbar text with fade-in, stay and fade-out times and an XUID for filtering.

Opens a JSON-defined UI form: simple buttons, modal (OK/cancel) or a custom form with inputs.

Client's answer to a ModalFormRequest: form id plus button index, toggle/float/slider values or raw input JSON.

It is also an empty packet. There is no handler for this packet, should be removed.

The server's answer to a settings request: the JSON describing a settings tab to draw for this server, and the form id the client echoes back when the player submits it.

This is just the name of the objective.

Sets the scoreboard which is used for 3rd party content.

Send an update packet for a player identity definition iff a tracked player has logged in with a different display name.

This allows someone to sync between server and client tags and enums on mobs or on the level.

Sent from the player (and in one case from the village) to make those really cool animated effects for the hero of the village and the totem saving you. Just an id (unsigned int). At least thats what the code suggests. May be obsolete / deprecated.

Used when the player changes the world settings like doDayNightCycle or WeatherCycle via the world settings menu

Client sends text for server-side profanity filtering; the server answers with the filtered version.

Shows a notification toast with title and body strings.

This packet will toggle the HUD visibility.

This will only have an affect if the client currently has a server form on the UI stack.

In order for the client to send a packet with StartLoadingScreen, the server needs to anticipate that this packet is coming. If the server doesn't expect that we are about to start a loading screen, the server will disconnect the client. EndLoadingScreen is sent by the client when the loading screen closes. The Loading Screen Id field will be empty if the loading screen is triggered by the initial loading into of a world. The Loading Screen Id field will have a value if sent by the server. This currently happens as part of ChangeDimensionPacket if the player is alive.

Every so often (and at login) the server sends the current time to the client, and additionally the client can set the server time through 2 commands: DayLockCommand and TimeCommand

Changes a single block in the world, with the block's runtime (hash) ID and the update flags.

Generic world event: particles, sound-less effects, door/chest state changes, block breaking progress and more.

Sends a full chunk column: serialized sub-chunks, biome palettes, border blocks and block entity NBT in one payload blob.

If the server finds the map, it sends the data back. If it can't find the map, it creates it and sends the map and data back. (the map creation data packet and the map data packet are separate packets). The response from the server potentially has to load from disk, just an fyi. This packet is fired via map item tick, if the map data we have is invalid, or if the map is placed in an item frame. For Client Side Generation when we re-sample pixels from the Client's ChunkSource we need to inform the Server's map about these new pixels so that it can save them to LevelStorage. Use this packet to send to the Server the extra pixels

Client asks for a render distance in chunks; the server answers ChunkRadiusUpdated with what it will actually send.

When the player uses the camera item or adds a photo to the scrapbook it sends the photo to the server, then the server sends a response back on whether that was successful or not. Either uploads a photo to the server's photoStorage or request one from it to be stored in client's photoStorage. If no mPhotoData is provided it is a request for the given filename.

Variation of UpdateBlockSyncedPacket that includes information to sync entities with renderchunk generation. Occasionally when blocks change a sync message is sent and during the change on the dimension, this packet is sent to the client to alert the update flags and sync info at a specific position.

This is not used for much anymore, only the Particle command (spawn particle by name at a location) and for ScriptServerSpawnParticleAttachedToActor and ScriptServerSpawnParticleInWorldEvent.

Tells the client the position from which chunk publishing is driven (the subscribing player's viewpoint).

- mBiomeData: map of biome string indices to biome definition data. - mStringList: list of biome name strings.

It is a request from the client to either turn the page in the lectern or drop the book.

It sends the original map id and the new map id. On the server it follows a similar process to creating a new map, sends the data and the map info to the client.

This is used to kick off the process of loading and returning a structure in a Tag from the server back to the client. Currently this functionality is completely disabled and does nothing.

The client sends a packet to the server, from there the structure is built and then put into a Tag where it is sent back to the client, from there you can view the structure in the Structure Block Screen. Currently this functionality is completely disabled and does nothing. Used to reply to a request for structure information.

Only used when Item Stack Net Manager is disabled on the server. Sends the position of the anvil that is requesting to be damaged from the client.

Client to server packet for server authoratative runtime database (with persistent LevelStorage backup) designed primarily to track lodestone stuff. See Position Tracking DB Notes.md in bedrock-docs. see PositionTrackingDBServerBroadcastPacket

Requests information about a photo taken with the camera.

Sub-chunk terrain response: per-entry serialized paletted storage, render heightmaps and blob cache IDs.

Client asks for specific sub-chunks around a center position — part of the limited sub-chunk request system.

Contains dimension definition data including height bounds and generator type for each dimension.

Internal Text Packet

Sends the serialized jigsaw rule JSON to the client as it's needed on both the client and server.

Sends the name of the Structure Feature the player is currently occupying to the client. If the player is not in a structure, this packet contains an empty string.

Internal

Sends the serializable voxel shapes data to the client as it's needed on both the client and server. This packet should always be sent before StartGamePacket.

Sent from the server when a client joins to initialize all world clocks for the client and periodically to all clients to keep them in sync. It is also sent to all clients when a world clock's paused state changes or when time markers are added or removed.

The largest packet of the login: player IDs, spawn position, the full level settings blob (seed, dimension, difficulty, game rules, experiments), block palette, permissions and the movement authority mode.

see SimpleEventPacket

Used for when a client changes difficulty through the menu or when the server changes the difficulty.

The client handles the change of the UI element (the gametype dropdown, although this can be avoided by changing via command or on the server), then the client sends a packet to the server, then the server changes the player's gametype and sends a packet back (UpdatePlayerGameTypePacket) to make sure it matches on the client.

Informs client about any changes to the game rules.

That packet is sent to the client. When the credits have concluded, a packet is sent back to the server to let it know to reinstate the player watching the credits.

This is used by EDU for joining players and removing players from your session, the settings (there is only one) is an enum for enabling/disabling/refreshing multiplayer join codes. Starts on the client, and a response to the client is issued from the server.

- mSimType: an enum representing the simulation type to switch to.

Spawns another player's entity in the world, with game mode, held item, metadata, abilities and riding links.

Used for inventory button press and in _updateInteraction() for a variety of purposes. From the client.

Sends the damage taken after armor is taken into account. This looks like it is trying to be phased out, this is not sent while the ItemStackNetManagerServer is active. From the server.

Sets the local player's health directly. Largely superseded by UpdateAttributes for the health attribute.

Sets the world or player spawn point used by compasses and respawns.

Coordinates the respawn flow: the server searches for a spawn, the client readies, the server confirms the final position.

Legacy permissions packet: adventure flags, command permission level, action permissions and permission level for one player.

Adds or removes entries from the tab list / player registry, each with UUID, name, XUID, platform and skin.

Client skin update: full SerializedSkin with geometry, animations, persona pieces and tint colors.

Client tells the server that the client is ready to roll.

Sent in both directions; by client to request that an emote is played and then from the server to the clients to indicate which player needs to now emote.

This is the packet that tracks the active fog stack from the server so the local players can apply different fog settings.

Functions the same as UpdateAbilities; the reason these two were separated is unclear.

The values in this packet are originally synced through the Connection Request and then updated via this packet.

Updates client entity property override data. Sets/removes an override for the indicated property for a specific entity on a client or clears all overrides for that entity.

Sent by PlayerLocationSender when a player position changes beyond a certain angle.

Spawns a non-player entity (mob, projectile, item-less actor) with type identifier, attributes, metadata and links.

Despawns an entity by its unique ID (not the runtime ID).

Item pickup: the taker (player/runtime) grabs an item actor, decrementing its count.

Triggers an entity animation or state event such as hurt, death, eating or taming.

Adds, modifies or removes a potion effect on an entity, with duration, amplifier, particles and ambient flags.

Updates entity attributes (health, movement speed, hunger, ...) with min/max/current/default values and modifiers.

Updates an entity's synchronized data: flags (on fire, sneaking, ...), byte/short/int/float/long variants and component data like bounding box.

Sets an entity's velocity. For the local player with server-auth movement the client predicts and corrects instead.

Sent when the player starts riding something. Two are sent at a time for some reason.

Plays a player animation: arm swing, critical hit, wake up or rowing.

Note: This can be seen as "ContainerWantSetSlotPacket" when sent from client to server. Currently, the client handles side-effects relating to it's own inventory, regardless of the success of the operation.

For automation

A request is made from the client during an interaction with an NPC then the request is processed by the server. Actor MUST have the NPCComponent to be handled. We currently only use this for EDU, but the goal was to expose the NPC Component to creators.

This is from the server when spatial optimizations are enabled and the server does not send a spatial update.

Several properties can be specified in the following order:</br> - The name of the animation (a string) that the specified entities are to play.</br> - The next state to transition to (a string) once the specified animation is finished playing.</br> - The stop expression (a string), the condition that determines when to transition to the next state.</br> - The name of an animation controller (a string) that you would like to use.</br> - The blend out time (a float), the amount of time to blend out of this animation.</br> - A vector of ActorRuntimeIds of the entities that will play the specified animation.

Intended to one day replace SynchedActorData.

Client request to toggle an ability (e.g. stop flying). The server validates permissions before applying it.

Client → server command-permission and player-permission request (custom operator levels), answered by UpdateAdventureSettings/UpdateAbilities.

Full ability layers sync: per-layer permission values and ability toggles (fly, fly speed, walk speed, may build, ...).

Sent by the server to update the state of AdventureSettings. Replaces the AdventureSettingsPacket for updating AdventureSettings from server to client.

mDeathCauseMessage: is untranslated cause of death string vector returned from ActorDamageSource

These MovementEffects can be client-predicted. Ex: Fireworks Rockets used while gliding send this packet to the client so they know the exact duration of the GLIDE_BOOST MovementEffect.

Debug-draw hook for server-side post-move player positions; only sent when debug rendering is enabled.

Teleports or hard-sets a player's position. With server-authoritative movement the client only sends it to acknowledge teleports; regular movement rides on PlayerAuthInput.

The expected actions change depending on the ServerAuthMovementMode specified in the StartGamePacket. See the PlayerActionType enum for details on which have differing behavior. See also PlayerAuthInputPacket and InventoryTransactionPacket for similar types of player actions.

Each position, rotation and head-rotation component is sent as an independent optional, accompanied by flags indicating whether the actor is on the ground and whether this is a teleport.

Sent every tick with server-authoritative movement: position, rotation, input flags, pending item/block actions and vehicle state. Replaces client-bound MovePlayer as the client's movement packet.

Used only in server authoritative movement mode, see ServerAuthMovementMode documentation.<br> Since it is sent to the specified client the target player is implied to be the receiver.<br> It is an optional part of the server authoritative protocol. A server could choose to never send this or do all corrections through MovePlayerPacket, although doing so would likely provide less smooth results.

Used to update the players input permissions. Sends the full permission set and the server position of the player at the time the permission was modified.

Only used in Server-Authoritative Movement. Sent periodically if the client has received corrections from the server. Contains information about client-predictions that are relevant to movement.

Legacy use-item/placement packet. Inventory and crafting moves went through ItemStackRequest long ago; only the UseItem transaction family still carries meaningful traffic.

Held item sync per slot (hotbar selected slot + equipment window/slot).

Armor sync: head/chest/legs/feet/offhand item stacks in one packet.

Opens a container UI (chest, furnace, horse, ...), positioning it and binding entity containers.

Closes a container window; the server echoes the client's close with the same window id.

The crafting registry: recipes (shaped, shapeless, furnace, potion mixes, container, material reducer) with network ids the client uses in ItemStackRequest.

This is only used when players use pick block, a command is used, tests, and some 3rd party content.

The packet can be fired from the client through the UI or from the server during updates.

The creative inventory: grouped entries of item stacks, sent after spawn.

The client's authoritative request stream for every inventory/crafting/trade operation: each request has an id, a list of filtered stack operations and string filters.

Server's per-request result for ItemStackRequest: ok with modified slots, or an error with a reason.

This packet needs to be sent immediately after the StartGamePacket for primary clients.

Packet sent by the player to start the cooldown on an item.

- mTrimPatterns: vector of TrimPattern - mTrimMaterials: vector of TrimMaterial

Whenever the serverside ContainerRegistry does a clean, identifiers for the removed containers are gathered in a ContainerRegistryCleanUp packet and sent to the client so that the clientside container registry can remove those same containers.

The player's screen options for one kind of furnace: which left-hand tab is open, whether the recipe list is filtered, and the layout it draws with.

This is fired from the client to the server and a SetCommandsEnabledPacket is sent back when enabling commands.

Lets scripts on the client and server exchange a named event with JSON payload.

Modern replacement for ScriptCustomEvent: scripts exchange named messages with an optional JSON payload between client and server.

Send primitive drawing shape info (from scripting) to the client for rendering.

It may be used to queue or stop a camera shake

The camera presets the level defines, sent during the join sequence.

Sent by the server to clients for initializing and updating the client aim-assist registry. AddToExisting operations are sent by the server when new presets/categories are added to the registry through creator facing APIs.

Sent by clients to the server for activating/deactivating aim-assist. Activation uses the CameraPreset Id for server-side lookup and uses its aim_assist field for aim-assist activation settings.

Sent from the server to the client when a server script changes the rendering settings.

Sent by the server to clients for initializing custom spline data that can be played later through the camera command.

Sent by the server to clients for updating the actor priority for client aim-assist systems.

Redirects the player to another server without leaving the world screen.

Sound playback with position, block/item runtime ids, entity type strings and per-sound extra data.

A jukebox began playing, so the client can show the record's name.

The server can redirect the user to a 3rd party server page, to a marketplace offer description page, or to a dressing room page containing desired offer.

Sent from the client after we make a purchase in the store OR if we login and our entitlements are verified. It sends a vector of purchase receipts(string).There is a handler and a multiple senders.

The only use in vanilla is a test command called ProfileCommand. It makes the user's xbox profile popup.

Currently transmits EducationLevelSettings to all clients when the game is starting.

This is EDU exclusively.It is sent once from _sendLevelData() in the start of a game from the server, and once per CodeBuilderCommand