YAML to JSON Converter - Free Online Tool for DevOps, Kubernetes, and Configuration Files

Kubernetes Manifest Conversion

Kubernetes accepts both YAML and JSON for resource definitions, but many programmatic tools and client libraries work exclusively with JSON. The Kubernetes API server itself communicates in JSON - YAML files are converted to JSON internally by kubectlbefore being sent to the API. Custom operators built with the Kubernetes Go client, Node.js client, or Python client (kubernetes-client) often construct or patch resources using JSON payloads. The kubectl patch command's--type=merge and--type=strategic flags accept JSON patch documents. Converting your YAML manifest to JSON first lets you build these payloads interactively without writing a parser.

Helm Chart Values Files

Helm uses YAML for values.yaml files, but several third-party Helm tooling projects and policy engines (like Conftest with OPA/Rego policies, or Datree) accept JSON for programmatic validation. Converting a Helm values file to JSON lets you query it with jq, validate it against a JSON Schema, or feed it into a policy-as-code pipeline that expects structured JSON input.

Docker Compose to JSON for CI/CD Automation

Docker Compose files are YAML, but custom CI/CD automation scripts written in JavaScript, TypeScript, or Python often need to parse and manipulate service definitions programmatically. Convertingdocker-compose.yml to JSON lets you use standard JSON tooling to extract service names, image tags, environment variables, volume mounts, and port mappings without pulling in a YAML parsing dependency.

GitHub Actions and GitLab CI Workflow Analysis

GitHub Actions workflow files and GitLab CI configuration files are both YAML. When building tools that analyze, visualize, lint, or generate these workflows programmatically - for example, a dashboard that maps job dependencies, a security scanner that checks for unsafe uses of ${{{ github.event.inputs }}}}, or a template engine that generates workflows from a JSON schema - having the workflow in JSON form makes it immediately consumable by any JSON-aware tool without introducing a YAML parsing dependency.

Ansible Playbooks and Variable Files

Ansible playbooks, host variables, and group variables are all stored as YAML files. When integrating Ansible with external systems - a CMDB (Configuration Management Database), a service catalog, a monitoring platform, or a ticket management system via REST API - you often need to represent host facts, variable values, or task results as JSON. Converting the relevant YAML structures to JSON provides a clean interface to these integrations.

OpenAPI and Swagger Specification Conversion

OpenAPI 3.x and Swagger 2.0 specifications can be written in either YAML or JSON. Many API tooling platforms, code generators (openapi-generator, swagger-codegen), and API gateways accept only one format. Converting an OpenAPI spec from YAML to JSON (or vice versa) is a routine step when integrating with tools that do not support both. This converter handles the full depth and breadth of a typical OpenAPI document including$ref chains, nested schema objects, and security definition blocks.

Terraform and Infrastructure as Code (IaC)

While Terraform's native format is HCL, many Terraform modules use YAML variable files (processed by the yamldecode()function) for environment-specific configurations. Converting these YAML variable files to JSON helps you inspect, validate, and version their structure using JSON tooling, or feed them into Terraform's JSON-native variable format for providers that require it.

Application Configuration Files

Many application frameworks - Spring Boot, Rails, Node.js apps withconfig or convict, Python apps with dynaconf - support both YAML and JSON configuration files. During development or debugging, it is sometimes useful to see the YAML configuration rendered as JSON to verify that environment variable overrides, nested merge logic, or type coercions produced the expected resolved configuration object.

Tabs vs Spaces - The Most Common YAML Error

YAML strictly forbids tab characters for indentation. Only spaces are allowed. This is the single most frequent cause of YAML parse errors. Many text editors - especially those configured for Python or Makefile editing - insert literal tab characters when you press Tab. Configure your editor to use spaces for .yml and.yaml files, or runexpand -t 2 file.yaml to convert tabs to spaces before pasting into this tool.

Comments Are Stripped in the JSON Output

JSON has no comment syntax. All YAML comments - lines starting with# and inline comments after values - are removed during conversion. This is by design and by the JSON specification. If you need to preserve documentation alongside the data, keep the YAML as the authoritative source and generate JSON only for consumption by tools that require it.

