Generate clean API documentation from OpenAPI specs with endpoint details, schemas, and examples.
Paste or upload an OpenAPI (formerly Swagger) spec in JSON or YAML and this tool renders it as readable reference documentation: one section per operation, with the HTTP method, path, parameters, request body, and response schemas expanded inline, plus examples wherever the spec defines them. It is a renderer, not a test runner. Nothing is sent to your API, so the output can only be as current and complete as the spec file. Users are most often surprised that the only way to improve the docs is to enrich the spec: descriptions and examples you write there are exactly what appears on the page.
A concrete input and expected output from the current implementation.
Input
openapi: 3.0.0
info:
title: Todo API
version: 1.0.0
paths:
/todos:
get:
summary: List all todos
responses:
'200':
description: OK
content:
application/json:
schema:
type: array
items:
$ref: '#/components/schemas/Todo'
components:
schemas:
Todo:
type: object
required: [id, title]
properties:
id:
type: integer
format: int64
title:
type: string
done:
type: boolean Expected output
Todo API - v1.0.0
GET /todos - List all todos
200 OK - application/json
Schema: array of Todo
Todo (object)
id integer (int64) required
title string required
done boolean optional The generator resolves the $ref to the Todo schema in components and renders the 200 response as an array of Todo objects, expanding id, title, and done as declared and marking exactly the fields the spec's required list names.
The tool accepts the OpenAPI document as JSON or YAML and builds the reference from the spec's own structure: the info block becomes the page header, each path item becomes a section per HTTP method, and parameters, request bodies, and responses are listed as declared. Ordering follows the file's own path order, so the page mirrors the document rather than any inferred logic.
OpenAPI specs avoid repeating types: schemas live once under components/schemas and operations point at them with $ref. The generator resolves those pointers, so a response such as an array of items expands to the full referenced schema inline, with required fields, enums, and formats such as int64 preserved exactly as declared in the file.
No. These tools run entirely in the browser: the spec is parsed locally, and nothing is sent to your API or anywhere else. The generator renders the file as written, so it cannot catch drift between the spec and the running service. Re-paste or re-export the spec after the API changes.
Probably not. Examples appear only where the spec defines them, in the example or examples fields on schemas, parameters, and responses. Add those fields to the spec and regenerate; the tool cannot invent request or response samples that were never declared.
The example and behavioral notes were checked against the browser implementation. Standards and primary references below define the relevant format, formula, or platform behavior.
Format, validate, and beautify JSON with syntax highlighting and error detection.
Encode text or files to Base64 and decode Base64 strings back to their original form.
Format and indent SQL queries for better readability across all major dialects.
Convert HTML markup into clean Markdown syntax with support for tables and lists.
Write Markdown and see the rendered HTML output in real time with live preview.
Visualize unified diffs and patch files with color-coded additions and deletions.