YAML Format & Validate

Details and how to verify this yourself: Security & privacy.

The YAML studio checks, formats and converts YAML in one place. Paste or type a document into Input: it is checked as you type. Choose what to look at from the View menu; the badge in the status line names the current view, and the Problems button next to it counts the findings.

Menus. The studio works like a desktop window. Its menu bar has File (open, load the sample, download, clear), Edit (format, copy), View (switch views, show the options inline, full screen), Settings (Options… opens the options in an overlay) and Help (jumps to these sections, and lists the keyboard shortcuts). The full-screen icon sits at the right of the same row: two arrows pointing out make the studio fill the window, and arrows pointing in (or Esc) bring it back.

Edit → Format (or Ctrl+Enter) shows the formatted document on the Formatted view; your Input is never changed unless you press Use as input there. The JSON view always shows the converted data, updating as you type. The Formatted and JSON views each have their own Copy and Download buttons. The File menu has Open file… (a .yaml or .yml file), Load sample (a short file with a few findings), Download input and Clear input.

Settings → Options…. These settings change the findings and the formatted output together:

• Indent: 2 or 4 spaces per level.
• Sequences: whether lists under a key are indented. Indented puts - item one level in under key:. Flush puts - item in the key’s column. Consistent (the default) accepts either, as long as the whole file does the same; the first list decides.
• Max line length: 120 by default, or off. yamllint’s default is 80, which most Kubernetes manifests and CI files exceed, so the default here is 120.
• Document start: Ignore (default), Require --- before every document, or Forbid it on the first document.
• Quote style: Any (default), Single or Double.

Reading the findings. An error means the YAML is unusable: it does not parse, a mapping has the same key twice, or an alias refers to an anchor that does not exist. Formatted, Tree and JSON stay empty until errors are fixed. A warning is a style or portability problem, and info is a note. The rules and their IDs match yamllint, so a finding here is one yamllint would report with the same settings. The exception is that some yamllint errors are warnings here (see the rules table).

Why YAML 1.1 matters. YAML has two versions in wide use. YAML 1.2 (2009) is what this page and the eemeli/yaml library follow. YAML 1.1 is still what PyYAML, Ruby’s Psych, SnakeYAML and Go’s yaml.v2 implement, so Ansible, many CI systems and older Kubernetes tooling read your file as 1.1. The same plain text means different things:

The truthy and octal-values rules flag the first rows. YAML → JSON warns about every value in the left column whose meaning differs, and JSON → YAML double-quotes any string that either version would read as something else.

Converting.

• YAML → JSON takes the first document, or all of them (All documents gives a JSON array). Merge keys (<<: *defaults, common in Docker Compose and CI files) are applied by default; turn them off to keep << as an ordinary key. Custom tags such as CloudFormation’s !Ref and !GetAtt, or YAML 1.1’s !!binary, have no JSON equivalent, so by default they are an error. Drop tags keeps the value and discards the tag; Wrap tags keeps both, as {"!Ref": "MyBucket"}.
• JSON → YAML is the reverse conversion. On this site it is the As YAML view of the JSON studio. The result is block-style YAML 1.2 that means the same under YAML 1.1.

Library. eemeli/yaml 2.9, configured for YAML 1.2 with the core schema, strict mode, and unique keys. The linter reads the library’s concrete syntax tree, which holds every token with its position. It never matches regular expressions against raw lines, so a # inside a string or a blank line inside a block scalar is never mistaken for a comment or a style problem.

YAML 1.2 is pinned. A %YAML 1.1 directive does not switch rules; YAML → JSON warns about it. Plain scalars resolve as in the 1.2 core schema:

Lint rules

Rule IDs and default behaviour follow yamllint’s default configuration. yamllint reports most style rules at error level; here they are warnings, because they do not change what the document means, and an error is kept for YAML that cannot be used. Positions are 1-based lines and columns counted in Unicode code points, plus a 0-based UTF-16 offset; most findings also give an end position.

Formatting cannot fix the no rules without changing what the file means, or what a YAML 1.1 reader sees. For example, quoting yes keeps the YAML 1.2 meaning, but tools that read YAML 1.1 lose the boolean they expected.

Formatting

The formatter uses the yaml library’s document model, which keeps comments, anchors, aliases, tags, key order, directives and document markers.

