Reference

JSON glossary

This JSON glossary defines the terms you meet when you work with JSON, in plain English. It covers syntax and data types, JSON Schema keywords like const, JSONPath, JWT claims like jti, Unix timestamps in seconds and milliseconds, and the APIs that move JSON around. There are 176 terms across 10 topics, and many link to a free tool you can try them in.

176 terms · updated 2026-10-01

JSON core and syntax

The values, structure and grammar rules that make up JSON.

application/json media type#JSON MIME type · content-type application/json: application/json is the official media type (MIME type) for JSON, used in the HTTP Content-Type and Accept headers. It tells the receiver to parse the body as JSON text. RFC 8259 requires UTF-8, so the media type has no charset parameter.MIME Type Lookup HTTP Headers Parser
Boolean#true · false: A JSON boolean is one of two literals, true or false, written in lowercase without quotes. The tokens are case-sensitive, so True or FALSE cause a parse error. "true" in quotes is valid, but it is a string, not a boolean.
Comments in JSON#JSON comments: JSON does not allow comments, so both // line comments and /* block */ comments make a document invalid. Douglas Crockford left them out on purpose so parsers could not be misused for directives. To keep notes in data, add a string field such as "_comment", or use a format that allows comments, like JSONC, JSON5 or YAML.JSON5 / JSONC to JSON JSON Validator JSON ⇄ YAML
Duplicate keys#repeated keys: Duplicate keys are the same member name appearing more than once in one JSON object, like {"a": 1, "a": 2}. RFC 8259 says keys should be unique but does not forbid repeats, so the result depends on the parser. JavaScript's JSON.parse keeps the last value, while other parsers may keep the first or throw an error.Read more about Duplicate keys →JSON Validator
Escape sequence#escape character: An escape sequence is a backslash followed by a character, used inside a JSON string to write a character that cannot appear as is. JSON defines eight short escapes: \" \\ \/ \b \f \n \r \t. It also has the \uXXXX form for any code point, and a raw newline or unescaped quote inside a string is invalid JSON.JSON Escape / Unescape
Insignificant whitespace#whitespace: Insignificant whitespace is the spaces, tabs, carriage returns and line feeds allowed between JSON tokens, which never change the parsed value. Pretty-printing adds it and minification removes it. RFC 8259 allows only these four characters, and only between tokens, never inside a number or literal.JSON Formatter JSON Minifier
JSON (JavaScript Object Notation)#JSON format: JSON (JavaScript Object Notation) is a text format for storing and exchanging data, built from objects, arrays, strings, numbers, booleans and null. Its syntax comes from JavaScript object literals, but almost every language can read and write it. It is the default format for web APIs, config files and message payloads.JSON Formatter JSON Validator
JSON array#array · list: A JSON array is an ordered list of values inside square brackets, separated by commas, like [1, "two", null]. Elements can mix types, including nested objects and arrays. An array of objects with the same keys is the shape most tools expect when converting JSON to CSV.JSON Formatter JSON to CSV
JSON number#number: A JSON number is a base-10 value with an optional minus sign, fraction and exponent, like -12.5e3. Leading zeros, a leading plus, hex notation, NaN and Infinity are not allowed. JSON has one number type, so whether 3 becomes an integer or a float depends on the language that parses it.
JSON object#object: A JSON object is an unordered set of key/value pairs inside curly braces, like {"name": "Ada", "age": 36}. Each key is a double-quoted string followed by a colon and a value, and pairs are separated by commas. Values can be any JSON type, including nested objects and arrays.JSON Formatter JSON to TypeScript
JSON string#string: A JSON string is a sequence of Unicode characters inside double quotes. Single quotes are not valid. Double quotes, backslashes and control characters such as newline must be escaped with a backslash.JSON Escape / Unescape
Key/value pair (member)#member · name/value pair · property: A key/value pair, called a member in RFC 8259, is one entry in a JSON object: a double-quoted string key, a colon and any JSON value, like "email": "a@b.com". Keys can be any string, so field names with spaces, like "first name", are valid JSON. You read such keys with bracket notation, as in obj["first name"], and keys in one object should be unique.Read more about Key/value pair (member) →
null#JSON null: null is the JSON literal for an empty or unknown value, written in lowercase without quotes. It is different from a missing key, an empty string or 0. Languages map it to None, nil or null, and APIs differ on whether they send null or leave the key out.
RFC 8259#STD 90 · ECMA-404: RFC 8259 is the IETF standard that defines JSON, published in December 2017 as Internet Standard 90 (STD 90). It replaced RFC 7159, which had replaced the original RFC 4627, and it requires UTF-8 for JSON exchanged between systems. ECMA-404 from Ecma International defines the same grammar.JSON Validator
Structural characters#: The structural characters are the six tokens that give JSON its shape: the square brackets, the curly braces, the colon and the comma. Brackets wrap arrays, braces wrap objects, the colon separates a key from its value, and the comma separates items. Whitespace around them is allowed and ignored.JSON Formatter JSON Validator
Trailing comma#dangling comma: A trailing comma is a comma after the last item in a JSON array or object, like [1, 2,] or {"a": 1,}. JSON does not allow it, so strict parsers reject both examples. JavaScript and JSON5 accept trailing commas, which is why they often slip into hand-edited JSON.Read more about Trailing comma →JSON Validator JSON Repair JSON5 / JSONC to JSON
Unicode escape sequence#\uXXXX · unicode escape: A Unicode escape writes a character as \u plus four hex digits, like \u00e9 for é, so a JSON string can hold any character using only ASCII. Characters above U+FFFF, such as most emoji, need a surrogate pair of two escapes. A parser turns each escape back into the original character.JSON Escape / Unescape

Data types and structures

How JSON values map to the data types and structures you use in code.

