YAML to JSON Converter

What is JSON?

// Convert YAML to JSON in Node.js using the eemeli/yaml library
import { parseAllDocuments } from 'yaml';

const yamlString = `apiVersion: apps/v1
kind: Deployment`;

// parseAllDocuments handles multi-document YAML (--- separator)
// version: '1.2' ensures yes/no are strings, not booleans
// merge: true expands anchor/alias merge keys (<<: *anchor)
const docs = parseAllDocuments(yamlString, { version: '1.2', merge: true });

// Take the first document (skip additional --- blocks)
const json = JSON.stringify(docs[0].toJSON(), null, 2);

console.log(json);
// {
//   "apiVersion": "apps/v1",
//   "kind": "Deployment"
// }

Key Features

Examples

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
  namespace: production
  labels:
    app: my-app
    version: 1.0.0
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
        - name: my-app
          image: my-app:1.0.0
          ports:
            - containerPort: 8080
          resources:
            requests:
              memory: 64Mi
              cpu: 250m
            limits:
              memory: 128Mi
              cpu: 500m

version: '3.9'
services:
  web:
    image: nginx:1.25-alpine
    ports:
      - '80:80'
      - '443:443'
    environment:
      NGINX_HOST: example.com
      NGINX_PORT: '80'
    depends_on:
      - db
    restart: unless-stopped
  db:
    image: postgres:16-alpine
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: admin
      POSTGRES_PASSWORD: secret
    volumes:
      - pgdata:/var/lib/postgresql/data
volumes:
  pgdata: {}

name: CI
on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main
jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - name: Set up Node.js
        uses: actions/setup-node@v4
        with:
          node-version: '20'
          cache: pnpm
      - name: Install dependencies
        run: pnpm install --frozen-lockfile
      - name: Run tests
        run: pnpm test

openapi: 3.0.3
info:
  title: User API
  version: 1.0.0
  description: Manage application users
paths:
  /users:
    get:
      summary: List users
      operationId: listUsers
      parameters:
        - name: limit
          in: query
          schema:
            type: integer
            default: 20
      responses:
        '200':
          description: Success
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/User'
  /users/{id}:
    get:
      summary: Get user
      operationId: getUser
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: Success
components:
  schemas:
    User:
      type: object
      properties:
        id:
          type: string
        name:
          type: string
        email:
          type: string
          format: email

replicaCount: 3
image:
  repository: my-app
  tag: 1.0.0
  pullPolicy: IfNotPresent
service:
  type: ClusterIP
  port: 80
ingress:
  enabled: true
  className: nginx
  hosts:
    - host: my-app.example.com
      paths:
        - path: /
          pathType: Prefix
resources:
  requests:
    memory: 64Mi
    cpu: 250m
  limits:
    memory: 128Mi
    cpu: 500m
autoscaling:
  enabled: false
  minReplicas: 1
  maxReplicas: 10
  targetCPUUtilizationPercentage: 80

- name: Configure web servers
  hosts: webservers
  become: true
  vars:
    http_port: 80
    max_clients: 200
  tasks:
    - name: Ensure nginx is installed
      ansible.builtin.package:
        name: nginx
        state: present
    - name: Start nginx service
      ansible.builtin.service:
        name: nginx
        state: started
        enabled: true
    - name: Copy nginx config
      ansible.builtin.template:
        src: nginx.conf.j2
        dest: /etc/nginx/nginx.conf
        owner: root
        group: root
        mode: '0644'
      notify:
        - Restart nginx
  handlers:
    - name: Restart nginx
      ansible.builtin.service:
        name: nginx
        state: restarted

How to Use

1. 1

   Paste Your YAML

   Enter or paste your YAML data into the input field above. You can also click 'Load example' to try a sample like a Kubernetes Deployment, Docker Compose file, or Helm values.yaml.

2. 2

   See Live JSON Output

   JSON appears instantly in the output panel. Adjust Options (indent 2 or 4 spaces) to match your target tool's requirements.

3. 3

   Copy or Download

   Click Copy to grab the JSON to your clipboard, or Download to save it as a .json file ready for jq, API calls, or any downstream tooling.

Common YAML Pitfalls

services:
	web:
		image: nginx:1.25-alpine

services:
  web:
    image: nginx:1.25-alpine

metadata:
  name: my-app
   namespace: production

metadata:
  name: my-app
  namespace: production

url: http://example.com:8080/api
tag: #latest

url: 'http://example.com:8080/api'
tag: '#latest'

# Circular anchor (rare but possible)
base: &base
  parent: *base

