All processing runs in your browser — no files or inputs are uploaded to a server.
Paste a YAML document on the left, and the right pane shows Valid or Invalid with a list of every error and warning — each pinned to a line and column. Multi-document files separated by `---` are supported; the panel reports how many documents parsed. Warnings cover non-fatal issues like duplicate map keys that the parser auto-resolves.
This is a syntax validator, not a schema validator. It catches "your YAML is malformed" — wrong indentation, unclosed quotes, mixed tabs, invalid anchor references. It does *not* check "your Kubernetes manifest needs a `metadata.name`" or "your GitHub Actions workflow has an unknown step". For schema validation against k8s, GitHub Actions, or your own JSON Schema, pair this with `kubeval`, `actionlint`, or `ajv`. Everything runs in the browser using the `yaml` parser, so secrets pasted from a config stay on your machine.
apiVersion: v1 kind: ConfigMap metadata: name: app-config data: database_url: postgres://localhost:5432/app retries: 3
Valid · 1 document
Standard 2-space indentation, key-value pairs at the right depth. The validator reports document count — useful for multi-resource manifests joined by `---`.
services:
web:
port: 8080
image: nginxInvalid · line 3, column 1: Tabs are not allowed as indentation in YAML
YAML 1.2 §5.1 explicitly forbids tab characters where indentation is expected. Most editors silently convert tab-to-space, but a paste from a different source can sneak in real `\t` bytes. The validator pins the offending line so the fix is immediate.
countries: - US - JP - NO - KR
Valid · 1 document (Note: NO is parsed as the boolean false in YAML 1.1)
YAML 1.1 treats `yes`/`no`/`on`/`off` and their capitalized forms as booleans, so a list of country codes loses Norway. The `yaml` library used here defaults to 1.2 (where only `true`/`false` are booleans), so the example actually stays as strings — but be aware that PyYAML, libyaml, and many Ansible / older Ruby parsers still default to 1.1. Always quote ambiguous scalars: `- "NO"`.
The underlying `yaml` package defaults to YAML 1.2. The biggest practical difference: 1.1 treats `yes/no/on/off/y/n/Y/N` and their cases as booleans (the "Norway problem"), 1.2 narrows booleans to `true/false`. 1.2 also fixed the octal literal mess. If your deployment target uses a 1.1 parser (most Ansible runs, older PyYAML), validate locally with both — files that pass here may behave differently there.
The most common cause is mixed tabs and spaces — YAML forbids tabs at indent positions and many editors render tabs as a 4- or 8-space gap that looks identical to indented spaces. Open the file in a hex view or with `cat -A` to spot the `\t` bytes. Other quiet killers: a non-breaking space (U+00A0) pasted from a doc, a stray BOM at the file start, or a control character inside a "plain" scalar.
No — it validates YAML *syntax* only. Schema rules ("a `Deployment` needs `spec.template.spec.containers`", "a workflow `run:` cannot have a sibling `uses:`") need schema-aware tools: `kubeval` and `kubeconform` for Kubernetes, `actionlint` for GitHub Actions, `ajv-cli` for arbitrary JSON Schema. Run those after this validator passes, since they expect well-formed YAML as input.
Yes. Multi-document streams are standard YAML and the validator reports the document count. Each document is validated independently — an error in document 2 does not skip document 3. `kubectl apply -f manifest.yaml` accepts the same multi-doc form, which is why most Helm chart outputs and `kustomize build` results look this way.
YAML 1.2 §6.7 says duplicate keys are an error, but most real-world parsers (PyYAML, libyaml, snakeyaml in lenient mode) accept the file and keep the last value silently. The `yaml` library treats it as a recoverable warning to match that real-world behavior — the document still parses, but the warning surfaces the ambiguity so it doesn't hide a bug.
Not from this tool — it only validates. For round-trip conversion use the JSON ↔ YAML converter on this site. Note that YAML supports types JSON does not (dates, sets, multi-line strings with preserved newlines, references via anchors); a one-way YAML → JSON pass either drops or stringifies those.
YAML (YAML Ain't Markup Language) is a data serialization language optimized for human editing, designed by Clark Evans, Ingy döt Net, and Oren Ben-Kiki and first released in 2001. The current revision is YAML 1.2.2 (October 2021). The core data model is the same JSON-compatible tree of scalars, sequences, and mappings — anything valid in JSON parses as YAML, but YAML adds indentation-based structure, comments, anchors / aliases, multi-document streams, and richer scalar types.
The surface syntax is what bites people. Indentation must be spaces; tab characters are forbidden at indent positions. Strings can be plain (unquoted), single-quoted (literal except for `''`), double-quoted (with escape sequences), or block (`|` preserves newlines, `>` folds them). Unquoted scalars can be auto-typed to booleans (`true`, `false`), integers, floats, null (`null`, `~`, empty), or strings — leading to the infamous Norway problem in YAML 1.1, where `no`, `false`, `off` all became boolean false. Quoting eliminates ambiguity for any scalar that resembles a typed literal.
Adjacent serializers each cover different ground. **JSON** is YAML 1.2's strict subset, machine-friendly but verbose for human editing. **TOML** targets configuration files with a flatter, less ambiguous syntax — common in Rust's `Cargo.toml` and Python's `pyproject.toml`. **HCL** (HashiCorp Configuration Language) backs Terraform configs with a block-oriented, expression-aware syntax. YAML's niche stays in Kubernetes manifests, GitHub Actions workflows, CI / CD pipelines, and Ansible playbooks where multi-document support, anchors, and human comments are worth the indentation discipline cost.
Convert between JSON and YAML in either direction. Clear error messages with line numbers.
Format and validate JSON. Indented or minified output, with clear error messages.
Encode text to Base64 or decode Base64 back to text. UTF-8 safe.
Percent-encode or decode URL components.