Associative array#hash · hash map: An associative array is a collection that stores values by key instead of by numeric index. A JSON object is an associative array with string keys. Other languages call the same idea a dictionary, hash or hash map.
Compound value#composite value · container value: A compound value is a value made of other values, as opposed to a single scalar. JSON has two compound types, objects and arrays, and they can nest to any depth. A parser recurses into compound values and stops at scalars.
Empty array#: An empty array, written [], is a valid JSON list with zero items. It says the list exists but has no elements, which is different from null or a missing field. Returning [] instead of null lets clients loop over the result without a null check.
Empty object#: An empty object, written {}, is a valid JSON object with no key/value pairs. It says a structure exists but has no fields yet, while null says there is no value at all. It is a common default when you build an object before adding keys.
Flat JSON#flat structure: Flat JSON is data with little or no nesting, where values are mostly strings, numbers, booleans or null. It maps directly to rows and columns, so JSON is usually flattened before it is converted to CSV. Flattening joins nested keys into one path, so address.city becomes a single column header.JSON Flattener JSON to CSV
Heterogeneous array#mixed-type array: A heterogeneous array holds elements of different types or shapes, like [1, "two", {"three": 3}]. JSON allows this, but it makes typing harder. Schema and type generators usually fall back to a union type, and typed languages may need a wrapper type to hold the values.JSON to TypeScript JSON Schema Generator
Homogeneous array#: A homogeneous array holds elements that all share one type or shape, such as a list of numbers or a list of objects with the same keys. JSON does not require it. Type and schema generators work best with homogeneous arrays because they can infer one element type.JSON to TypeScript JSON Schema Generator
Leaf node#leaf: A leaf node is a node with no children, the end of a branch in a tree. In JSON the leaves are the scalar values: strings, numbers, booleans and null. Path queries usually resolve to leaves, and flattening a document lists every leaf with its key path.JSONPath Tester
Map#hash map: A map is a data structure that stores values by key, like JavaScript's Map, Java's HashMap or Go's map. A JSON object corresponds to a map, but JSON.parse returns a plain object, so you convert it with new Map(Object.entries(obj)). A Map can use keys of any type, while JSON keys are always strings.JSON to TypeScript
Nested JSON#deeply nested data · nested data: Nested JSON is JSON with objects or arrays inside other objects or arrays. It lets one document hold related data together, like a user with an address that has a list of phone numbers. Deep nesting makes values harder to reach and flatten, which is why path languages such as JSONPath exist.JSONPath Tester JSON Flattener JSON to CSV
Ordered collection#sequence: An ordered collection keeps its elements in a fixed sequence. In JSON the array is ordered, and parsers must keep element order. Reordering an array changes the data, while reordering object keys does not.JSON to CSV
Scalar value#atomic value · scalar: A scalar value is a single value that holds one piece of data, not a collection. In JSON the scalars are strings, numbers, booleans and null. Each scalar maps to one cell when you flatten JSON into CSV or database columns.JSON to CSV
Tree structure#hierarchical data · tree: A tree structure is a hierarchy of nodes that starts at one root, where each node has one parent and any number of children. Every JSON document is a tree. Objects and arrays are the branches and scalar values are the leaves, which is how editors render collapsible tree views.JSON Formatter JSONPath Tester
Unordered collection#: An unordered collection identifies elements by key, not by position, so their order has no meaning. RFC 8259 treats a JSON object as unordered, so two objects with the same members in a different order are equal. Most parsers keep insertion order anyway, but code should not rely on it, and diff tools usually ignore key order.JSON Diff / Compare

JSON dialects and variants

Formats built on JSON, plus binary formats that trade readable text for size and speed.

Amazon Ion#Ion: Amazon Ion is a data format from Amazon with a text encoding and a binary encoding of the same data model. Its text form is a superset of JSON, so any JSON document is valid Ion. Ion adds types JSON lacks, such as timestamps, arbitrary-precision decimals, symbols, blobs and type annotations.
BSON#Binary JSON: BSON (Binary JSON) is the binary format MongoDB uses to store documents and send data. It adds types JSON lacks, such as dates, 64-bit integers, decimal128, binary data and ObjectIds. Each element carries length information for fast scanning, so BSON is often larger than the same data as JSON text.
Canonical JSON#Deterministic JSON · JCS: Canonical JSON is a way to serialize data so equal values always produce the same bytes. The rules usually fix key order, remove whitespace and normalize numbers and string escapes. The JSON Canonicalization Scheme (JCS, RFC 8785) is the IETF standard, used when you hash, sign or compare JSON.JSON Sorter JSON Diff / Compare
CBOR#Concise Binary Object Representation: CBOR (Concise Binary Object Representation) is a binary data format defined in RFC 8949, based on the JSON data model. It needs no schema, supports streaming, and uses tags for extra types such as dates and big numbers. COSE, CWT and WebAuthn all use CBOR.
GeoJSON#: GeoJSON is a JSON format for geographic data such as points, lines and polygons, standardized as RFC 7946. Each feature has a geometry and a properties object. Coordinates are listed as longitude then latitude in WGS84, and most mapping libraries read GeoJSON directly.JSON Validator
HAL#Hypertext Application Language: HAL (Hypertext Application Language) is a convention for adding links to JSON API responses. Links go under a reserved _links object and related resources under _embedded, each named by a relation. Clients follow these links instead of hardcoding endpoint paths.JSONPath Tester
Hjson#Human JSON: Hjson (Human JSON) is a JSON syntax extension for config files that people edit by hand. It allows comments and multi-line strings, and makes quotes and commas optional. Tools parse Hjson and output standard JSON for programs to read.JSON Formatter
JSON Text Sequences#json-seq · RFC 7464: JSON Text Sequences is a format, defined in RFC 7464 with the media type application/json-seq, for a stream of JSON values that each start with the ASCII record separator character (U+001E) and end with a newline. The leading separator lets a reader recover after a truncated or broken record, which NDJSON cannot do. It is meant for logs and streams that append values over time.
JSON-LD#JSON for Linked Data: JSON-LD (JSON for Linked Data) is a W3C standard for describing linked data in plain JSON. A @context maps keys to global identifiers called IRIs, so their meaning is clear across systems. Search engines read schema.org markup written in JSON-LD to show rich results.JSON Validator
JSON:API#JSON API: JSON:API is a specification for how JSON APIs shape their requests and responses. It defines a top-level data member, resource objects with a type and id, relationships, included resources, pagination, filtering and sparse fieldsets. It uses the media type application/vnd.api+json, so shared client libraries work with any compliant API.JSONPath Tester
JSON5#: JSON5 is a superset of JSON for hand-written config files. It allows comments, trailing commas, single quotes, unquoted keys, hex numbers, leading or trailing decimal points and multi-line strings. Standard JSON parsers reject JSON5, so it needs its own parser and is usually converted to plain JSON before use.JSON5 / JSONC to JSON JSON Validator
JSONC#JSON with Comments: JSONC (JSON with Comments) is JSON that also allows // line comments and /* */ block comments. VS Code uses it for its settings files, and it often accepts trailing commas too. JSON.parse rejects comments, so JSONC needs a lenient parser or must have its comments stripped first.JSON5 / JSONC to JSON JSON Minifier
JSONP#JSON with Padding: JSONP (JSON with Padding) is an old technique for loading data from another origin by wrapping JSON in a function call and loading it with a script tag. Script tags are not limited by the same-origin policy, so the browser runs the response as code. CORS (Cross-Origin Resource Sharing) has replaced it, and JSONP is unsafe because the page executes whatever the server returns.
MessagePack#msgpack: MessagePack is a binary serialization format with the same data model as JSON but a much smaller encoding. Small integers and short strings fit in one or a few bytes, and it supports raw binary and extension types. It is used for caching, messaging and APIs where size matters more than readability.JSON Minifier
MongoDB Extended JSON#Extended JSON · EJSON: MongoDB Extended JSON (EJSON) is a way to write BSON types in plain JSON text so they survive tools that only understand JSON. Types JSON lacks, such as dates, ObjectIds and 64-bit integers, are wrapped in reserved keys like {"$oid": ...} or {"$date": ...}. It has relaxed and canonical modes, and mongoexport and mongoimport read and write it.JSON Validator
NDJSON#JSON Lines · JSONL: NDJSON (newline-delimited JSON), also called JSON Lines or JSONL, stores one JSON value per line. Each line can be parsed on its own, so large files and streams never have to be loaded at once. The file as a whole is not valid JSON, which lets producers append records.Read more about NDJSON →JSON ⇄ JSONL JSON to CSV
TopoJSON#: TopoJSON is an extension of GeoJSON that stores shared borders, called arcs, once instead of repeating coordinates for each shape. This removes duplication and can make map files much smaller. It also supports quantized integer coordinates, and clients usually convert it back to GeoJSON before drawing.
UBJSON#Universal Binary JSON: UBJSON (Universal Binary JSON) is a binary format that mirrors the JSON data model exactly. Each value starts with a one-byte type marker. Its only additions are explicit integer widths and a byte type, so UBJSON converts to and from JSON without loss.

