Does every YAML feature translate cleanly into JSON?

Most of what you'll encounter in practice does: mappings become objects, sequences become arrays, and scalars map onto JSON's string, number, boolean, and null types directly. Comments are the exception, since JSON has no concept of them, so they're dropped during conversion, the same way they are when formatting or minifying YAML.

What happens with YAML anchors and aliases?

Anchors (`&name`) and aliases (`*name`) are YAML's way of referencing a value defined elsewhere in the same document, avoiding repetition. The parser resolves them before conversion, so the JSON output contains the fully expanded value at every point it's referenced, rather than any equivalent of a reference.

Does a bareword like `yes` or `on` convert to a boolean, the way it does in some YAML tools?

No, not with this converter. It follows the YAML 1.2 core schema, which only recognizes `true` and `false` (in a few capitalizations) as booleans. Older YAML 1.1 tools also treated `yes`, `no`, `on`, and `off` as booleans, a common source of surprise bugs, but YAML 1.2 deliberately removed that behavior, and this converter follows the newer, less surprising spec.

Does this handle multi-document YAML files?

Only the first document in a `---`-separated stream is converted. If your file has multiple documents, split it and convert each one separately, or handle the stream with a YAML library directly if you need all of them at once.

YAML to JSON Converter - Convert YAML to JSON Online

Overview

Introduction

YAML and JSON describe the same kinds of data, mappings, sequences, and scalars, but plenty of tools only accept one or the other. This converter takes a YAML document and produces the equivalent JSON, so you can move a value between a YAML-based config and a JSON-only API or library without hand-translating it.

It's a strict, spec-driven conversion: the same parser used across every YAML tool on this site resolves your document into a real data structure first, then serializes that structure as JSON, so the output is exactly what a YAML-aware application would see if it read the same file.

What Is YAML to JSON Converter?

A YAML-to-JSON converter parses a YAML document into its underlying value, an object, array, string, number, boolean, or null, and re-serializes that value using JSON's syntax instead.

Because JSON is technically a subset of what YAML can express, most everyday YAML converts losslessly. The main casualties are comments and YAML-specific syntax like anchors, which get resolved to their expanded values rather than represented directly.

How YAML to JSON Converter Works

Your input is parsed with a full YAML 1.2 parser, then the resulting JavaScript value is passed straight to `JSON.stringify()` with your chosen indentation.

Because both steps operate on the same in-memory value, there's no intermediate text-munging step that could introduce a mismatch between what the YAML actually means and what the JSON expresses.

When To Use YAML to JSON Converter

Use it when a config, fixture, or API payload lives in YAML but a downstream tool, a JSON Schema validator, a `jq` pipeline, a JavaScript `JSON.parse()` call, needs it as JSON.

It's also useful for reviewing what a YAML document actually parses to, since YAML's flexible syntax can occasionally produce a different data shape than a quick visual read suggests.

Often used alongside JSON to YAML Converter, YAML Validator and YAML Formatter & Prettifier.

Features

Advantages

Runs entirely client-side, so config with real values never leaves your browser.
Uses a spec-compliant parser, so YAML-specific features like anchors resolve correctly.
Output is standard, indented JSON ready to paste elsewhere.
Reports the exact parse error location if the input isn't valid YAML.

Limitations

Comments in the source YAML are not preserved, since JSON has no equivalent.
Only the first document in a multi-document stream is converted.
YAML's non-string map keys (rare, but valid) are coerced to strings, matching how JSON object keys always work.

Examples

Simple mapping with a nested list

Input

name: api
replicas: 3
env:
  - prod
  - staging

Output

{
  "name": "api",
  "replicas": 3,
  "env": [
    "prod",
    "staging"
  ]
}

Each YAML key becomes a JSON property, and the sequence becomes a JSON array.

true/false resolve to real JSON booleans, but yes/no stay strings

Input

debug: false
enabled: yes

Output

{
  "debug": false,
  "enabled": "yes"
}

Under the YAML 1.2 core schema this converter follows, only `true`/`false` are booleans. `yes` is just a string, unlike in older YAML 1.1 tools, so it converts to JSON's `"yes"`, not `true`.

Invalid indentation stops conversion

Invalid input

a: b
  c: d

Parser error

Nested mappings are not allowed in compact mappings at line 1, column 4:

Conversion refuses to guess at malformed YAML and reports the parser's exact error location instead.

Corrected version

a: b
c: d

Best Practices & Notes

Best Practices

Quote any string value that happens to look like a YAML boolean or null keyword before converting, if you need it to stay a string.
Validate the YAML first if you're not sure it's well-formed, so a parse error doesn't surprise you mid-conversion.
Keep the original YAML around if it has comments you rely on for documentation.

Developer Notes

This calls the `yaml` package's `parse()` and pipes the result straight into `JSON.stringify(value, null, indent)`. No intermediate transformation happens between the two, so the JSON output is a faithful, direct serialization of exactly what the YAML parser resolved your document to.

YAML to JSON Converter Use Cases

Feeding a YAML config into a JSON Schema validator
Converting a Kubernetes manifest to JSON for a `jq`-based pipeline
Preparing YAML test fixtures for a JSON-only test harness
Inspecting exactly what a YAML document parses to, including resolved anchors

Common Mistakes

Assuming `yes`/`no`/`on`/`off` convert to booleans the way they do in some older YAML 1.1 tools, when this converter's YAML 1.2 core schema keeps them as plain strings.
Assuming comments survive the conversion, when JSON has no way to represent them.
Converting only part of a multi-document YAML stream without realizing later documents were skipped.

Tips

If a value converts to a boolean unexpectedly, quote it in the source YAML and reconvert.
Use the YAML Validator first for a quick syntax check before converting a large or unfamiliar file.
Pair this with the JSON Formatter's sort-keys option if you need a deterministic, diff-friendly JSON representation.

YAML to JSON Converter