Anchors and Aliases Are Expanded

YAML supports node reuse via anchors (&anchor_name) and aliases (*anchor_name). In the JSON output, aliases are fully resolved and expanded into their referenced values - JSON has no concept of references or shared nodes. This means a YAML file that uses anchors to avoid repeating a block will produce a JSON file where that block appears multiple times in full. The data is equivalent; only the compactness is lost.

The Norway Problem - Boolean Gotchas in YAML 1.1

YAML 1.1 - the version implemented by most tools including Go'sgopkg.in/yaml.v2, Python'sPyYAML, and Ruby'sPsych - interprets the valuesyes, no,on, off,true, and false as booleans. Country code abbreviations like NO (Norway) and ON (Ontario) have historically been misinterpreted as boolean values. YAML 1.2 (the current specification) restricts booleans to only true and false. If your YAML is processed by a YAML 1.1 tool and you need to preserve these values as strings, wrap them in quotes:"yes","NO","on".

Multi-Line String Blocks

YAML supports two multi-line string styles. The literal block scalar (|) preserves newlines exactly. The folded block scalar (>) folds newlines into spaces. In JSON, both are represented as regular strings with embedded\n characters (for the literal style) or as single-line strings (for the folded style). Multi-line strings in YAML configuration - often used for inline shell scripts in GitHub Actions, SQL queries in Ansible tasks, or certificate PEM blocks in Kubernetes secrets - convert cleanly to their JSON string equivalents.

Multi-Document YAML Streams

A single YAML file can contain multiple documents separated by---. This is common in Kubernetes resource files that bundle multiple objects (e.g., a Deployment, a Service, and a ConfigMap) in a single file. This tool processes the first document in a stream. For multi-document files, split them at the --- boundaries before pasting, or use theyq command-line tool which handles multi-document streams natively.

Numeric String Ambiguity

YAML performs implicit type coercion. A value like10001 will be parsed as an integer, not a string. If you need a value to be a JSON string rather than a number - for example, a ZIP code, a version string like1.0 that should not become a float, or a numeric ID that must stay a string - wrap it in quotes in the YAML source: zip: "10001". The converter will correctly output "10001" as a JSON string.

Node.js - using js-yaml (recommended)

const fs   = require("fs");
const yaml = require("js-yaml");

const yamlContent = fs.readFileSync("config.yaml", "utf8");
const jsonObject  = yaml.load(yamlContent);          // Parse YAML → JS object
const jsonString  = JSON.stringify(jsonObject, null, 2); // Serialize → JSON

fs.writeFileSync("config.json", jsonString);
console.log("Converted successfully");

Install: npm install js-yaml. js-yaml is the most widely adopted YAML parser in the Node.js ecosystem and implements YAML 1.2.

Python - using PyYAML

import yaml
import json

with open("config.yaml", "r") as f:
    data = yaml.safe_load(f)          # safe_load avoids arbitrary code execution

with open("config.json", "w") as f:
    json.dump(data, f, indent=2)

print(f"Converted {len(data)} top-level keys")

Install: pip install pyyaml. Always usesafe_load() instead ofload() to prevent arbitrary object deserialization when processing YAML from untrusted sources.

Python - using ruamel.yaml (preserves comments, round-trip safe)

from ruamel.yaml import YAML
import json

yaml = YAML()
with open("config.yaml") as f:
    data = yaml.load(f)

# Convert CommentedMap/CommentedSeq to plain dicts/lists for JSON serialization
def to_plain(obj):
    if isinstance(obj, dict):
        return {k: to_plain(v) for k, v in obj.items()}
    if isinstance(obj, list):
        return [to_plain(i) for i in obj]
    return obj

with open("config.json", "w") as f:
    json.dump(to_plain(data), f, indent=2)

CLI - using yq (the YAML equivalent of jq)

# Install: brew install yq  (macOS)
# Install: snap install yq  (Linux)

# Convert a single YAML file to JSON
yq -o=json config.yaml > config.json