Schema and validation

How to describe the shape of JSON and validate documents against it.

$defs keyword#: $defs is the JSON Schema keyword for storing reusable subschemas that other parts of the schema reference with $ref. It does no validation by itself and replaced the older definitions keyword. It also makes recursive shapes easy, like a tree node that references itself through #/$defs/node.JSON Schema Generator
$id keyword#: The $id keyword gives a JSON Schema or subschema a base URI that other schemas can point to with $ref. Relative references inside it resolve against that URI. A stable $id lets you register, cache and share schemas across files.JSON Schema Generator
$ref keyword#reference · JSON reference: The $ref keyword points to another schema by URI or JSON Pointer, such as #/$defs/address, and validates the value against it. It lets you define a shape once and reuse it. It also lets you split a schema across files or describe recursive data.JSON Schema Generator
$schema keyword#: The $schema keyword declares which JSON Schema draft a schema uses, as a URI such as https://json-schema.org/draft/2020-12/schema. Validators read it to decide which keywords and rules apply. Without it, many validators fall back to a default draft without warning.JSON Validator
additionalProperties keyword#: The additionalProperties keyword controls whether a JSON object may have keys that are not listed in properties or patternProperties. Set it to false to reject unknown keys, or to a schema to constrain their values. It is the usual way to catch typos and unexpected fields in API request bodies.JSON Validator
Conditional subschemas (if/then/else)#if/then/else: The if, then and else keywords add conditional validation to JSON Schema. If a value matches the if schema it must also match then, and otherwise it must match else. For example, a schema can require routingNumber only when "method" is "bank", and the keywords have existed since Draft 7.JSON Validator
const keyword#JSON Schema const · JSON Schema constant: The const keyword in JSON Schema requires a value to equal one fixed constant, such as "const": "invoice". The constant can be any JSON type, and objects or arrays must match exactly, including nested values. It works like a one-item enum and is often used to pin a discriminator field like "type" in a tagged union.Read more about const keyword →JSON Schema Generator JSON Validator
enum keyword#: The enum keyword limits a value to a fixed list of allowed options, such as ["draft", "published", "archived"]. The value must exactly equal one entry, and entries can be any JSON type, not only strings. Use const instead when only one value is allowed.JSON Schema Generator JSON to TypeScript
format keyword#: The format keyword names a known string format such as email, uri, date-time, uuid or ipv4. Validators differ here. Some treat format only as an annotation and some enforce it, depending on the tool and its settings, and custom formats need the pattern keyword.JSON Validator
items keyword#: The items keyword sets the schema every array element must match, such as an array of integers. Since Draft 2020-12, prefixItems describes fixed positions at the start of an array, and items applies only to the elements after them. minItems, maxItems and uniqueItems control size and uniqueness.JSON Schema Generator
JSON Schema#: JSON Schema is a vocabulary, written in JSON, for describing the structure, types and constraints a JSON document must follow. A validator checks a document against the schema and reports every mismatch. Teams use it to validate API payloads and config files, generate forms and write documentation.Read more about JSON Schema →JSON Schema Validator JSON Schema Generator Mock JSON Data Generator
JSON Schema Draft 2020-12#Draft 2020-12 · 2020-12 dialect: Draft 2020-12 is the latest published version of the JSON Schema specification, released in December 2020. It replaced the items and additionalItems array handling with prefixItems and items, and replaced $recursiveRef with $dynamicRef and $dynamicAnchor. Drafts are not always backward compatible, so declare the draft with the $schema keyword.JSON Schema Generator JSON Validator
Meta-schema#: A meta-schema is a JSON Schema that describes what valid schemas look like, so a schema can be validated like any other document. Each draft publishes a meta-schema at a stable URI, and the $schema keyword points to it. Validators use it to catch misspelled keywords and values of the wrong type.JSON Validator JSON Schema Generator
minimum and maximum keywords#: The minimum and maximum keywords set inclusive bounds on a number, and exclusiveMinimum and exclusiveMaximum set strict bounds. minLength and maxLength do the same for string length, and minItems and maxItems for array size. They catch values like a negative age or an oversized list before they reach your code.JSON Validator
pattern keyword#: The pattern keyword requires a string to match a regular expression, such as ^[A-Z]{2}\d{4}$ for a product code. The match is unanchored unless you add ^ and $, and JSON Schema uses ECMAScript regex syntax. It covers formats the format keyword does not, like custom IDs, URL slugs or local phone numbers.JSON Validator
patternProperties keyword#: The patternProperties keyword applies a subschema to every object key that matches a regular expression. It validates objects with dynamic keys, such as IDs that must each map to a number. Keys matched by neither properties nor patternProperties are then handled by additionalProperties.JSON Schema Generator JSON Validator
properties keyword#: The properties keyword maps object keys to the schemas their values must match. It only checks keys that are present and does not make any key mandatory, which is the job of required. Unlisted keys are allowed unless additionalProperties forbids them.JSON Schema Generator
required keyword#: The required keyword lists the keys a JSON object must contain, as an array of strings like ["id", "email"]. It only checks that each key is present. The type and format of each value come from properties, and a missing key produces a validation error.JSON Validator
Schema composition (oneOf, anyOf, allOf, not)#combinators · applicator keywords: oneOf, anyOf, allOf and not combine subschemas with boolean logic in JSON Schema. allOf requires every subschema to match, anyOf at least one and oneOf exactly one, while not requires its subschema to fail. If oneOf branches overlap, a value can match two of them and fail, which is a common source of confusing errors.JSON Validator JSON Schema Generator
Schema inference#schema generation · type inference: Schema inference generates a schema or type definition from example JSON instead of writing it by hand. The tool reads each value to guess its type, marks fields that are sometimes missing as optional, and merges different shapes into unions. The output, such as JSON Schema or a TypeScript interface, usually needs edits because samples rarely cover every case.JSON Schema Generator JSON to TypeScript
Schema validation error#validation error: A schema validation error is the message a validator returns when a JSON document breaks a schema rule. It usually names the failing keyword, gives the location in the document as a JSON Pointer, and includes a readable message. A parse error means the JSON is malformed, while a validation error means it is valid JSON with the wrong shape.JSON Validator
type keyword#: The type keyword limits a value to one JSON Schema type: string, number, integer, boolean, object, array or null. integer exists only in JSON Schema, since JSON itself has one number type. Pass an array such as ["string", "null"] to allow more than one type, for example a nullable string.JSON Schema Generator JSON to TypeScript
unevaluatedProperties keyword#: The unevaluatedProperties keyword applies to object keys that no other keyword has checked, including keys checked inside allOf, anyOf or oneOf. additionalProperties cannot see into those subschemas, so unevaluatedProperties is the way to forbid extra keys in a schema built by composition. It was added in Draft 2019-09, and unevaluatedItems does the same for arrays.JSON Validator

