OpenAPI Viewer, Linter & Docs Generator

OpenAPI file

Open .yaml or .json

OpenAPI 3.x or Swagger 2.0 (YAML or JSON)

openapi: 3.1.0
info:
  title: Bookshop API
  version: 1.4.0
  description: Orders and stock for a small online bookshop.
servers:
  - url: https://api.example.co.uk/v1
security:
  - bearer: []
tags:
  - name: Books
  - name: Orders
paths:
  /books:
    get:
      tags: [Books]
      summary: List books
      operationId: listBooks
      parameters:
        - name: q
          in: query
          description: Search the title and author
          schema: { type: string }
        - $ref: '#/components/parameters/Limit'
      responses:
        '200':
          description: A page of books
          content:
            application/json:
              schema:
                type: array
                items: { $ref: '#/components/schemas/Book' }
  /books/{isbn}:
    get:
      tags: [Books]
      summary: Get one book
      operationId: getBook
      parameters:
        - name: isbn
          in: path
          required: true
          schema: { type: string, example: '9780141439518' }
      responses:
        '200':
          description: The book
          content:
            application/json:
              schema: { $ref: '#/components/schemas/Book' }
        '404':
          description: No book with that ISBN
  /orders:
    post:
      tags: [Orders]
      summary: Place an order
      operationId: createOrder
      requestBody:
        required: true
        content:
          application/json:
            schema: { $ref: '#/components/schemas/NewOrder' }
      responses:
        '201':
          description: Order placed
          content:
            application/json:
              schema: { $ref: '#/components/schemas/Order' }
        '422':
          description: Out of stock
  /orders/{id}/cancel:
    post:
      tags: [Orders]
      operationId: getBook
      responses:
        '204':
          description: Cancelled
components:
  securitySchemes:
    bearer: { type: http, scheme: bearer }
  parameters:
    Limit:
      name: limit
      in: query
      schema: { type: integer, minimum: 1, maximum: 100, default: 20 }
  schemas:
    Book:
      type: object
      required: [isbn, title, price]
      properties:
        isbn: { type: string, example: '9780141439518' }
        title: { type: string, example: Pride and Prejudice }
        author: { type: string, example: Jane Austen }
        price: { type: number, example: 8.99 }
        inStock: { type: integer, minimum: 0 }
    NewOrder:
      type: object
      properties:
        items:
          type: array
          items:
            type: object
            properties:
              isbn: { type: string }
              qty: { type: integer, minimum: 1 }
        email: { type: string, format: email }
    Order:
      allOf:
        - $ref: '#/components/schemas/NewOrder'
        - type: object
          properties:
            id: { type: string, format: uuid }
            status: { type: string, enum: [placed, packed, shipped] }
            placedAt: { type: string, format: date-time }
    Legacy:
      type: object

Endpoints

Endpoint detail

Spec checks

Markdown reference

API reference in Markdown

What it does

Reads OpenAPI 3.x or Swagger 2.0, lists every endpoint with examples built from the schemas, lints the spec and writes Markdown docs.

OpenAPI 3.0, 3.1 and Swagger 2.0, YAML or JSON
Every path and method with parameters and responses
Example request and response bodies from the schemas
Lint: missing operationIds, broken $refs, undocumented errors

Private by design

Everything happens in your browser. Nothing you type, paste or upload is sent anywhere, and it keeps working offline once the page has loaded.

What you get

Markdown API reference and a lint report, with a Copy and a Download button on every result.

OpenAPI
Swagger
REST
Docs

Why it matters

An OpenAPI file describes an API completely, but a 3,000-line YAML file isn't something you read. Most viewers need a server or send your spec to a third party, which isn't great for an internal API.

This viewer reads the spec in your browser, lays out each endpoint with its parameters, bodies and responses, and builds example payloads from the schemas. The linter catches the problems that make generated clients and docs worse: missing operationIds, unresolved $refs, missing error responses and undocumented security.

How it works

InputOpenAPI 3.x or Swagger 2.0, YAML or JSON
In your browser$refs resolved, operations checked
OutputA browsable reference, example bodies and Markdown

Where it fits in a designer's workflow

Plan
Design
Build
Test
Launch

Reading or reviewing an API.

By the numbers

Counted by this tool's own loader and checks on its sample OpenAPI 3.1 file: operations by method, $refs resolved, and issues such as a missing operationId or a response without a schema. Source: OpenAPI 3.1.0.

Show the numbers as a table

Item	Count
GET	2
POST	2
Issues found	4

How to use it

Paste an OpenAPI or Swagger file, or open one.
Browse the endpoints and pick one to see its detail.
Fix the problems the linter lists.
Download the Markdown reference.

FAQ

Which versions are supported?

OpenAPI 3.0 and 3.1, and Swagger 2.0, in YAML or JSON.

Does it follow external $refs?

No. References to other files or URLs are listed but not fetched; references within the file are resolved.

Can I try requests from here?

No. It's a viewer and linter; nothing is sent to the API. Use the cURL converter to build calls.

Is my spec uploaded?

No. It's parsed in your browser.

Work with me

Want a site that gets these right?

I build fast, accessible websites and web apps that pass these checks from day one. Tell me about your project and I'll reply personally with honest next steps.

Start a project What I do

All developer tools · Back to leej.uk