Convert YAML to JSON Online for Free

YAML to JSON: Turning Config Files Into Data Your Code Can Use

YAML is the format behind Kubernetes manifests, Docker Compose files, GitHub Actions pipelines, and countless application config files, precisely because it lets a human write nested settings without a forest of brackets and quotation marks. The trouble is that most programming languages and APIs expect JSON, not YAML, once that configuration needs to be read, transformed, or sent somewhere programmatically. A YAML-to-JSON converter closes that gap: it reads the indentation-based structure and re-expresses it as ordinary JSON, keeping every mapping, list, and scalar value intact. This tool runs that conversion in your browser — paste a YAML document, and the equivalent JSON appears immediately, produced by JavaScript loaded into the page rather than sent off to be processed elsewhere.

Reaching for a converter instead of writing a parser yourself usually comes down to how many small YAML quirks there are to get right: a bare word like True or FALSE is recognized as a boolean regardless of its capitalization, indentation alone (not braces) defines nesting depth, and a document can reference the same block twice through an anchor and alias rather than repeating it. Reimplementing all of that correctly, by hand, for every config file you need to inspect is rarely worth the time a converter saves.

How to Convert YAML Into JSON With This Tool

1. Paste your YAML document into the left panel, or click File to load a .yaml or .yml file from your device — it's read locally and dropped straight into that same box, with the conversion running the moment the parser (loaded in the background when the page opens) is ready.
2. Watch the status line under the input: a green confirmation means the document parsed without issue, while a red message reports the specific problem — often a tab character where YAML expects spaces, or an indentation level that doesn't line up with any enclosing block.
3. Pick an indent width of two or four spaces for the resulting JSON's formatting, and toggle Sort keys if you'd rather see object keys alphabetized than left in the order they appeared in the source document.
4. Use the swap control between the panels to flip direction and go from JSON back to YAML on the same page, useful for quickly checking how an edit would round-trip before committing to it.
5. Copy the resulting JSON to your clipboard, or download it as a .json file for use elsewhere.

The YAML parser itself loads asynchronously in the background the moment the page opens, so by the time you've pasted anything in, it's typically already sitting ready — there's no separate "load" step to wait through, and no document is uploaded anywhere to make any of this happen.

Why Convert YAML to JSON in the First Place

• Feeding a config file into a script that only reads JSON. Plenty of tooling, especially in JavaScript and Python ecosystems, has first-class JSON parsing but only optional or third-party YAML support, making conversion the path of least resistance.
• Inspecting a Kubernetes manifest or Helm values file programmatically. Tools built around the Kubernetes API frequently work with JSON internally even when the source manifests are authored in YAML, so converting lets a script query a specific field directly.
• Debugging deeply nested configuration. YAML's indentation-only nesting can be genuinely hard to eyeball once a file is a few levels deep; seeing the same structure as bracketed JSON sometimes makes a misplaced setting far easier to spot.
• Comparing two versions of a config file. Some diffing and comparison tools handle JSON's explicit structure more predictably than YAML's whitespace-sensitive one, particularly when indentation style itself has changed between versions.
• Passing CI/CD pipeline configuration into a custom build step. A GitHub Actions or GitLab CI file is YAML, but a custom script reading part of it for a templating or validation step often finds a JSON representation simpler to work with directly.
• Loading application settings into a browser-based tool. A JavaScript app that already ships a JSON schema validator, or a settings UI built around JSON, can read a converted config far more easily than adding a second, YAML-specific parsing path just for one file format.

Why the Safe Schema Matters

YAML the specification allows tags that go well beyond plain data — a document can, in principle, declare a value's type explicitly, and some YAML libraries historically supported tags that instructed the parser to construct a native function, a regular expression object, or other language-specific constructs directly from the document text. That's a meaningful risk if a parser ever runs untrusted input: a maliciously crafted YAML file using one of those tags could, on a permissive parser, end up constructing and even executing code purely by being loaded. The library behind this converter, js-yaml, avoids that entirely by using its safe default schema when parsing: unsafe tags such as one that would construct a callable function are simply not recognized, and a document containing one raises a parsing error rather than being quietly deserialized into something executable. Nothing about this converter — on the page or through its API — imports or opts into the separate, unsafe schema module that would be required to change that behavior.