Querying and transformation

How to address, extract and patch values inside a JSON document.

Array slice#slice · array slicing: An array slice selects a range of elements using start, end and optional step values, a syntax borrowed from Python. In JSONPath, $.items[0:3] returns the first three items, [-2:] the last two, and [::2] every second one. The end index is excluded, and negative numbers count from the end.JSONPath Tester
Dot notation vs bracket notation#dot notation · bracket notation: Dot notation and bracket notation are the two ways to step into a key in a path expression. Dot notation, like $.user.name, is short but only works when the key is a plain identifier. Bracket notation, like $['user']['first name'], works for any key, including keys with spaces or hyphens, and also holds array indexes like [0].JSONPath Tester
Filter expression#filter · predicate: A filter expression selects array elements that match a condition instead of selecting them by position. In JSONPath it looks like $.books[?(@.price < 10)], where @ is the element being tested. JMESPath uses [?expr] filters, and jq uses select().JSONPath Tester
JMESPath#: JMESPath is a query language for extracting and reshaping data from JSON. It supports keys, indexes, wildcards, slices, projections, filters, functions and pipes. It has a formal grammar and a shared test suite, so implementations agree, and the AWS CLI uses it for its --query option.JMESPath Tester
jq#: jq is a command-line tool and language for filtering and transforming JSON. Filters are joined with a pipe (|), so each stage feeds the next, as in jq '.items[] | .name'. It is common in shell scripts and CI pipelines for reshaping API responses.Read more about jq →jq Tester JSONPath Tester
JSON Merge Patch (RFC 7386)#RFC 7386 · Merge Patch: JSON Merge Patch (RFC 7386) is a format where the patch is a partial JSON document that gets merged into the target. Keys in the patch overwrite or merge into the target, and a key set to null deletes it. It cannot set a value to null or change a single array element, and its media type is application/merge-patch+json.JSON Patch / Merge Patch JSON Diff / Compare
JSON Patch (RFC 6902)#RFC 6902: JSON Patch (RFC 6902) is a format that describes changes to a JSON document as an array of operations, like {"op": "replace", "path": "/name", "value": "Ada"}. Each operation has an op, which is add, remove, replace, move, copy or test, and a JSON Pointer path. It is sent with HTTP PATCH and the media type application/json-patch+json, and the test operation can guard against concurrent edits.Read more about JSON Patch (RFC 6902) →JSON Patch / Merge Patch JSON Diff / Compare
JSON Pointer (RFC 6901)#RFC 6901 · JSON Pointer: A JSON Pointer (RFC 6901) is a string that identifies one value in a JSON document, like /users/0/name. Each slash-separated token is an object key or an array index, and a ~ or / inside a key is written as ~0 or ~1. JSON Patch, the $ref keyword and validation errors all use pointers.Read more about JSON Pointer (RFC 6901) →JSONPath Tester
JSONata#: JSONata is a query and transformation language for JSON, inspired by XPath 3.1. Besides paths, wildcards and predicates, it has arithmetic, string and aggregate functions, conditionals, variables and user-defined functions. One expression can turn an input document into a completely different shape, and it is common in integration and low-code tools.
JSONPath#RFC 9535: JSONPath is a query language that selects values from a JSON document with path expressions like $.store.book[0].title. A query starts at the root ($) and uses dot or bracket steps, wildcards, filters and recursive descent. Stefan Goessner proposed it in 2007, and RFC 9535 standardized it in 2024.Read more about JSONPath →JSONPath Tester
Projection#: A projection applies an expression to every element of a collection and collects the results into a new list. In JMESPath, people[*].name returns every person's name, and multiselect syntax can build a new object for each item. It is similar to a SQL SELECT column list or jq's map.JMESPath Tester JSON to CSV
Recursive descent#deep scan · ..: Recursive descent is the JSONPath operator .. that searches every level of a document instead of one. $..author finds every author key anywhere in the tree. It helps with irregular data, but it can be slow on large documents and may match more than you expect.JSONPath Tester
Root node identifier ($)#$ · root selector: The root node identifier is the dollar sign ($) that starts a JSONPath expression and stands for the whole document. $.store.book[0] goes from the root into store, then book, then the first element. Inside filters, @ refers to the current element, while jq uses a leading dot for the root and JMESPath has no root symbol.JSONPath Tester
SQL/JSON#: SQL/JSON is the part of the SQL standard, added in SQL:2016, for storing, querying and generating JSON in relational databases. It includes JSONPath-style path expressions, JSON_EXISTS, JSON_VALUE, JSON_QUERY and JSON_TABLE, which turns JSON into rows and columns. PostgreSQL, Oracle and SQL Server each implement parts of it.JSONPath Tester
Structural diff#JSON diff · semantic diff: A structural diff compares two JSON documents by their parsed values instead of their text. It reports added, removed and changed values by path, and ignores whitespace and usually key order. That avoids the noise of a line-based diff, and the result can be turned into a JSON Patch.JSON Diff / Compare
Wildcard#wildcard selector · *: A wildcard (*) is a path selector that matches every child at one level instead of one key or index. In JSONPath, $.items[*].price returns the price of each item, and $.* returns all top-level values. It returns a list of matches, so it is the usual way to query arrays of unknown length.JSONPath Tester

Serialization and processing

How data becomes JSON text and back again: parsing, stringifying and the steps in between.

