Chat

Minecraft supports two-way chat communication via the Player Chat Message packet, which support a variety of formatting options. Note that this system isn't exclusive to the Chat Message packet - it's used in several other places (including written books, death messages, window titles, and the like).

Heads up! Currently out of date. 1.20.3+ encodes the JSON Chat into NBT in most cases when sent over the network (indicated via the Chat and Json Chat data types). How its converted in both directions needs to be documented.

Current system (JSON Chat)

Chat data is sent in JSON. For most situations, the JSON is strictly parsed, but lenient JSON parsing is used for the Disconnect packet and for written book text.

Inheritance

Each component can have multiple siblings. Each sibling component inherits properties from the style of its parent, using those styles if they are not defined in the sibling's own style.

For example, in this component:

{
    "text": "foo",
    "bold": true,
    "extra": [
        {
            "text": "bar"
        },
        {
            "text": "baz",
            "bold": false
        },
        {
            "text": "qux",
            "bold": true
        }
    ]
}

The text "foo", "bar", and "qux" are all rendered as bold while "baz" is not.

Schema

Each situation where a component can appear may be either a JSON object (the most common choice), an array, or a JSON primitive (which is converted to a String).

JSON primitives can be used for components, in which case they are implicitly converted into a String component. Note that it is invalid to have a JSON primitive as the root object, so it is not valid to merely send the text in quotes. This shorthand is useful for sibling lists, though.

It is also legal to put a JSON array where a component would go, so long as the array is not empty. The first component in the array is the parent of all of the following components. This can produce unusual behavior with style inheritance, but it is still useful shorthand.

The most common type of component is a JSON object; the format is as follows:

Shared between all components

All component types have certain fields that represent the style. All of these fields may be skipped, in which case the parent's style will be inherited.

bold

Boolean - if true, the component is emboldened.

italic

Boolean - if true, the component is italicized.

underlined

Boolean - if true, the component is underlined.

strikethrough

Boolean - if true, the component is struck out.

obfuscated

Boolean - if true, the component randomly switches between characters of the same width.

font

