OpenAPI / Swagger Viewer

Paste an OpenAPI 3 or Swagger 2 spec in YAML or JSON and browse its endpoints, schemas and example requests.

Open file

openapi: 3.1.0
info:
  title: Bookshelf API
  version: 1.2.0
  description: Manage a personal library of books and reading lists.
servers:
  - url: https://api.example.com/v1
tags:
  - name: books
    description: Books in the library
  - name: lists
    description: Reading lists
security:
  - bearerAuth: []
paths:
  /books:
    get:
      tags: [books]
      summary: List books
      operationId: listBooks
      parameters:
        - name: q
          in: query
          description: Search titles and authors
          schema: { type: string }
        - name: limit
          in: query
          schema: { type: integer, minimum: 1, maximum: 100, default: 20 }
      responses:
        '200':
          description: A page of books
          content:
            application/json:
              schema:
                type: object
                properties:
                  items:
                    type: array
                    items: { $ref: '#/components/schemas/Book' }
                  next: { type: string, nullable: true }
    post:
      tags: [books]
      summary: Add a book
      operationId: createBook
      requestBody:
        required: true
        content:
          application/json:
            schema: { $ref: '#/components/schemas/NewBook' }
      responses:
        '201':
          description: Created
          content:
            application/json:
              schema: { $ref: '#/components/schemas/Book' }
        '422': { $ref: '#/components/responses/ValidationError' }
  /books/{bookId}:
    parameters:
      - name: bookId
        in: path
        required: true
        schema: { type: string, format: uuid }
    get:
      tags: [books]
      summary: Get a book
      operationId: getBook
      responses:
        '200':
          description: The book
          content:
            application/json:
              schema: { $ref: '#/components/schemas/Book' }
        '404': { description: Not found }
    delete:
      tags: [books]
      summary: Remove a book
      operationId: deleteBook
      responses:
        '204': { description: Deleted }
  /lists/{listId}/books:
    post:
      tags: [lists]
      summary: Add a book to a reading list
      operationId: addToList
      parameters:
        - name: listId
          in: path
          required: true
          schema: { type: integer }
      requestBody:
        content:
          application/json:
            schema:
              type: object
              required: [bookId]
              properties:
                bookId: { type: string, format: uuid }
                position: { type: integer, description: Where to insert; appended when omitted }
      responses:
        '200': { description: Updated list }
components:
  securitySchemes:
    bearerAuth: { type: http, scheme: bearer }
  responses:
    ValidationError:
      description: The request body is invalid
      content:
        application/json:
          schema:
            type: object
            properties:
              errors:
                type: array
                items: { type: string }
  schemas:
    NewBook:
      type: object
      required: [title, author]
      properties:
        title: { type: string, example: The Pragmatic Programmer }
        author: { type: string, example: Andy Hunt }
        isbn: { type: string, example: '9780135957059' }
        status:
          type: string
          enum: [want, reading, finished]
    Book:
      allOf:
        - $ref: '#/components/schemas/NewBook'
        - type: object
          properties:
            id: { type: string, format: uuid, readOnly: true }
            addedAt: { type: string, format: date-time, readOnly: true }

Bookshelf API 1.2.0

OpenAPI 3.1.0 · 5 operations · 2 schemas

Manage a personal library of books and reading lists.

https://api.example.com/v1

books — Books in the library

lists — Reading lists

Schemas (2)

NewBook object

title*string
author*string
isbnstring
statusstringone of want, reading, finished

Book object

title*string
author*string
isbnstring
statusstringone of want, reading, finished
idstring (uuid)read-only
addedAtstring (date-time)read-only

Guide

About the OpenAPI / Swagger Viewer

OpenAPI (formerly Swagger) is the standard way to describe a REST API in a YAML or JSON file: every endpoint, its parameters, the shape of requests and responses, and how to authenticate. The file is precise but long, and following its $ref links by hand is slow. This viewer turns it into browsable documentation as you type.

Edit the spec on the left and the endpoint list updates live, so it doubles as a quick way to check a spec you are writing. Everything is processed in your browser.

OpenAPI 3 vs Swagger 2

Swagger 2.0 keeps schemas under definitions, describes the request body as a parameter with in: body, and sets the host and base path at the top. OpenAPI 3 moves schemas to components/schemas, adds a separate requestBody with one schema per content type, and lists one or more servers. The viewer reads both.

How to use it

1Paste a spec, open a .yaml or .json file, or load the example.
2Filter the endpoint list or browse it by tag.
3Open an endpoint to see its parameters, body and responses.
4Switch a schema to Example, or copy the curl command to try the call.

Frequently asked questions

Can I view a spec from a URL?

Open the URL in your browser, copy the YAML or JSON, and paste it here. The viewer does not fetch URLs, so private specs are never sent anywhere.

Are external $refs supported?

References inside the same document (#/components/...) are resolved. References to other files or URLs are shown but not followed.

How are example payloads made?

From the example, default or enum values in the spec where present, otherwise from each property’s type and format — a date-time gets a timestamp, a uuid gets a UUID.

Is this a full validator?

No. It reports common mistakes such as undeclared path parameters and duplicate operationIds, but it does not check every rule of the specification.