Deserialization#Decoding: Deserialization turns serialized data, such as JSON text, back into in-memory objects, arrays and values. JSON.parse in JavaScript and json.loads in Python both deserialize JSON. Validate untrusted input against a schema before your code uses the result.JSON Validator
JSON parser#Parser: A JSON parser is code that reads JSON text and turns it into in-memory values or a stream of events. A conforming parser accepts every valid RFC 8259 document and rejects malformed input. Strict parsers also reject extras such as comments and trailing commas.JSON Validator JSON Formatter
JSON.parse#: JSON.parse is the built-in JavaScript method that converts a JSON string into a JavaScript value. It throws a SyntaxError if the text is not valid JSON, so wrap untrusted input in try/catch. An optional reviver function can transform each key/value pair, for example to turn ISO 8601 strings into Date objects.JSON Validator
JSON.stringify#stringify: JSON.stringify is the built-in JavaScript method that converts a value into a JSON string. Its optional replacer filters or changes values, and its space argument sets indentation, as in JSON.stringify(data, null, 2). Functions, undefined and symbols are dropped from objects and become null in arrays, and an object with a toJSON method is serialized from that method's return value.JSON Formatter JSON Minifier
Marshalling / Unmarshalling#Marshaling · Unmarshaling: Marshalling is another word for serialization, turning an in-memory object into a format for storage or transfer, and unmarshalling is the reverse. The terms are common in Go, Java and RPC (remote procedure call) systems. Go's encoding/json has Marshal and Unmarshal functions that use struct tags to map field names.JSON to Go JSON to TypeScript
Minification#Minify · Compact JSON: Minification removes all insignificant whitespace from JSON to produce the smallest valid text. The parsed data is the same as the pretty-printed version. APIs usually send minified JSON to save bytes, and JSON.stringify without a space argument outputs it by default.JSON Minifier JSON Formatter
Parsing#: Parsing is reading JSON text by the RFC 8259 grammar and turning it into a structured, in-memory value. The parser splits the characters into tokens and checks that braces, brackets, commas, colons and quotes form a valid document. Invalid input produces a syntax error, usually with a line and column.JSON Validator JSON Formatter
Pretty-print / Beautify#Beautify · Prettify · Format: Pretty-printing, or beautifying, reformats JSON with indentation and line breaks so people can read its structure. Only the whitespace between tokens changes, never the data. In JavaScript, JSON.stringify(value, null, 2) indents with two spaces, and pretty-printed JSON gives cleaner diffs in version control.JSON Formatter
Replacer function#replacer: A replacer is the optional second argument to JSON.stringify that controls what gets serialized. As a function, it runs for every key/value pair and its return value is written out, and returning undefined drops the key. As an array of strings, it serializes only the listed keys, which helps strip secrets or shrink payloads.JSON Formatter
Reviver function#reviver: A reviver is the optional second argument to JSON.parse, a function called for every key/value pair as the result is built. It runs from the innermost values outward, its return value replaces the original, and returning undefined deletes the key. Common uses are turning ISO 8601 strings into Date objects or numeric strings into BigInt.
Round-trip fidelity#Round-tripping · Lossless round-trip: Round-trip fidelity is whether data comes back unchanged after you serialize it and parse it again. JSON does not keep whitespace or guarantee key order, and integers above 2^53 can lose precision as IEEE 754 doubles. Date objects come back as strings and JSON.stringify throws on BigInt, which matters when you compare, hash or sign JSON.JSON Diff / Compare
Serialization#Serializing · Encoding: Serialization converts an in-memory data structure, such as an object, array or map, into text or bytes that can be stored or sent. For JSON it means producing JSON text, as JSON.stringify in JavaScript or json_encode in PHP do. Any platform with a JSON parser can then rebuild the data.JSON Formatter JSON Minifier
Streaming parser (SAX-style)#SAX parsing · Event-based parsing: A streaming parser reads JSON piece by piece and emits events, such as start of object, key, value and end of array, without loading the whole document into memory. It follows the SAX (Simple API for XML) model and suits files or network streams too large for memory. The cost is more complex, callback-driven code than a single JSON.parse call.
String escaping#Escape · Unescape: String escaping replaces characters that cannot appear raw in a JSON string with backslash sequences. A double quote becomes \", a backslash becomes \\, and a newline or tab becomes \n or \t, while any character can be written as \uXXXX. You need it when you embed one JSON document inside another as a string, and unescaping turns the sequences back into the original text.JSON Escape / Unescape
Tokenizer / Lexer#Lexer · Scanner · Lexical analysis: A tokenizer, or lexer, is the first stage of a parser, which groups raw JSON characters into tokens. Tokens are strings, numbers, punctuation and the literals true, false and null. The parser then checks the order of those tokens, and keeping the two stages apart makes it easier to report errors at exact positions.JSON Validator

Web APIs and data exchange

How JSON moves between clients and servers over HTTP.