Two more specific behaviors are worth knowing about the underlying parser. First, anchors and aliases — YAML's own mechanism for referencing one block of the document from another location within the same document, written as &name and *name — are fully supported and expanded into the repeated structure they represent in the resulting JSON, rather than left as an unresolved reference. Second, the parser reads a single YAML document per request: a string containing multiple documents separated by a --- marker, the way a single file sometimes bundles several Kubernetes resources together, isn't something a single parse call is built to split apart, and passing one is reported as invalid input rather than silently returning just the first document.

How YAML Syntax Maps to JSON

YAML syntax	Resulting JSON
A key-and-value mapping, e.g. name: Alice	An object property: "name": "Alice"
A dash-prefixed list, e.g. - one / - two	A JSON array: ["one", "two"]
Bare words true, false, null, or ~	The corresponding JSON boolean or null literal, unquoted
An anchor and alias referencing the same block twice	The full block, expanded and duplicated at both locations
A quoted string, e.g. "42"	Kept as the string "42", not converted to a number
A # comment line	Not represented — comments carry no data through the conversion

Manual Parsing vs. Using This Converter

• Writing your own indentation-tracking parser. A genuinely hard problem to get fully right — YAML's whitespace sensitivity, anchors, and multiple ways of writing the same scalar value make a complete hand-rolled parser a much bigger undertaking than it initially looks.
• Your code editor's built-in YAML support. Handy for browsing a file you already have open, though most editors show YAML as YAML rather than offering a one-click conversion to JSON alongside it.
• A programming language's YAML library, called from a script. The right call when this conversion is one step in an automated pipeline — a deployment script or a config-validation job — rather than a task someone is doing by hand in a given moment.
• This tool's metered API. The same safe-schema parsing described above is available as a REST endpoint that accepts a yaml string and returns the parsed value as JSON, intended for a server, script, or CI job calling it directly rather than a person opening this page at all.

How This Tool Handles Your Data

Nothing about the conversion above touches a server: the YAML you paste is interpreted directly by JavaScript loaded into your browser, and the JSON you see comes back without uploading anything to produce it. For programmatic use — a deployment script pulling apart a values file, say, or a CI job validating a pipeline definition — the same parsing logic is also published as a metered REST endpoint, and that path does involve sending the YAML content to our server as part of the request, unlike using the page itself, which keeps the document local from the moment you paste it to the moment you copy the result.

Will a maliciously crafted YAML file execute code when I convert it here?

No. The parser behind this tool loads only its safe default schema, which doesn't recognize the unsafe tags — such as one that would construct a callable function — that would be needed to make that kind of attack work on a more permissive parser. A document using one of those tags simply fails to parse, reported as invalid input rather than partially executed.

Does this tool support YAML anchors and aliases?

Yes. A block referenced elsewhere in the same document through an anchor and alias is expanded into the full repeated structure in the resulting JSON, rather than left as a shorthand reference the way it's written in the source YAML.

Can I convert a file containing multiple YAML documents separated by "---"?

Not in one call. The parser used here reads a single YAML document at a time; a string containing several documents joined by --- separators is treated as invalid input rather than being split and processed piece by piece automatically.

Why did a value like "True" in my YAML come back as a boolean instead of text?

The parser recognizes true/false and their capitalized variants (True, TRUE, and so on) as YAML's boolean shorthand rather than as literal words — note that YAML 1.1 favorites like yes, no, on, and off are not treated as booleans here and pass through as plain strings. If you need true or false itself preserved as literal text, wrap it in quotes in the source YAML — a quoted value is always kept as a string rather than reinterpreted.

Does the JSON output preserve the order of keys from my YAML?

By default, yes — keys appear in the JSON in the same order they were written in the source document. The on-page tool's Sort keys option can alphabetize them instead if that's more useful for comparing output between runs.

Does this tool understand block scalars, like a multi-line string written with a pipe or a greater-than sign?

Yes. YAML's block scalar styles — a pipe character for a literal block that keeps line breaks, and a greater-than sign for a folded block that joins lines with spaces instead — are both parsed into a single JSON string value, with the line-break handling appropriate to whichever style the source document used.

Related Tools

Need to go the other direction? JSON to YAML takes the same kind of parsed data and renders it back as a properly indented YAML document. If the data underneath your config is really tabular, JSON to CSV can flatten a JSON export into spreadsheet rows once you've converted it here. And if you're working across formats more broadly, XML to JSON covers the same JSON destination starting from tag-based documents instead of indentation-based ones.