YAML Formatter

Paste or type YAML into the editor and the tool parses it on every change. There are three things it gives you:

• Validation — if the document can't be parsed, you get the error message plus the line and column. YAML failures are usually about indentation or an unexpected character, and the position pointer is what makes them quick to fix.
• Formatting — valid input is re-serialized with uniform two-space indentation, normalized list and key spacing, and trailing whitespace removed. This is useful for cleaning up files that several people have edited by hand.
• Conversion — switch the output to JSON to get the equivalent JSON document, or paste JSON and get YAML back. Round-tripping a config between the two formats is a fast way to sanity-check its structure.

The parser follows standard YAML rules: it understands mappings, sequences, scalars, multi-line block strings, anchors and aliases, and explicit type tags. No part of this requires an account or a network connection.

Say you have this fragment and the formatter reports an error:

server:
  host: localhost
   port: 8080
  tags: [web, api]

The message points at the port line: it's indented one space deeper than host, and YAML treats inconsistent indentation under the same mapping as a structural error. Line up port with host and it parses. Formatted output comes back as:

server:
  host: localhost
  port: 8080
  tags:
    - web
    - api

Note two things the formatter did. It kept 8080 as a number, not a quoted string, because unquoted numeric scalars are numbers in YAML. And it expanded the inline [web, api] flow sequence into block style, which is the more readable form most config files use. If you'd rather keep values as strings (for example a ZIP code or a version like 1.10), quote them explicitly: version: "1.10".

YAML is the config language for a lot of infrastructure tooling, and most editing of it still happens by hand, so a quick validate-and-format pass catches a lot of mistakes before they reach a pipeline:

• Kubernetes and Helm — check a manifest's indentation before kubectl apply, where a misplaced key silently lands a field in the wrong block.
• CI/CD pipelines — validate GitHub Actions, GitLab CI, or CircleCI files locally instead of pushing a commit just to find out the YAML was malformed.
• Ansible and Docker Compose — confirm playbooks and compose files parse before a run.
• Format conversion — turn an API's JSON response into readable YAML, or convert a YAML config into JSON for a tool that only accepts JSON.
• Cleanup — normalize indentation across a file that's been edited by several people with different editor settings.

Because it's all local, you can run a real production config through it without worrying about where the text goes.

Most YAML pain comes from a handful of recurring traps:

• The Norway problem — unquoted no, yes, on, off, true, and false are booleans. A country list with NO (Norway) becomes false. Quote any string value that could be read as a boolean.
• Tabs are illegal for indentation — YAML requires spaces. A single tab gives a parse error. Set your editor to insert spaces.
• Numeric-looking strings — 08 is invalid (looks like a malformed octal), and 1.20 loses its trailing zero. Quote version numbers, ZIP codes, and IDs with leading zeros.
• Indentation defines structure — there are no braces. A key indented to the wrong depth quietly attaches to a different parent, which often parses fine but means something you didn't intend.
• Colons in values — time: 10:30 can confuse the parser. Quote it: time: "10:30".

When the validator flags a line, check indentation and quoting first; that's where the answer usually is.

YAML lets you define a block once and reuse it, which JSON can't do. You mark a node with an anchor (&name) and reference it later with an alias (*name). The << merge key folds an anchored mapping's keys into another mapping:

defaults: &defaults
  retries: 3
  timeout: 30

production:
  <<: *defaults
  timeout: 60

Here production inherits retries: 3 from defaults and overrides timeout to 60. This keeps shared config in one place instead of copy-pasting it across environments.

When you convert this to JSON, the aliases are resolved and expanded into full literal values, because JSON has no concept of references. So the JSON production block will contain both retries and timeout written out in full. That expansion is expected, and it's a good way to see exactly what your anchors resolve to.