Accept header#Accept: The Accept header tells the server which response formats the client can handle, for example Accept: application/json. The server uses it to choose a format, so one endpoint can return JSON, XML or something else. This process is called content negotiation.HTTP Headers Parser
API#Application Programming Interface: An API (application programming interface) is a defined contract that lets one program request data or actions from another. Most web APIs send and receive JSON because it is light, language-neutral and quick to parse. A stable API lets web apps, mobile apps and third parties use the same backend.Mock JSON Data Generator
Content negotiation#conneg: Content negotiation is how a client and server agree on the format of a response. The client states its preferences in headers such as Accept and Accept-Language. The server picks a matching format and confirms it in the Content-Type header, so one URL can serve JSON to one client and XML or HTML to another.JSON ⇄ XML
Content-Type header#Content-Type · media type header: The Content-Type header states the media type of a message body so the receiver knows how to parse it. For JSON the value is application/json. Sending the wrong Content-Type is a common bug that makes a server ignore the JSON body or reject the request with 415 Unsupported Media Type.HTTP Headers Parser MIME Type Lookup
CORS#Cross-Origin Resource Sharing: CORS (Cross-Origin Resource Sharing) is the browser mechanism that decides whether a page on one origin can call an API on another origin. The server allows it by returning headers such as Access-Control-Allow-Origin, and the browser may send a preflight OPTIONS request first. That is why a fetch can fail in the browser but work from curl or a server.
Endpoint#API endpoint · route: An endpoint is a URL where an API exposes a resource or action, such as /users/42 or /orders. Clients send HTTP requests to it and usually get JSON back. Each endpoint accepts certain HTTP methods, like GET or POST.
ETag#: An ETag (entity tag) is a response header that identifies one version of a resource, often a hash of its content. Clients send it back in If-None-Match to check a cache and get 304 Not Modified if nothing changed. Sent in If-Match, it makes a write fail with 412 Precondition Failed if someone else changed the resource first.
GraphQL#: GraphQL is a query language and runtime for APIs where the client asks for exactly the fields it needs in one request. Requests usually go to a single endpoint, and responses are JSON shaped like the query. It avoids over-fetching and under-fetching, and a typed schema describes the whole API.JSON to TypeScript
gRPC#: gRPC is a remote procedure call framework from Google that runs over HTTP/2 and encodes messages with Protocol Buffers instead of JSON. Its binary encoding and two-way streaming make it common between internal services. gRPC-Web and JSON transcoding let browsers and REST clients call gRPC services with JSON.
HATEOAS#Hypermedia as the Engine of Application State · hypermedia: HATEOAS (Hypermedia as the Engine of Application State) is a REST constraint where responses include links to the actions and resources available next. An order response might include links to pay or cancel it, so the client does not hardcode URLs. Few APIs implement it fully.
HTTP method#HTTP verb · request method: An HTTP method, or verb, states what a request wants to do with a resource. GET reads, POST creates, PUT and PATCH update, and DELETE removes. JSON usually goes in the body of POST, PUT and PATCH requests, and using the right method lets caches and proxies behave correctly.
HTTP status code#response code · status code: An HTTP status code is the three-digit number a server returns to describe the result of a request. 2xx means success, 3xx a redirect, 4xx a client error like 404 Not Found, and 5xx a server error. JSON APIs often add an error body with details, such as which field failed validation.
Idempotency key#: An idempotency key is a unique token, often a UUID, that the client sends in a request header so the server can ignore duplicate retries. It matters for requests like a POST that charges a card, where a network retry could otherwise charge twice. The server stores the key with its first response and returns that same response for later requests with the same key.UUID / NanoID Generator
JSON-RPC#JSON Remote Procedure Call: JSON-RPC is a lightweight protocol for calling named methods on a remote server with JSON messages. A request has a method, params and an id, and the response returns the same id. It is action-based rather than resource-based like REST, and blockchain nodes such as Ethereum clients expose JSON-RPC APIs.JSON Formatter
OpenAPI (Swagger)#Swagger · OpenAPI Specification · OAS: OpenAPI, formerly Swagger, is a specification for describing a REST API in one JSON or YAML file. The file lists endpoints, parameters, request and response schemas, and authentication. Tools use it to generate docs, client SDKs and mock servers, and its schemas are based on JSON Schema.OpenAPI Validator JSON Schema Generator
Pagination#paging: Pagination splits a large collection into pages so an API returns one part of it per request. Offset pagination uses parameters like page and limit, and cursor pagination returns a token for the next page. JSON responses usually include metadata such as a total count or a next link.
Payload#request body · response body · message body: A payload is the data in the body of an HTTP request or response, as opposed to the headers. In a JSON API it is the JSON document, such as the object a client POSTs or the array a server returns. Smaller payloads transfer and parse faster, and minifying JSON removes bytes you do not need.JSON Size Analyzer JSON Minifier JSON Formatter
Problem Details#application/problem+json · RFC 9457: Problem Details is a standard JSON format for HTTP API errors, defined in RFC 9457 and sent as application/problem+json. It uses the members type, title, status, detail and instance, plus any custom fields, so clients can handle errors the same way across APIs. RFC 9457 replaced RFC 7807.
Rate limiting#: Rate limiting caps how many requests a client can make in a time window. Servers usually reject extra calls with 429 Too Many Requests and a JSON error body, and send headers such as Retry-After. Clients should back off and retry, ideally with exponential backoff and jitter.
REST API#RESTful API · REST: A REST API is a web API that models data as resources at URLs and changes them with standard HTTP methods. Responses are usually JSON, and each request carries all the context it needs, with no session on the server. REST fits HTTP well and is easy to cache.JSON Formatter
Server-Sent Events#SSE: Server-Sent Events (SSE) is a browser standard that lets a server push a one-way stream of text events over one long-lived HTTP connection. The browser reads it with the EventSource API, and apps usually put JSON in each event's data field. It suits live feeds like notifications or streamed AI responses, and is simpler than WebSockets when only the server sends updates.
Webhook#HTTP callback · reverse API: A webhook is an HTTP request a service sends to a URL you register when an event happens, so you do not have to poll. The event data usually arrives as a JSON payload. Payment providers and CI systems use webhooks, and receivers should verify the signature header to confirm the sender.Mock JSON Data Generator

Encoding, numbers and dates

Character encoding, number precision and dates in JSON. These details cause many parsing bugs.

Base64#base-64: Base64 is an encoding that turns binary data into text using 64 ASCII characters: A to Z, a to z, 0 to 9, + and /, with = for padding. JSON has no binary type, so images, files and keys are stored in JSON as base64 strings. The encoded text is about 33% larger than the original bytes.Base64 Encode / Decode Data URI Encoder / Decoder
Base64url#base64url encoding · URL-safe base64: Base64url is a URL-safe variant of base64 that uses - and _ instead of + and /, and usually drops the = padding. The output works in URLs and filenames without escaping. JWTs encode their header, payload and signature with base64url, and some decoders need the padding added back first.Read more about Base64url →Base64 Encode / Decode JWT Decoder
Byte Order Mark#BOM · U+FEFF: A byte order mark (BOM) is the character U+FEFF placed at the start of a text file to signal its encoding. RFC 8259 says JSON must not start with a BOM, though parsers may ignore one. A stray UTF-8 BOM (bytes EF BB BF) often causes an unexpected token error at the first character.Unicode & Encoding Inspector JSON Validator
IEEE 754 double-precision#IEEE 754 · double · binary64: IEEE 754 double precision is the 64-bit floating-point format most JSON parsers use for numbers. It has 1 sign bit, 11 exponent bits and 52 fraction bits, and holds about 15 to 17 significant digits. Decimals like 0.1 cannot be stored exactly, so 0.1 + 0.2 gives 0.30000000000000004.JSON Validator
Integer precision loss#big integer problem · number precision loss: Integer precision loss happens when a JSON integer is larger than 2^53 minus 1, the largest integer a double can store exactly (Number.MAX_SAFE_INTEGER in JavaScript). Larger values, such as big database IDs or Twitter snowflake IDs, silently round to a nearby number. JSON allows integers of any size, so send big numbers as strings and parse them with BigInt or a big-number library.JSON Validator JSON to TypeScript
ISO 8601 date string#ISO 8601 · RFC 3339 timestamp: An ISO 8601 date string is the standard text format for dates and times, like 2026-07-12T14:30:00Z, where Z means UTC. JSON has no date type, so this is the most common way to store timestamps in JSON, and JSON Schema's date-time format checks the RFC 3339 profile of it. Strings in this format sort in time order as long as they use the same offset.Timestamp Converter JSON Schema Generator
Line separator characters#: U+2028 (line separator) and U+2029 (paragraph separator) are Unicode characters that JSON allows unescaped inside strings. Before ECMAScript 2019 they were invalid in JavaScript string literals, so JSON pasted into a script could throw a syntax error. Serializers often escape them as \u2028 and \u2029, which is still a good habit when you put JSON into HTML or JavaScript.JSON Escape / Unescape
NaN and Infinity#not a number · non-finite numbers: NaN and Infinity are IEEE 754 number values that JSON cannot represent. RFC 8259 has no syntax for them, so standard parsers reject them. JSON.stringify writes them as null, and other serializers may throw an error or use non-standard tokens.JSON Validator
No native date type#JSON has no date type: JSON has no date type, only strings, numbers, booleans, null, objects and arrays. Dates are stored by convention, usually as an ISO 8601 string or a Unix timestamp number, and both sides must agree on the format and time zone. A parser cannot tell a date string from any other string, so your code has to convert it.JSON Schema Generator JSON to TypeScript
Number canonicalization#canonical number form · number normalization: Number canonicalization rewrites numbers in one standard text form so equal values always serialize the same way. JSON allows many spellings of one value, such as 1, 1.0 and 1e0. A single form matters for hashing, signatures and diffs, where the bytes must match.JSON Diff / Compare JSON Formatter
Percent encoding#URL encoding · percent-encoding: Percent encoding, also called URL encoding, writes reserved or non-ASCII characters in a URL as % followed by two hex digits, so a space becomes %20. In form data a space can also be written as +. JSON sent in a query string is often percent-encoded so braces, quotes and Unicode survive, and encoding it twice is a common bug.Read more about Percent encoding →URL Encode / Decode URL Parser
Surrogate pair#UTF-16 surrogate: A surrogate pair is two UTF-16 code units that together encode one Unicode character above U+FFFF, such as an emoji. The high surrogate is in the range U+D800 to U+DBFF and the low surrogate in U+DC00 to U+DFFF. In JSON such characters are escaped as two \u sequences, like \ud83d\ude00 for the grinning face emoji, and a lone surrogate produces broken text.Unicode & Encoding Inspector JSON Escape / Unescape
Unicode code point#code point: A Unicode code point is a number from U+0000 to U+10FFFF that identifies one character. JSON strings are sequences of code points, written directly or as \u escapes. Code points above U+FFFF need two UTF-16 units, which matters in languages like JavaScript that index strings by UTF-16 unit.Unicode & Encoding Inspector JSON Escape / Unescape
Unix epoch timestamp#epoch time · Unix time · POSIX time · unixMillis: A Unix epoch timestamp is the number of seconds, or milliseconds (often called unixMillis), since 00:00:00 UTC on 1 January 1970, ignoring leap seconds. In JavaScript, Date.now() returns milliseconds, so divide by 1000 and round down to get seconds. Store it as a JSON number and document the unit, and use Intl.RelativeTimeFormat to show the gap from now as text like "3 hours ago".Read more about Unix epoch timestamp →Timestamp Converter
UTF-8#UTF8 · Unicode Transformation Format 8-bit: UTF-8 is a character encoding that stores each Unicode code point in one to four bytes and matches ASCII for the first 128 characters. RFC 8259 requires UTF-8 for JSON exchanged between systems that are not part of a closed ecosystem. Sending JSON in another encoding breaks many parsers.Unicode & Encoding Inspector JSON Validator

