Free YAML Validator & Parser Online - js-yaml, Not a K8s Linter

A YAML validator - also searched as a YAML parser, YAML syntax checker, or YAML linter - is a tool that asks one question: can this text be loaded as YAML? This page answers that with js-yaml load. It does not ask whether a Deployment is well-typed, whether a Helm values file matches a chart schema, or whether a GitHub Actions workflow uses a legal job key. Those are schema jobs. This is a document job.

YAML (YAML Ain't Markup Language) is the configuration dialect of Docker Compose, Ansible, Kubernetes manifests, GitHub Actions, OpenAPI fragments, and countless CI files. Unlike JSON, YAML is indentation-sensitive, allows comments, and has a rich set of scalars. That flexibility is why people write it by hand and why a single tab character can make a parser reject a file that looks fine in an editor that shows whitespace as identical to spaces.

The worked check on this page is the default mapping foo: bar. js-yaml loads it as the JavaScript object whose JSON form is {"foo":"bar"}. If that mapping fails on your machine, the parser did not load. If it succeeds, you have a passing parse - not a Kubernetes admission review.

Checking YAML here takes a few seconds. Parsing runs as you type:

1. Paste your YAML - Paste into the left panel. Keep the default foo: bar for a passing mapping, or replace it with a document you wrote.
2. Read the parse result - js-yaml load runs as you type. A valid document shows the JavaScript value as indented JSON. Indentation errors, tabs, and illegal tokens show a line and column.
3. Quote ambiguous scalars - If a country code or the words on/off become booleans, quote them. That is YAML 1.1 typing, not a Kubernetes schema check.
4. Copy or convert - Copy the JSON view if you need a note. Dedicated conversion belongs on the YAML to JSON page. This page is the syntax check.
5. Fix indentation - Use spaces, not tabs. Nested keys must indent further than their parent. A dangling colon with no value is often a typo, not a feature.

Here is the default document and the value js-yaml produces. That pair is the worked check for this tool.

foo: bar

{
  "foo": "bar"
}

A nested example that still parses as YAML (and is still not a cluster check):

service:
  name: api
  ports:
    - 8080
    - 8443

{
  "service": {
    "name": "api",
    "ports": [
      8080,
      8443
    ]
  }
}

The JSON view is a convenience so you can see types: unquoted 8080 became a number, not the string "8080". If you needed a string port, quote it in the YAML. Conversion as a product feature still lives on YAML to JSON.

These three jobs are often searched as if they were one tool. They are not:

The general rule: parse first, lint schemas second, convert when you need another format. This page stops at parse.

These are the failures this validator is built to surface. None of them are Kubernetes resource errors:

• Tab indentation. YAML is a spaces dialect for indent. A tab in the indent column often throws. Switch the editor to spaces.
• Inconsistent indent width. Mixing 2-space and 3-space nested keys confuses the block parser. Pick one width and stay with it.
• Duplicate keys. js-yaml typically keeps the later value. That is a silent logic bug more often than a hard error. The JSON view shows which value survived.
• The Norway problem. Unquoted NO, yes, on, and off can become booleans under YAML 1.1. Quote country codes and switch names if they are strings.
• Unquoted special characters. Colons inside unquoted strings, unmatched quotes, and stray { or [ in plain scalars produce scan errors with a mark.
• Multi-document files. This page uses a single yaml.load. Streams separated by --- may load only the first document. loadAll is out of scope.
• Unsafe tags. This page does not use an unsafe load. Typical mappings and sequences load. Custom constructors that execute code are not invited.

JSON has six value types and no comments. YAML has comments, block scalars, flow collections that look like JSON, and a historical type system that still surprises people who treat YAML as "JSON with less punctuation." js-yaml's load is the YAML 1.1-flavored parser most Node tools still ship. YAML 1.2 tried to make unquoted NO a string. This page is not a 1.2-only checker. If your production parser is PyYAML, ruamel, or Go's yaml.v3, quote anything that looks like a boolean, sexagesimal, or version-like scalar rather than arguing about which spec your CI actually uses.

Flow style is legal YAML: {foo: bar} is the same mapping as the default block form. A sequence can be [8080, 8443] instead of dashed lines. Mixing flow and block is allowed; mixing tabs into either is not. Anchors and aliases (&id / *id) are YAML features this parser will load as shared JavaScript references when the document is valid. They are not Kubernetes $ref pointers and they are not JSON Schema. If you paste a Helm template full of {{ .Values }}, that is Go text/template, not YAML - the parser will fail at the braces unless they are quoted.

Comments starting with # are stripped during load. They never appear in the JSON view. That is expected. If you needed comments to survive a round-trip, you wanted a different product: a document editor, not a validator. Empty documents and documents that load as null are still "valid YAML" in the parse sense. A file that contains only # comment often loads as null. That is not an error here; it is a reminder that "valid" is not "useful."

Integers, floats, and timestamps are another typing trap. Unquoted 1.0 may become a number. Unquoted 2020-01-01 may become a Date in some YAML 1.1 loaders. Quote values you intend to keep as strings. The JSON view on the right is the fastest way to see what this specific library decided. It is not a promise that every other YAML library will decide the same way.

Block scalars with | (literal) and > (folded) are valid YAML and load as strings. They are a common source of "it parsed but the newline vanished" confusion. Folded scalars join lines with spaces; literal scalars keep newlines. If your CI secret file uses a literal block for a PEM, you want |, not >. This validator will load both; it will not tell you which one your deployer expected. Merge keys (<<) are a 1.1-era feature some parsers still expand. Do not rely on this page as a merge-key specification. If the document loads, you get a JSON view of whatever js-yaml produced.

All YAML loading runs in your browser with js-yaml. The document is not uploaded. That makes the tool usable for private Compose files, Ansible inventories with redacted secrets, and draft manifests you would not paste into a random hosted linter.

Your input is saved under the unique key yaml-validator-data in this browser's localStorage for up to 30 days. Panel width uses yaml-validator-panel-width. The split track class yaml-validator-split-track is unique so desktop resize does not collide with other tools. Click Clear to restore foo: bar.