# Use explicit fields instead of circular references
base:
  parent: null

# Only the first document is converted
apiVersion: v1
kind: ConfigMap
---
apiVersion: v1
kind: Secret

# Convert each document separately
apiVersion: v1
kind: ConfigMap

# This comment will be lost
replicas: 3 # scale this up for production

replicas: 3
_comment: scale this up for production

Common Use Cases

Kubernetes Manifest Analysis

Convert Kubernetes YAML manifests to JSON for querying with jq, sending to the Kubernetes REST API, processing in Terraform data sources, or feeding into CI/CD pipelines that expect JSON.

Docker Compose to JavaScript Tooling

Parse Docker Compose YAML to JSON to extract service definitions, image names, port mappings, and environment variables for use in automation scripts, dependency graphs, or Node.js tooling.

GitHub Actions API Integration

Convert GitHub Actions workflow YAML to JSON to validate structure programmatically, extract job and step definitions, or integrate with CI/CD APIs that accept JSON workflow specifications.

OpenAPI to Client Code Generation

Many code generators (openapi-generator, swagger-codegen, oazapfts) accept OpenAPI specs in either format. Convert your YAML spec to JSON when a tool specifically requires JSON input or when you need to inspect it with JSON Schema validators.

Helm Values Analysis

Convert Helm chart values.yaml to JSON to generate reports, compare values across environments, feed into policy enforcement tools, or process with automation that expects JSON configuration.

Config Migration to JSON-Based Tools

Migrate application configuration from YAML (common in infrastructure tools) to JSON for use in JavaScript environments, REST APIs, AWS AppConfig, Azure App Configuration, or any system that stores configuration as JSON.

Technical Details

YAML 1.2 Spec via parseAllDocuments with merge:true

YAML is parsed using the eemeli/yaml library (v2.8+, CVE-safe) via parseAllDocuments with { version: '1.2', merge: true }. The YAML 1.2 schema ensures bare strings like yes and no are treated as strings (not booleans), matching the current YAML specification. The merge: true option fully expands anchor/alias merge keys (<<: *anchor) so the JSON output contains complete, dereferenced data. Multi-document YAML (--- separated) returns the first document.

Anchor and Alias Expansion via Library

The eemeli/yaml library handles anchor (&name) and alias (*name) expansion safely, including circular reference detection. All aliased data blocks — including merge key expansions — are fully inlined in the JSON output. This is the correct transformation because JSON has no reference or anchor concept. The library's safe expansion prevents infinite loops from malformed YAML.

Browser-Based — No Upload, No Server

All processing happens entirely in your browser's JavaScript engine. No data is transmitted over the network at any point. Inputs larger than 200KB automatically switch from live mode to manual mode (requiring an explicit Convert click) to keep the browser responsive and prevent main-thread blocking during heavy serialization.

Best Practices

Use YAML 1.2-Compatible Syntax for Clean Conversion

Author your YAML using YAML 1.2 conventions — quote yes, no, on, off, y, and n string values explicitly (e.g., enabled: 'yes') to avoid ambiguity. This tool parses with the YAML 1.2 schema (so these are strings), but older tools in your pipeline may use YAML 1.1 (where they become booleans). Explicit quoting in the source YAML is the safest practice across all parsers.

Quote Large Numbers in YAML to Preserve Precision

JavaScript cannot represent integers larger than 2^53 - 1 (9007199254740991) exactly. Kubernetes fields like resourceVersion and uid are int64 on the server and can exceed this limit. In your YAML source, quote these values (resourceVersion: '9007199254740993') so the parser treats them as strings, which are then preserved exactly in the JSON output as string values.

Validate JSON Output Before Using in APIs

After converting YAML to JSON, validate the result before sending it to an API, storing it, or processing it programmatically. Use our JSON Formatter to confirm the structure is correct. This is especially important for Kubernetes API calls, OpenAPI specs, and any JSON Schema-validated payload, where a structural error causes a confusing rejection at the API layer rather than at the conversion step.

Separate Multi-Document YAML Before Converting

If your YAML file contains multiple --- separated documents and you need all of them as JSON, split the file on --- first and convert each document individually. This tool takes only the first document. A simple approach: split on '\n---\n' in your editor or with awk, then paste each section separately.

Use jq for Downstream JSON Processing

Once you have JSON from your YAML, jq is the fastest way to query and transform it from the command line. Combine this tool with jq: convert your YAML online, paste the JSON, then use jq '.spec.replicas' or jq '.services | keys' to extract exactly what you need. For batch processing of many files, use the yq CLI with -o json flag directly.

Frequently Asked Questions