Tokens, auth and security

JSON in authentication tokens, and the attacks to guard against.

Bearer token#: A bearer token is an access credential that works for whoever holds it, sent as Authorization: Bearer <token>. JWTs are often used as bearer tokens in OAuth 2.0. A stolen token works for an attacker too, so send it only over HTTPS, keep its lifetime short, and keep it out of logs.JWT Decoder
Claim#JWT claims: A claim is one piece of information in a JWT payload, written as a JSON name/value pair such as "sub": "user-123". Claims are registered (like exp and iss), public or private. Anyone can decode a payload, so verify the signature and check exp and aud before you trust any claim.JWT Decoder
Deeply nested JSON denial of service#JSON parser DoS: A deeply nested JSON denial of service is an attack that sends JSON nested so deep, or so large, that parsing exhausts the stack or memory. A recursive parser can overflow on a few thousand nested arrays. Defend against it by capping body size and nesting depth and by setting parse timeouts for untrusted input.JSON Validator
HS256 vs RS256#HMAC vs RSA signing: HS256 signs a JWT with one shared secret key, while RS256 signs with an RSA private key and verifies with the matching public key. With HS256, anyone who can verify a token can also create one, so it fits a single trusted service. RS256 fits systems where many services verify tokens, and servers should pin the expected algorithm so a header cannot switch it to HS256 or "none".JWT Decoder
JSON hijacking#: JSON hijacking is an old attack where a malicious page loaded a JSON endpoint with a script tag and read the data by overriding the Array constructor. It worked because a top-level JSON array was once executable JavaScript. Modern browsers block it, and older defenses include non-GET endpoints, CSRF tokens and prefixing responses with )]}' so they cannot run as script.
JSON injection#: JSON injection happens when untrusted input is pasted into JSON text or a JSON query without encoding, letting an attacker change its structure. It can add or overwrite fields, break out of a string, or slip operators like $ne into a NoSQL query. Build JSON with a JSON library instead of string concatenation, and validate input against a schema.JSON Validator JSON Schema Generator
JSON Web Encryption (JWE)#JWE: JSON Web Encryption (JWE) is the standard, defined in RFC 7516, for encrypting a token or message so only the intended recipient can read it. A signed JWT is only encoded, but a JWE payload is ciphertext. The compact form has five parts: protected header, encrypted key, initialization vector, ciphertext and authentication tag.JWT Decoder
JSON Web Key (JWK)#JWK · JWKS: A JSON Web Key (JWK) is a JSON object that represents a cryptographic key, with members like "kty", "alg", "use" and "kid". A JWK Set (JWKS) is a list of them that servers publish at a well-known URL so clients can fetch public keys and verify JWT signatures. Matching a token's "kid" header to a JWKS entry lets you rotate keys without redeploying.JWT Decoder
JSON Web Signature (JWS)#JWS: JSON Web Signature (JWS) is the standard, defined in RFC 7515, for signing content so the receiver can check who sent it and that it was not changed. A signed JWT is a JWS in compact form. JWS also has a JSON form that can carry several signatures over one payload, and the payload is signed, not encrypted.JWT Decoder
JSON Web Token (JWT)#JWT: A JSON Web Token (JWT) is a compact, URL-safe token that carries JSON claims and is signed, or sometimes encrypted. It has three base64url parts joined by dots: header, payload and signature. Every JWT starts with "eyJ" because that is how {" encodes, and anyone can decode the payload, so verify the signature before trusting it.JWT Decoder
JWT header#: The JWT header is the first part of a JSON Web Token, a base64url-encoded JSON object that says how the token is signed. It usually has "alg" for the algorithm and "typ", usually "JWT", and may have "kid" to name the verification key. An attacker can change an unverified header, so servers should pin the algorithms they accept instead of trusting "alg".JWT Decoder
JWT payload#Claims set: The JWT payload is the middle part of a JSON Web Token, a base64url-encoded JSON object that holds the claims, such as user ID, roles and expiry. Encoding is not encryption, so anyone with the token can read it. Keep it small since it travels with every request, and never put passwords or secrets in it.JWT Decoder
JWT signature#: The JWT signature is the third part of a JSON Web Token, computed over the encoded header and payload to prove the token was not changed. HMAC algorithms use a shared secret, and RSA or ECDSA use a private key with a matching public key. Servers must check the signature before trusting any claim and reject tokens that ask for the "none" algorithm.JWT Decoder
Mass assignment#over-posting: Mass assignment, or over-posting, is a bug where a framework copies every field from a JSON request body onto a model, so an attacker can set fields like isAdmin or price. The fix is to accept only an allowlist of fields. A strict schema with additionalProperties set to false also rejects unexpected keys.JSON Validator
OAuth 2.0#OAuth2: OAuth 2.0 is an authorization framework, defined in RFC 6749, that lets an app access a user's resources on another service without getting their password. The user approves the app, which receives an access token, often a JWT, to call protected APIs. OAuth covers authorization only, and OpenID Connect adds login on top.JWT Decoder
OpenID Connect#OIDC: OpenID Connect (OIDC) is an identity layer on top of OAuth 2.0 that adds user login. Along with the access token, the provider issues an ID token, a JWT whose claims such as sub, iss, aud, exp and nonce describe the signed-in user. Apps must verify the ID token's signature against the provider's JWKS and check its claims.JWT Decoder
Prototype pollution#__proto__ pollution: Prototype pollution is a JavaScript vulnerability where keys like __proto__, constructor or prototype in parsed JSON get merged into Object.prototype, changing every object in the app. Deep-merge and clone helpers run on untrusted request bodies are the usual entry point. Reject those keys, use Map or Object.create(null) objects, and validate input against a strict schema.JSON Validator
Registered claims (exp, iss, aud)#Reserved claims · JWT registered claims: Registered claims are the standard JWT claim names defined in RFC 7519: iss (issuer), sub (subject), aud (audience), exp (expiration time), nbf (not before), iat (issued at) and jti (JWT ID). The jti claim is a unique ID for one token, used to block replays or revoke that token. Check exp, iss and aud on every request, or expired and misdirected tokens will pass.Read more about Registered claims (exp, iss, aud) →JWT Decoder

