Prettify YAML

Quickly prettify a YAML configuration file with consistent indentation and readable structure.

The prettifier takes supported YAML configuration and rebuilds it into a stable two-space block layout. This is useful when a file has drifted into inconsistent indentation, compact flow syntax, or hard-to-read nested structures. In every case the main workflow is deliberately visible: enter or load data, run the primary action, inspect the result or validation message, and then copy or download the output when the tool provides an export. The editor is a normal accessible textarea with a connected label, keyboard-focusable controls, visible error and success states, and a responsive two-column layout that stacks on smaller screens. There is no requirement to create an account, select a server-side processing job, or wait for an upload queue.

The parser is intentionally focused on the YAML forms most often used for application and infrastructure configuration. It handles nested mappings, sequences, scalar values, quoted strings, numbers, booleans, nulls, inline arrays, inline mappings, comments, document markers, and simple literal or folded text blocks. Input is normalized only as part of parsing; a conversion or formatting operation then creates a new representation from the resulting data structure. This distinction matters because YAML is not just indentation around arbitrary text: the same characters can represent different data types depending on quoting and context.

For prettify yaml, the input is treated as untrusted text. The browser code escapes error content before placing it in the page, does not evaluate pasted text, and does not construct executable code from the input. The generated template also avoids third-party runtime dependencies, external APIs, and CDN libraries. As a result, the core operation can run without a network request once the page itself has loaded. The local-only design is useful when configuration contains internal hostnames, credentials placeholders, deployment settings, feature flags, or other material that should not be copied into a public conversion service.

Output behavior is intentionally conservative. Formatting does not promise to preserve comments as comments because comments are discarded when the input becomes a plain data structure. Conversion tools similarly do not invent application schema information. A syntactically valid configuration can still fail a product-specific validation rule, and this interface does not pretend to know those rules. The validator therefore reports parser validity, while the transformation tools report whether the input could be parsed into the supported data model. When something outside that model is encountered, the tool shows an error rather than silently guessing a replacement.

Several edge cases are handled explicitly. Empty input is rejected instead of being treated as a successful document. Indentation with tab characters is rejected because the parser expects spaces for structural indentation. Missing mapping colons, empty mapping keys, unsupported indentation changes, malformed inline collections, and invalid JSON for the JSON-to-YAML tool produce a visible error and leave the previous source text intact. Clear removes both the input and generated state. Load Sample restores a known-good configuration so the primary workflow can be tested immediately after the page loads.

The statistics shown after successful processing are a practical sanity check rather than a schema report. They summarize keys, arrays, objects, scalar values, nesting depth, or output character count depending on the tool. These counts help confirm that the parser saw roughly the structure you expected before you copy the result elsewhere. The export action uses a browser Blob and a temporary download URL, so the generated file is created on the device. Clipboard copying uses the browser Clipboard API when available and falls back to a hidden textarea copy path for environments where the modern API is unavailable.

Performance is kept proportional to the size of the text being entered. The implementation does not make a remote request for each validation or conversion, and it does not add a package dependency that has to be fetched at runtime. The practical ceiling is therefore the browser’s available memory and the size of the editor content. For normal configuration files this keeps the interaction immediate. For extremely large generated manifests, users should still treat the browser as a convenience tool rather than assume unlimited file size or command-line scale.

Use Prettify YAML when you need a controlled, repeatable browser workflow for common YAML configuration tasks. It is especially useful for small edits, documentation examples, deployment snippets, API configuration, CI files, local development settings, and quick checks before committing a file. The tool deliberately favors predictable behavior over broad claims of complete YAML language coverage, making its success and failure states easier to understand and safer to act on.

Before relying on a converted or formatted configuration in production, compare the generated output with the original source and validate it with the target application or platform. A serializer can preserve the parsed data model without knowing whether a particular key, value range, environment variable, or deployment option is valid for your application. This tool gives you a reliable syntax-and-transformation step; your target system remains the final authority on configuration semantics.

• Consistent indentation: Rebuilds parsed mappings and sequences with two-space indentation for a predictable layout.
• Nested structures: Keeps objects and arrays nested instead of flattening configuration into a single line.
• Scalar preservation: Retains strings, numbers, booleans, and null values as their parsed data types.
• Inline cleanup: Expands common inline arrays and objects into a readable block structure.
• Comments for input validation: Checks the configuration before formatting so malformed content is not silently rewritten.
• Sample configuration: Loads a realistic service configuration with arrays, nested objects, and comments.
• Live statistics: Shows key, array, object, and output character counts after formatting.
• Copy output: Copies the formatted YAML with a visible confirmation state.
• Download result: Saves the formatted result locally as a YAML file.
• Browser-only processing: Keeps the conversion logic in the page instead of requiring an upload service.

1. Paste your compact or unevenly indented YAML into the editor.
2. Click Load Sample to see a representative configuration and confirm the interface is responding.
3. Click Process YAML to parse the input and rebuild its structure.
4. Review the result for hierarchy, list indentation, and scalar values.
5. Check the statistics below the output to compare structure size and output length.
6. Use Copy to move the formatted document into your editor or terminal.
7. Use Download to save the result as a local .yaml file.

Example 1 - Compact service settings. A single-line mapping becomes easier to inspect.

Before: server: {host: localhost, port: 8080, tls: true}
After:
server:
  host: localhost
  port: 8080
  tls: true

Example 2 - Deployment list. A list under a mapping is rewritten with stable sequence indentation.

replicas:
- api
- worker

Example 3 - Feature flags. Nested feature values remain grouped under their parent key.

features:
  login: true
  export: false

Example 4 - Quoted values. Strings that look like booleans or numbers keep their string meaning.

version: "2026"
active: "false"

Example 5 - Database configuration. Mixed objects and arrays become a normal block-style YAML document.

database:
  host: db.internal
  ports:
    - 5432
    - 5433

• Readable reviews: A normalized structure makes pull requests and configuration audits easier to scan.
• Safer edits: Consistent indentation reduces accidental nesting mistakes when editing YAML by hand.
• No installation: You can format a configuration without installing a YAML package or command-line tool.
• Fast feedback: The result appears immediately after parsing in the browser.
• Local workflow: Configuration text remains on the device rather than going to a hosted conversion endpoint.
• Repeatable output: The serializer gives the same two-space style for the same parsed data.
• Useful for snippets: Small configuration fragments can be cleaned without setting up a project.