# Convert all YAML files in a directory
for f in *.yaml; do
    yq -o=json "$f" > "$(basename "$f" .yaml).json"
done

# Extract a specific field and output as JSON
yq -o=json '.spec.containers[0]' deployment.yaml

yq is the most powerful CLI tool for YAML processing. It supports multi-document files, in-place editing, complex queries, and full YAML 1.2 compliance. It is the recommended tool for production pipeline use.

Go - using gopkg.in/yaml.v3 + encoding/json

package main

import (
    "encoding/json"
    "fmt"
    "os"
    "gopkg.in/yaml.v3"
)

func main() {
    yamlData, _ := os.ReadFile("config.yaml")
    var obj interface{}
    yaml.Unmarshal(yamlData, &obj)
    jsonData, _ := json.MarshalIndent(obj, "", "  ")
    fmt.Println(string(jsonData))
}

Can I convert a Kubernetes YAML manifest to JSON?

Yes, this is one of the most common use cases. Paste the full content of any .yaml Kubernetes resource file - Deployment, Service, ConfigMap, Secret, StatefulSet, Ingress, or any custom resource definition - and the tool will produce the equivalent JSON object. The output is compatible withkubectl patch --type=merge, the Kubernetes REST API, and Kubernetes client libraries in all languages.

Does the converter handle nested objects and arrays?

Yes. YAML's nested mappings (objects) and sequences (arrays) are fully supported at any depth. Deeply nested structures like a Kubernetes pod spec with containers, environment variables, volume mounts, resource requests, and liveness probes convert correctly to nested JSON objects and arrays.

What happens to YAML comments in the output?

All YAML comments are stripped. JSON does not support comments, so there is no valid way to preserve them in the output. If you need to keep comments alongside the configuration data, maintain the YAML as your source of truth and use this converter to generate the JSON artifact on demand.

How are YAML booleans (yes/no/on/off) handled?

In YAML 1.1 (used by most tools), yes, no,on, off,true, and false are all treated as boolean values and converted to JSONtrue or false. If you need these values to remain as strings in the JSON output, quote them in the YAML source: active: "yes" produces"active": "yes" in JSON.

Can I convert a Docker Compose file to JSON?

Yes. Open your docker-compose.yml ordocker-compose.yaml file in a text editor, copy all contents, paste into this tool, and copy the JSON output. The resulting JSON represents the full Compose configuration including services, volumes, networks, environment variables, and port mappings.

Is the output valid JSON?

Yes. The output is strict RFC 8259 compliant JSON. The green checkmark confirms that JSON.parse() will succeed on the output without errors. The output is also compatible with JSON Schema validators, jq, JSONPath tools, and all standard JSON parsing libraries.

Does this tool support multi-document YAML files (with ---)?

The tool processes a single YAML document. Multi-document files containing multiple documents separated by --- - common in Kubernetes resource bundles - will have only the first document converted. Split the file at each --- boundary before pasting, converting one document at a time. For automated multi-document processing, use the yq CLI tool.

Is my YAML data secure? Does it get sent anywhere?

No data is transmitted to any server. The YAML parsing and JSON serialization run entirely inside your browser's JavaScript engine. This makes the tool safe for YAML files that contain database passwords, TLS private keys, API tokens, internal hostnames, and other sensitive infrastructure configuration that must not leave your network perimeter.

How do I convert YAML to JSON on the command line?

The best CLI option is yq:yq -o=json input.yaml > output.jsonAlternative using Python (no dependencies beyond the standard library and PyYAML):python3 -c "import sys,yaml,json; print(json.dumps(yaml.safe_load(sys.stdin), indent=2))" < input.yaml > output.json

Can I convert an OpenAPI or Swagger YAML spec to JSON?

Yes. OpenAPI 3.x and Swagger 2.0 specifications are valid YAML documents and convert cleanly using this tool. The output JSON can be fed to API code generators, linting tools, API gateways (like AWS API Gateway, Kong, or Azure API Management), and documentation platforms that require JSON format for their import workflows.