String - You can choose between minecraft:uniform (Unicode font), minecraft:alt (Enchanting table font) or minecraft:default (the default font, which switches based on the user's texture pack). This option is only valid on 1.16+, otherwise the property is ignored.

color

String - contains the color for the component. Should be one of the normal colors, but can also be a format code (however, the fields relating to styles should be used instead for that purpose) or any valid web color(since 1.16.x). If not present (or set to reset), then the default color for the text will be used, which varies by the situation (in some cases, it is white; in others, it is black; in still others, it is a shade of gray that isn't normally used on text).

insertion

String - contains text to insert. Only used for messages in chat. When shift is held, clicking the component inserts the given text into the chat box at the cursor (potentially replacing selected text). Has no effect on other locations at this time.

clickEvent

JSON object - Defines an event that occurs when this component is clicked. Contains the fields action and value, both strings.

action may be one of the following:

open_url

Opens the given URL in the default web browser. Ignored if the player has opted to disable links in chat; may open a GUI prompting the user if the setting for that is enabled. The link's protocol must be set and must be http or https, for security reasons.

open_file

Cannot be used within JSON chat. Opens a link to any protocol, but cannot be used in JSON chat for security reasons. Only exists to internally implement links for screenshots.

run_command

Runs the given command. Not required to be a command - clicking this only causes the client to send the given content as a chat message, so if not prefixed with /, they will say the given text instead. If used in a book GUI, the GUI is closed after clicking.

twitch_user_info

No longer supported; cannot be used within JSON chat. Only usable in 1.8 and below; twitch support was removed in 1.9. Additionally, this is only used internally by the client. On click, opens a twitch user info GUI screen. Value should be the twitch user name.

suggest_command

Only usable for messages in chat. Replaces the content of the chat box with the given text - usually a command, but it is not required to be a command (commands should be prefixed with /).

change_page

Only usable within written books. Changes the page of the book to the given page, starting at 1. For instance, "value":"1" switches the book to the first page. If the page is less than one or beyond the number of pages in the book, the event is ignored.

copy_to_clipboard

Copies the given text to the client's clipboard when clicked.

hoverEvent

JSON object - Defines an event that occurs when this component hovered over. Contains the fields action (a string) and contents (dependent on action).

The content field was introduced in Minecraft 1.16, replacing the old value field, which is still supported by new versions for compatibility. value functioned similarly to content, but was always interpreted as a chat component, with show_item and show_entity data represented as sNBT (e.g. "value":"{id:35,Damage:5,Count:2,tag:{display:{Name:Testing}}}").

action may be one of the following:

show_text

Displays a tooltip with arbitrary text. contents can either be a string directly ("contents":"la") or a full component ("contents":{"text":"la","color":"red"}).

show_item

Displays a tooltip describing an item. contents contains the following fields:

id

The textual identifier of the item's type. If unrecognized, defaults to minecraft:air.

count

The number of items in the item stack. If omitted, defaults to 1.

tag

The item's NBT information as an sNBT string (as would be used in /give) (if present).

show_entity

Displays a tooltip describing an entity. Shown only if Advanced tooltips (F3+H) is enabled. contents contains the following fields:

type

The textual identifier of the entity's type. If unrecognized, defaults to minecraft:pig.

id

The entity's UUID (with dashes). Does not need to correspond to an existing entity; only for display.

name

The entity's custom name (if present).

show_achievement

No longer supported. Since 1.12, this no longer exists; advancements instead simply use show_text. The ID of an achievement or statistic to display. Example: "value":"achievement.openInventory".

extra

An array of sibling components. If present, cannot be empty.

Beyond that, there are additional properties. Attempt to parse as each of the following in the order they are described:

String component

A String component contains only text. If the JSON contains a text key, then the component is a String component. The only content of this component is its text, with no additional processing.

Translation component

	The following information needs to be added to this page:
	Is using this with an invalid key intended or deprecated? Also, what exactly happens on invalid formats?

Translates text into the current language. If the JSON contains a translate key, then the component is a translation component.

Translation supports %s, %n$s (where n is an index) and %% format tokens. %% is just an escaped percent symbol. %s marks text to replace using content from the optional with tag. with is an array of components. %n$s acts like %s but instead will use the text component in with that is at the index of n.

It should be noted that when the key is not known by a language file, it will result in the translation key being the value of the text. For Example, soundCategory.hostile exists and will result in "Hostile Creatures" whereas soundCategory.angry (Which does not exist) will result in "soundCategory.angry".

Prior to 1.19.1 the narrator was hardcoded to replace the translation key chat.type.text with chat.type.text.narrate. This mechanism has been superseded by chat types, and is no longer present in new versions.

Keybind component

Displays the client's current keybind for the specified key. If the component contains a keybind key, then it is a keybind component. The value is named after the keys in options.txt (for instance, for key_key.forward in options.txt, key.forward would be used in the component and W would be displayed). For keys that are not known, the value provided should be displayed instead (for instance key.invalid would remain as key.invalid).

Score component

Displays a score. If the JSON contains a score key, then the component is a score component.

The score JSON object contains data about the objective.

When being sent to the client, it must contain name, objective, and value keys. name is a player username or entity UUID (if it is a player, it is a username); objective is the name of the objective; value is the resolved value of that objective.

When being sent to the server, value is not used. name can be an entity selector (that selects one entity), or alternatively * which matches the sending player.

Selector component

Displays the results of an entity selector. If the component contains a selector key, then it is a selector component.

This component is meant for client-to-server interactions (such as commands), and should not be sent directly to the client.

If received by the client, it won't be resolved, and will always be displayed as the selection pattern.

The server resolves the list selector into a list of entities, each with an appropriate hover event (and click event if it happens to be a player).

Entries in the list are separated by a comma by default, but can be overriden with any component if a separator is specified.

NBT component

Displays the results of a NBT query. If the component contains a nbt key, then it is a NBT component.

This component is meant for client-to-server interactions (such as commands), and should not be sent directly to the client.

If received by the client, it won't be resolved, and will always be displayed as empty text.

The server constructs a list using the data found at the nbt path, for each entry of a given source. This source varies, and is defined by the presence of one of the three following fields:

• block, where the data comes from the block entity at the given position;
• entity, where the data comes from the entities resulted from the given entity selector;
• storage, where the data comes from the internal storage defined by the given Identifier.

Entries in the list are separated by a comma by default, but can be overriden with any component if a separator is specified.

Furthermore, if the boolean interpret is set to true, the server will attempt to resolve each of the data as its own component, before appending them with the separator.

Examples

Here are some examples from the Notchian server for how chat formatting can be used.

TODO - additional examples

Standard chat message

The normal chat message uses a translation component along with some styling.

Since 1.19.1 the Notchian client uses the chat type mechanism, meaning chat messages are no longer sent directly like shown in this example.

{"translate":"chat.type.text","with":[{"text":"Herobrine","clickEvent":{"action":"suggest_command","value":"/msg Herobrine "},"hoverEvent":{"action":"show_entity","value":"{id:f84c6a79-0a4e-45e0-879b-cd49ebd4c4e2,name:Herobrine}"},"insertion":"Herobrine"},{"text":"I don't exist"}]}

The chat.type.text translation key becomes <%s> %s, which is then filled in with the player's name and the actual message. Note that the player's name has a click event (which inserts text to message the player), a hover event (which shows the entity ID; also note that type is missing), and an insertion (for the player's name).

Old system

Control Sequences

The client treats certain two-character sequences specially. The first character must be:

• § (U+00A7) for Minecraft
• & for Minecraft Classic

The following character indicates a certain color or formatting to apply to the proceeding text.

e.g.: This is white, but §4this is dark red. §lThis is still red, but also bold, while §rthis is neither.

In Minecraft Classic, the Notchian client expects that an escape code in a chat message will be followed by at least one character, and will otherwise crash with a StringIndexOutOfBoundsException. The server must sanitize outbound messages by removing any control characters at the end.

Styling

Colors

These correspond very roughly to the colors available in ANSI terminals.

Hex digit to color mapping

1. REDIRECT Text formatting/ColorSample

Sample	Common Name	Legacy Code	JSON Name	Foreground Color				Background Color
				R	G	B	Hex	R	G	B	Hex
Black	0	black	0	0	0	#000000	0	0	0	#000000
	Dark blue	1	dark_blue	0	0	170	#0000aa	0	0	42	#00002a
	Dark green	2	dark_green	0	170	0	#00aa00	0	42	0	#002a00
	Dark cyan	3	dark_aqua	0	170	170	#00aaaa	0	42	42	#002a2a
	Dark red	4	dark_red	170	0	0	#aa0000	42	0	0	#2a0000
	Purple	5	dark_purple	170	0	170	#aa00aa	42	0	42	#2a002a
	Gold	6	gold	255	170	0	#ffaa00	42	42	0	#2a2a00
	Gray	7	gray	170	170	170	#aaaaaa	42	42	42	#2a2a2a
	Dark gray	8	dark_gray	85	85	85	#555555	21	21	21	#151515
	Blue	9	blue	85	85	255	#5555ff	21	21	63	#15153f
	Bright green	a	green	85	255	85	#55ff55	21	63	21	#153f15
	Cyan	b	aqua	85	255	255	#55ffff	21	63	63	#153f3f
	Red	c	red	255	85	85	#ff5555	63	21	21	#3f1515
	Pink	d	light_purple	255	85	255	#ff55ff	63	21	63	#3f153f
	Yellow	e	yellow	255	255	85	#ffff55	63	63	21	#3f3f15
	White	f	white	255	255	255	#ffffff	63	63	63	#3f3f3f

Styles

The "Random" style is used for the "§kFUNKY LOL" message in /title/splashes.txt inside minecraft.jar.

Sample	Style	Legacy Code	JSON Name
	Random	k	obfuscated
	Bold	l	bold
	Strikethrough	m	strikethrough
	Underlined	n	underline
	Italic	o	italic
	Plain White	r	reset

Fonts

Since Minecraft 1.16 it has been possible to add custom fonts via resource packs, and use them in text components through the font field.

By default, the following fonts are available:

Identifier	Default Look	Notes
minecraft:default	Standard Minecraft font (with Unifont fallback)	Default font. Hardcoded to alias minecraft:uniform when Force Unicode Font is enabled.
minecraft:uniform	GNU Unifont	Default font when Force Unicode Font is enabled.
minecraft:alt	Standard Galactic Alphabet	Enchanting table font.
minecraft:illageralt	Illageralt from Minecraft Dungeons	Unused.

Processing chat

Client chat mode

The client may use the Chat Mode field of the Client Information packet to indicate that it only wants to receive some types of chat messages.

It is the server's responsibility to not send packets if the client has the given type disabled. However, it is the client's responsibility to not send incorrect chat packets.

Here's a matrix comparing what packets the server should send to a clients based on their chat settings:

Clientbound packet	Client setting			Usage
	Full	Commands only	Hidden
Player Chat Message	✔	✘	✘	Player-initiated chat messages, including the commands /say, /me, /msg, /tell, /w and /teammsg.
Disguised Chat Message	✔	✘	✘	Messages sent by non-players using the commands /say, /me, /msg, /tell, /w and /teammsg.
System Chat Message	✔	✔	✘	Feedback from running a command, such as "Your game mode has been updated to creative."
System Chat Message (overlay)	✔	✔	✔	Game state information that is displayed above the hot bar, such as "You may not rest now, the bed is too far away".

Here's a matrix comparing what the client may send based on its chat setting:

Serverbound packet	Client setting
	Full	Commands only	Hidden
Chat Message	✔	✘	✘
Chat Command	✔	✔	✘

If the client attempts to send a chat message and the server rejects it, the Notchian server will send that client a System Chat Message (non-overlay) with a red chat.disabled.options translation component (which becomes "Chat disabled in client options.").

Social Interactions (blocking)

1.16 added a social interactions screen that lets players block chat from other players. Blocking takes place clientside by detecting whether a message is from a blocked player.

Player Chat Message packets are blocked based on the included sender UUID.

Disguised Chat Message packets are never blocked.

System Chat Message packets (regardless of the Overlay field!) are blocked based on the first occurrence of <playername> anywhere in the message, including split across multiple chat components, where playername may be any text, including the empty string or whitespace. If playername is the name of a blocked player (matched case-sensitively), the message is blocked. This only occurs if Hide Matched Names is enabled in Chat Settings (the default).