YAML Formatter: Validate & Beautify YAML

What Is YAML Formatter?

YAML Formatter is a browser-based tool that parses, validates, and re-serializes YAML text with consistent, configurable indentation. YAML's indentation-sensitive syntax means a single misaligned block can change the meaning of an entire document or produce an error that is difficult to locate by eye. This tool catches those problems immediately and produces clean output that matches your preferred style.

Beyond basic formatting, the tool converts YAML directly to JSON — useful when an API or tool requires JSON but your source configuration is YAML, or when you need to verify that your YAML parses to the expected data structure. Both operations run entirely in your browser using the js-yaml library. No data leaves your machine, there is no account, and the tool is free.

Key Features

• Format YAML with proper indentation — Parses the input with js-yaml and re-dumps it with your chosen indent size. The lineWidth: -1 option prevents the formatter from introducing line breaks in long strings, and noRefs: true expands anchors and aliases into their full values.
• Validate YAML syntax with error messages — If js-yaml throws a parse error, the exact error message (including line number) appears below the output panel. Errors use an accessible role="alert" attribute.
• Convert YAML to JSON — Parses the YAML and serializes the result as JSON using JSON.stringify with your selected indentation. The download logic detects whether the output starts with { or [ and saves it with a .json extension automatically.
• Copy formatted output to clipboard — Uses the Clipboard API with a textarea fallback.
• Download as .yaml or .json file — When the output is JSON (from the Convert operation), the file saves as formatted.json. When the output is YAML (from the Format operation), it saves as formatted.yaml.
• Keyboard shortcuts — Ctrl+Enter (Cmd+Enter) formats; Ctrl+Shift+J (Cmd+Shift+J) converts to JSON.

How to Use YAML Formatter

Step 1: Paste Your YAML

Navigate to the tool at /developer/code/yaml-formatter. Paste your YAML into the Input panel on the left. The textarea is monospace and resizable. YAML documents of any size that fit in browser memory are accepted — there is no size restriction enforced by the tool.

Step 2: Choose Indentation

Open the indent dropdown in the action bar below the panels. Choose 2 spaces or 4 spaces. The selection affects both the Format output and the JSON conversion output. Two-space indent is the YAML community default and is used by Kubernetes manifests, Ansible playbooks, and most CI/CD pipeline files. Four-space indent aligns with some Python and Java project conventions.

Step 3: Format or Convert

Click Format (or press Ctrl+Enter / Cmd+Enter) to produce normalized YAML output in the right panel. Click To JSON (or press Ctrl+Shift+J / Cmd+Shift+J) to produce an equivalent JSON document.

Example input — a Kubernetes Deployment manifest with inconsistent indentation:

apiVersion: apps/v1
kind: Deployment
metadata:
    name: web-frontend
    labels:
      app: web
spec:
  replicas: 3
  selector:
      matchLabels:
        app: web
  template:
      metadata:
        labels:
          app: web
      spec:
        containers:
        - name: nginx
          image: nginx:1.25
          ports:
          - containerPort: 80

Output after Format with 2-space indent:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-frontend
  labels:
    app: web
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web
  template:
    metadata:
      labels:
        app: web
    spec:
      containers:
        - name: nginx
          image: nginx:1.25
          ports:
            - containerPort: 80

Step 4: Convert to JSON (Optional)

With the same YAML in the input, click To JSON. The output panel shows the equivalent JSON document:

{
  "apiVersion": "apps/v1",
  "kind": "Deployment",
  "metadata": {
    "name": "web-frontend",
    "labels": {
      "app": "web"
    }
  }
}

(truncated for brevity — the full document would include spec)

Step 5: Copy or Download

Click Copy to copy the output to your clipboard. Click Download to save the file. The tool automatically chooses .yaml or .json as the file extension based on whether the output looks like JSON (starts with { or [).

Practical Examples

Normalizing a CI/CD Pipeline File

A GitHub Actions workflow file has been edited by multiple contributors and has mixed indentation. Paste it into the formatter, click Format with 2-space indent, and the output shows consistent indentation throughout. Before committing the change, compare the input and output to confirm no semantic differences were introduced — since YAML is indentation-sensitive, reformatting can expose alignment bugs that were hiding in the original.

Verifying Configuration Structure

You maintain a configuration file for a Node.js application that is deployed with YAML but the runtime reads it as a parsed JavaScript object. Paste the config and click To JSON. The JSON output shows exactly what the parsed object looks like, including any type coercions (bare true/false → booleans, unquoted numbers → numbers). This confirms that values like port: 8080 will be a number and not the string "8080".

Input:

server:
  host: 0.0.0.0
  port: 8080
  debug: false
database:
  url: postgres://localhost:5432/myapp
  pool: 10

JSON output:

{
  "server": {
    "host": "0.0.0.0",
    "port": 8080,
    "debug": false
  },
  "database": {
    "url": "postgres://localhost:5432/myapp",
    "pool": 10
  }
}

Expanding YAML Anchors

YAML supports anchors (&) and aliases (*) for reusing values. The formatter uses noRefs: true, which means all aliases are expanded into their full values in the output. This makes the formatted document self-contained and easier to read in tools that do not support anchors.

Tips and Best Practices

The formatter preserves key order. The js-yaml dump options include sortKeys: false, so your key ordering is maintained as-is in the formatted output. This is important for Kubernetes and Ansible documents where field order carries convention even if not technically required.

Long strings are not wrapped. The lineWidth: -1 setting disables automatic line-wrapping. Multi-line strings and long values will remain on a single line rather than being broken at an arbitrary column. If you need line-wrapped output, copy the result and apply wrapping in your editor.

Validate before committing to version control. YAML indentation errors are a common source of CI failures. Run your pipeline file through this formatter before pushing. A clean format pass with no error message confirms the YAML is syntactically valid.

Check the file extension on download. The download logic inspects the output content, not the operation you performed. If you formatted YAML and the YAML happens to start with { (some YAML files use JSON-compatible syntax), the file saves as .json. Rename it if needed.

YAML booleans are strict. The YAML specification recognizes true, false, yes, no, on, and off as boolean values in YAML 1.1. The js-yaml library follows YAML 1.2 by default where only true and false are booleans. If your YAML uses yes/no, the formatter treats them as plain strings.

Common Issues and Troubleshooting

Error message with a line and column number — js-yaml parse errors include the exact location of the problem. Look at the indicated line in your input. Common causes are: tabs used for indentation instead of spaces (YAML does not allow tabs), a colon inside an unquoted string (e.g., url: http://example.com must be url: "http://example.com" or use a block scalar), or incorrect nesting level.

Output is missing values that were in the input — If your YAML uses !! type tags (e.g., !!binary, !!timestamp) that js-yaml does not recognize, those values may be dropped or transformed. Inspect the specific values to identify the type tag and quote the value if needed.

"Please enter YAML to format" error — The input field is empty or whitespace-only when you clicked Format or Convert. Paste your YAML into the input panel first.

Converted JSON has unexpected null values — A YAML value of ~ or an empty value (key with no value after the colon) becomes null in JSON. This is correct behavior and matches the YAML specification. Quote the value if you intended it to be the string "~" or an empty string "".

Download saves as .json instead of .yaml — The download handler checks if the output starts with { or [. Some YAML documents are written in JSON-compatible YAML syntax and start with a brace. If this is the case with your output, rename the downloaded file to .yaml after saving.

Privacy and Security

YAML Formatter processes all input locally in your browser using the js-yaml library. No text you paste — including database connection strings, API tokens, private keys, or personal configuration data — is sent to any server. The tool functions with no network connection once the page has loaded. There is no session tracking on the formatting operations.

Frequently Asked Questions

Is YAML Formatter free? Yes, completely free with no usage limits. All formatting, validation, and conversion operations are available at no cost. Glyph Widgets supporter features — saved presets, session history, tool notes — are available to Ko-fi supporters, but the core YAML functionality requires nothing.

Does it work offline? Yes. All processing runs in your browser. Once the page loads, you can disconnect from the internet and continue using the formatter and converter without interruption.

Is my data safe? Yes. Your YAML input is never transmitted to a server. It lives only in your browser's memory and is cleared when you click Clear or close the tab.

Does the formatter support YAML multi-document files (multiple --- sections)? The js-yaml load function parses the first document in a stream. Multi-document YAML files (separated by ---) will only have their first document formatted. Use yaml.loadAll behavior for multi-document files — but this tool currently processes the first document only.

What is the difference between Format and Convert to JSON? Format re-serializes the parsed YAML back as YAML with consistent indentation. Convert to JSON serializes the same parsed data as a JSON document. Both operations use the same parse step, so they both validate the YAML and fail identically on invalid input.

Does the tool preserve comments? No. The js-yaml parser discards comments during parsing. After formatting, comments in the original input will not appear in the output. If you need to preserve comments, edit the indentation manually in your source file.

Can I convert JSON to YAML? This tool converts YAML to JSON. To convert in the other direction, use the JSON Converter tool, which supports JSON-to-YAML conversion.

What YAML version does the tool support? The js-yaml library implements YAML 1.2, which is stricter about boolean values and some other edge cases compared to YAML 1.1. Most modern YAML files (Kubernetes, Docker Compose, GitHub Actions, etc.) are written to be YAML 1.2 compatible.

What is the keyboard shortcut for converting to JSON? Press Ctrl+Shift+J on Windows/Linux or Cmd+Shift+J on macOS to trigger the Convert to JSON operation. Press Ctrl+Enter or Cmd+Enter to Format.

Does the file extension on download reflect what operation I performed? Not directly — the download handler checks whether the output text starts with { or [ to decide between .json and .yaml. YAML formatted output that starts with a mapping will be saved as .yaml, and JSON converted output (which always starts with { or [) will be saved as .json.

Related Tools

JSON Formatter — Format, validate, and minify JSON with schema validation, schema generation, and interactive tree viewer.

XML Formatter — Format and validate XML documents with the same indentation controls and minification support.

TOML Formatter — Format and validate TOML configuration files.

Try YAML Formatter now: YAML Formatter