• Layout. The chosen indentation, the Sequences option, one space after : and -, no padding inside {} and [], , between flow items, at most one blank line in a row, no blank lines at the start or end, LF line breaks, no byte-order mark, and a final newline. Inline comments get two spaces before the #. Lines are never wrapped.
• Scalars. Numbers keep their spelling (0x1F, 1e3, 1.50, +12 and big integers stay as written), and so do ~, True and other null and boolean forms. Plain multi-line scalars and folded (>) scalars are joined onto one line, which leaves their value unchanged. Literal (|) scalars keep their lines, chomping and indentation indicators.
• Quotes. With quote style Any, quotes are removed only from strings that are plainly words: they start with a letter, _ or /, contain only letters, digits, _ . / @ + -, parentheses and single spaces, and mean the same string in YAML 1.2 and 1.1. So "yes", "on", "0755", "1.0", "null", "true", "~", "2024-01-01", "1:20", "<<" and "" stay quoted. With Single or Double, quoted values switch to that quote character when the content allows (a value containing ' or a backslash escape stays double-quoted).
• Comments. Every comment is kept, next to the node it describes, and own-line comments are re-indented with their content. A few move to the library’s canonical place. A comment after key: whose value is on the next line moves above the value. A comment on the line after a short value can become that value’s inline comment. A comment at the end of the file gets a blank line before it. A comment between documents goes just before the next ---.
• Safety check. The formatted text is parsed again and compared with the original, node by node: values, tags, anchors and alias names. If anything differs, the original text is returned unchanged. One case where this happens is a root block scalar with an indentation indicator, which the library would re-indent incorrectly.
• Only comments. A file with comments but no documents is tidied line by line.

Value

The Tree and JSON tabs (and value in the API) show the data of the first document. When there are several documents, they show an array with one element per document. Merge keys are applied, aliases are expanded, integers beyond 2^53 − 1 lose precision, and .inf and .nan become null. If the aliases would expand past 1,000 copies (a “billion laughs” document), or refer to a collection that contains them, the value is not shown and an anchors warning says why; the YAML is still valid and is still formatted.

YAML → JSON

Warnings (at most 100, then a count) cover plain scalars that YAML 1.1 parsers read differently: the 1.1 booleans (y, n, yes, no, on, off in lower, title and upper case), integers with a leading zero (with the octal value 1.1 would give), base-60 numbers, timestamps, and binary or _-separated numbers. Also: non-string keys converted to strings, two keys that become the same string, extra documents, and integers beyond 2^53 − 1.

Errors stop the conversion and give the line, column, an excerpt, and a code. Parse errors use the library’s codes, for example BAD_INDENT, TAB_AS_INDENT, MISSING_CHAR, DUPLICATE_KEY, UNEXPECTED_TOKEN, BLOCK_AS_IMPLICIT_KEY. Conversion errors:

Anchors and aliases. Every alias is expanded into a copy, because JSON has no references. To stop “billion laughs” documents (a few lines of nested aliases that expand to gigabytes), conversion stops after 1,000 alias expansions or 200,000 output values, whichever comes first.

Merge keys. A plain (unquoted) << key whose value is an alias or mapping, or a sequence of them, merges those mappings into the current one. Keys written explicitly in the mapping win, wherever they appear; among several merged mappings, earlier ones win. Merged keys are inserted where the << appears. A quoted "<<" is always an ordinary key.

Tags. The core tags !!str, !!int, !!float, !!bool, !!null, !!map, !!seq and the non-specific ! are applied (!!str 123 is the string "123"). Every other tag, including the YAML 1.1 types !!binary, !!timestamp, !!set, !!omap and !!pairs, follows the custom-tags option. With wrap, the key is the tag as written in short form (!!binary, !Ref).

Keys. JSON keys are strings. A null, boolean or number key becomes its text (1 → "1", true → "true", ~ → "null"), with a warning; if two keys end up equal, the later one wins, with a warning.

Numbers and order. Integers are converted exactly, however many digits they have. Floats are written in the shortest form that round-trips (1.5e3 → 1500). Key order is preserved as written. Comments are discarded (JSON has none).

JSON → YAML

• The input is parsed with the same strict JSON parser as the JSON tool, so errors give line, column and offset, and duplicate keys keep the last value with a warning.
• Output is block style, indented 2 to 8 spaces per level (2 by default), with sequences indented under their key, no --- marker, no line folding, and a final newline. Empty objects and arrays are written {} and [].
• Key order is kept unless Sort keys is on (UTF-16 code unit order, as in the JSON tool).
• Strings are plain when that is unambiguous under both YAML 1.1 and 1.2, double-quoted otherwise. Multi-line strings use literal block scalars (|, or |- when there is no final newline).
• Integers keep every digit. A number with a fraction or exponent stays a float: 1.0 → 1.0, 1e5 → 100000.0, 2.50 → 2.5, 1e-7 → 1e-7.

API

• POST /api/yaml/format lints and formats in one call. It takes input (at most 15,000 characters; linting and formatting parse the YAML twice, so use the page for larger files), indent (2 or 4), indent_sequences (consistent, indented or flush), max_line_length (0 turns the rule off; default 120), document_start (ignore, require or forbid) and quote_style (any, single or double). The response has valid, summary (counts by severity), diagnostics, documents, formatted and value. Invalid YAML is a 200 response with valid: false and formatted and value set to null, not an HTTP error.
• POST /api/convert/yaml-to-json takes input (at most 30,000 characters), documents (first or all), indent, sort_keys, merge_keys and custom_tags. The response has json (exact text) and value (the same data as a JSON value; integers beyond 2^53 − 1 lose precision there, as in any JSON parser).
• POST /api/convert/json-to-yaml takes input (at most 100,000 characters), indent (2–8) and sort_keys.

Errors make the document invalid. Warnings and information are style findings; the document still parses.