Does it support both YAML and JSON?

Yes. The input format is detected automatically and output uses the same format. You can also convert between them.

Is the spec sent to a server?

No. All processing is local in your browser. Specs that document internal APIs stay on the device.

Will it validate the OpenAPI document?

Basic structural checks are performed during parsing, but full schema validation is not the goal. Use a validator like Spectral for thorough linting.

What OpenAPI versions are supported?

OpenAPI 3.0 and 3.1 are recognised. Swagger 2.0 specs are not the primary target, though many will still parse.

openapi · swagger · sorted · live

Format OpenAPI specs

Accepts JSON or YAML, sorts top-level keys in canonical order (openapi, info, servers, paths, components...), and pretty-prints as JSON. Runs locally.

OpenAPI / Swagger Formatter

Input

53 B

1 lines

Output

10 B

1 lines

Status

ready

live

Ratio

0.19×

out/in

input · openapi

output · sorted json

Loading...

Quick Start

How to format an OpenAPI spec

Parses JSON first, falls back to YAML, sorts keys (canonical OpenAPI order at the top, alphabetic elsewhere), and serialises as 2-space JSON.

01
Paste the spec
A full openapi.json or openapi.yaml — Swagger 2.0 specs also work.
Parsing runs through Prettier’s standalone bundle (or the language-specific equivalent) loaded lazily — no parser ships until the tool is opened.
openapiPrettierASTstandalonelazy
input · sourceraw · AST
```
{"paths":{},"openapi":"3.0.0"}
```
loaded · parsedAST · ready
02
Wait for parser
js-yaml loads lazily on first paint so you only pay for it when needed.
Indent width, tab style, and print-width re-format through a memoised pass — switching 2 → 4 spaces never re-parses, only re-prints.
lazyindentprint-widthmemoisedlive
parser · optionsready · live
```
json + yaml
```
options applied · livelive
03
Watch keys sort
openapi/info/servers/paths/components/tags rise to the top; everything else is alphabetic.
The formatter is deterministic and idempotent: running it twice produces byte-identical output, which keeps diffs and git noise to a minimum.
liveidempotentdeterministicdiff-cleanstable
out · formattedordered · ready
```
{
  "openapi": "3.0.0",
  "info": ...
}
```
formatted · liveidempotent
04
Copy or download
Save as openapi.json or copy to clipboard. The spec stays in your browser.
Download writes a Blob with the language-appropriate extension; copy uses navigator.clipboard.writeText so the output preserves all whitespace exactly.
exportclipboardbloblanguage MIMEclient-side
ok · copiedready · done
```
OK Copied
```
shipped · ready to shipsuccess

Pro tips

Formatting tips that keep diffs sane

Pick one config and pin it

Inconsistent formatting causes diff churn. Commit .prettierrc / .editorconfig and enforce in CI.

Format on save

Editor integration is faster feedback than a pre-commit hook. Use both for belt-and-braces.

Idempotency matters

Running the formatter twice should produce identical output. Test this on a representative file.

Match the language community

Default to community conventions: 2 spaces for JS/CSS, 4 for Python, tabs for Go. Fights over indent are a productivity tax.

Print-width drives wrapping

80, 100, and 120 are the common targets. Wider lines parse fast but review slower side-by-side.

Don’t mix formatters and linters

Prettier handles whitespace; ESLint handles correctness. Disable overlapping rules to avoid fight-club configs.

Use Cases

When to format OpenAPI

API reviews, codegen prep, schema sharing.

API reviews

Normalise key order before opening a spec PR. Idempotent: running the formatter twice produces byte-identical output, which is the foundation of a clean CI gate. Pair with a pre-commit hook so PRs arrive already formatted, focusing review on logic.

idempotent

Codegen prep

Stabilise output before running openapi-generator. Pairs with EditorConfig + .prettierrc for end-to-end consistency. Whitespace-only changes vanish so reviewers see real diffs, and git blame stays honest about who wrote what.

CI-ready

Diff-friendly

Sorted keys mean smaller, cleaner git diffs. Output respects your indent width, tab style, and print-width — settings carry over for repeat runs. Switching 2-space to 4-space costs nothing in CPU but standardises an entire codebase.

diff-clean

YAML to JSON

Convert YAML specs to JSON for tools that prefer it. Format-on-save is the fastest feedback loop; CI is the safety net. Together they make inconsistent indentation a thing of the past and free up review cycles for genuine concerns.

PR-friendly

Quick read

Get a spec into a readable shape for skimming. Whitespace-only changes don't trigger downstream content-hash invalidations, so CDN cache keys and CI cache layers stay warm. Real changes get all the rebuild budget.

review-ready

Docs publishing

Standardise the spec before feeding a docs site. Pairs with linters (ESLint, Stylelint, pylint) that catch what formatting alone can't — bugs, unused imports, dead code. Each tool stays in its lane, and the codebase stays clean.

deterministic

FAQ

Frequently asked questions

Does it validate the spec?

No. Use Spectral or openapi-validator for OAS rule checks.

Will it preserve $ref order?

Within each object, keys are sorted; $ref values are strings so they are passed through unchanged.

What about path order under paths?

Paths under the top-level paths key are sorted alphabetically.

Does it handle Swagger 2.0?

Yes — the canonical top-level order includes Swagger 2 keys like host, basePath, schemes.

Is anything sent to a server?

No — the formatter runs locally in your browser tab.

Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

47 in queue·8 shipped this month

Request queued. Thanks!