Related data formats and storage

Other data formats close to JSON, and the databases that store it.

Apache Arrow#: Apache Arrow is a columnar in-memory format for tabular data that different languages and processes can share without copying or serializing. It stores each column in one contiguous block, unlike row-based JSON, which speeds up analytics. JSON is often parsed into Arrow for fast processing, and Arrow pairs with on-disk formats like Parquet.
Apache Avro#Avro: Apache Avro is a binary serialization format whose schemas are usually written in JSON. It is common in Hadoop and Kafka, and supports schema evolution so readers and writers can use different schema versions. The schema is JSON, but the encoded data is compact binary.
Apache Parquet#Parquet: Apache Parquet is a columnar file format for analytics on large datasets. It stores values by column instead of by row like JSON or CSV, which compresses better and lets queries read only the columns they need. JSON is often flattened and loaded into Parquet for data lakes and warehouses.
CSV#Comma-Separated Values: CSV (comma-separated values) is a plain-text table format where each line is a row and commas separate the fields. It has no nesting, arrays or types, so nested JSON must be flattened into columns before you convert it. Spreadsheets and data exports use CSV everywhere, which makes JSON to CSV conversion a common task.JSON to CSV CSV to JSON CSV Validator
Denormalization#: Denormalization copies related data into one record so reads do not need joins. In document databases this means embedding nested objects and arrays in a JSON document instead of referencing other collections. Reads get faster, but updates get harder because the same data lives in several places.
Document (MongoDB sense)#BSON document: In MongoDB, a document is one record, a set of field-value pairs that looks like a JSON object but is stored as BSON. Documents live in collections and can hold nested documents, arrays and types like dates and ObjectIds. Queries and drivers use JSON-like syntax to read and write them.JSON Validator
Document database#document store · document-oriented database: A document database is a NoSQL database that stores data as self-contained documents, usually JSON or BSON, instead of rows in tables. Each document can hold nested fields and arrays, so related data comes back in one read. MongoDB, Couchbase and Firestore are examples.
Flattening nested data#JSON flattening: Flattening converts nested JSON objects and arrays into flat columns for CSV files, spreadsheets or SQL tables. Nested keys are joined with a dot or underscore, so address.city becomes one column. Arrays become extra rows or indexed columns.JSON Flattener JSON to CSV
HOCON#Human-Optimized Config Object Notation: HOCON (Human-Optimized Config Object Notation) is a config format from the Lightbend and Akka ecosystem that is a superset of JSON. It adds comments, optional quotes and commas, dotted keys, file includes and value substitutions. Any valid JSON is valid HOCON, and parsers resolve it to a plain JSON-like tree.
Key-value store#key-value database · KV store: A key-value store is a database that maps unique keys to values and looks them up very fast. The value can be a plain string or a serialized JSON blob. Redis, DynamoDB and etcd are common examples, often used for caches and session data.
NoSQL#Not Only SQL: NoSQL (Not Only SQL) is a broad group of non-relational databases with flexible data models instead of fixed tables. The main types are document, key-value, column-family and graph stores. Many use JSON or a JSON-like format natively, so you can store and query nested objects directly.
Protocol Buffers#protobuf: Protocol Buffers (protobuf) is Google's binary serialization format, with schemas defined in .proto files. Messages are smaller and faster to parse than JSON, and gRPC uses protobuf by default. Fields are identified by numbers rather than names, so you need the schema to decode a message.
Schema evolution#: Schema evolution is changing a data schema over time while old and new versions of producers and consumers keep working together. Backward-compatible changes let new code read old data, and forward-compatible changes let old code read new data. The safe moves are adding optional fields with defaults and never reusing a field for a new meaning, in Avro, Protocol Buffers and JSON APIs alike.
Schema-on-read#: Schema-on-read means storing raw data without a fixed structure and applying a structure only when you query it. Schema-on-write is the opposite and enforces structure when data is inserted. JSON and document databases fit schema-on-read, since you can store any document now and validate or reshape it later.JSON Schema Generator
TOML#Tom's Obvious Minimal Language: TOML (Tom's Obvious Minimal Language) is a config file format that maps directly to a hash table. It uses key-value pairs grouped into [sections], with explicit types for strings, integers and dates. Rust's Cargo.toml and Python's pyproject.toml use it, and most TOML converts cleanly to JSON, though TOML has no null.JSON ⇄ TOML
TSV#Tab-Separated Values: TSV (tab-separated values) is a table format like CSV that separates fields with tabs instead of commas. Tabs rarely appear in data, so TSV needs less quoting and escaping than CSV. Nested JSON still has to be flattened before you export it to TSV.CSV ⇄ TSV JSON to CSV
XML#Extensible Markup Language: XML (Extensible Markup Language) is a tag-based markup format for structured data. It supports attributes, namespaces and XSD schema validation, but it is more verbose than JSON, which replaced it in most modern APIs. Converting between them is common when you work with SOAP services or older systems.JSON ⇄ XML XML Validator / Formatter
YAML#YAML Ain't Markup Language: YAML (YAML Ain't Markup Language) is a human-readable data format that uses indentation instead of braces and brackets. YAML 1.2 is a superset of JSON, so valid JSON is also valid YAML, and it adds comments, anchors and multi-line strings. It is common for config files such as Kubernetes manifests and CI pipelines.JSON ⇄ YAML YAML Validator / Linter YAML Formatter