Postman v2.1 → HTML · Markdown · JSON docs

Postman Collection to Docs Converter

Drop in an exported Postman collection and turn it into browsable API documentation — every folder, endpoint, query param, header, request body and example response — then preview it live and export self-contained HTML, GitHub Markdown or JSON. Parsed entirely in your browser; nothing is uploaded.

01 · Load a collection

E-Commerce API

Complete REST API documentation for our e-commerce platform. This API allows you to manage products, orders, customers, and more.

Version 2.1.0 4 endpoints 3 variables

Live documentation preview

Deep view

The generated reference, side by side

Markdown output

documentation.md

# E-Commerce API

> Complete REST API documentation for our e-commerce platform. This API allows you to manage products, orders, customers, and more.

**Version:** 2.1.0

## Table of Contents

- **Authentication**
  - [`POST` Login](#login)
- **Products**
  - [`GET` List Products](#list-products)
  - [`POST` Create Product](#create-product)
- **Orders**
  - [`GET` Get Order by ID](#get-order-by-id)

---

## 📁 Authentication

Endpoints for user authentication and authorization

### Login {#login}

`POST` **`{{baseUrl}}/auth/login`**

> Authenticate user credentials and receive access token

#### Headers

| Header | Value | Description |
|--------|--------|-------------|
| `Content-Type` | `application/json` | - |

#### Request Body

```json
{
  "email": "user@example.com",
  "password": "password123"
}
```

#### Example Responses

✅ **Successful Login** (200 OK)

```json
{
  "success": true,
  "data": {
    "token": "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...",
    "user": {
      "id": "usr_123456",
      "email": "user@example.com",
      "name": "John Doe"
    }
  }
}
```

---

## 📁 Products

Product management endpoints

### List Products {#list-products}

`GET` **`{{baseUrl}}/api/products?category=electronics&sort=price&limit=20`**

> Get a paginated list of products with optional filters

🔐 **Authentication Required**

#### Query Parameters

| Parameter | Value | Description |
|-----------|--------|-------------|
| `category` | electronics | Filter by category |
| `sort` | price | Sort field (price, name, date) |
| `limit` | 20 | Number of results per page |

#### Headers

| Header | Value | Description |
|--------|--------|-------------|
| `Authorization` | `Bearer {{token}}` | JWT authentication token |

#### Example Responses

✅ **Success** (200 OK)

```json
{
  "success": true,
  "data": {
    "products": [
      {
        "id": "prod_789",
        "name": "Wireless Headphones",
        "price": 99.99,
        "category": "electronics",
        "stock": 150
      }
    ],
    "pagination": {
      "total": 245,
      "page": 1,
      "limit": 20
    }
  }
}
```

---

### Create Product {#create-product}

`POST` **`{{baseUrl}}/api/products`**

🔐 **Authentication Required**

#### Headers

| Header | Value | Description |
|--------|--------|-------------|
| `Authorization` | `Bearer {{token}}` | - |
| `Content-Type` | `application/json` | - |

#### Request Body

```json
{
  "name": "Smart Watch",
  "description": "Advanced fitness tracking smartwatch",
  "price": 299.99,
  "category": "electronics",
  "stock": 50,
  "images": [
    "https://example.com/watch1.jpg"
  ]
}
```

---

## 📁 Orders



### Get Order by ID {#get-order-by-id}

`GET` **`{{baseUrl}}/api/orders/{{orderId}}`**

> Retrieve detailed information about a specific order

#### Headers

| Header | Value | Description |
|--------|--------|-------------|
| `Authorization` | `Bearer {{token}}` | - |

#### Example Responses

✅ **Order Found** (200 OK)

```json
{
  "success": true,
  "data": {
    "id": "ord_456",
    "status": "processing",
    "total": 359.98,
    "items": [
      {
        "productId": "prod_789",
        "quantity": 2,
        "price": 99.99
      }
    ],
    "customer": {
      "name": "Jane Smith",
      "email": "jane@example.com"
    },
    "createdAt": "2024-01-15T10:30:00Z"
  }
}
```

❌ **Order Not Found** (404 Not Found)

```json
{
  "success": false,
  "error": {
    "code": "ORDER_NOT_FOUND",
    "message": "The requested order could not be found"
  }
}
```

---


## Environment Variables

| Variable | Value | Type |
|----------|--------|------|
| `baseUrl` | https://api.example.com | string |
| `token` | your-auth-token-here | string |
| `orderId` | ord_123456 | string |

Parsed collection (JSON)

collection.json

{
  "info": {
    "name": "E-Commerce API",
    "description": "Complete REST API documentation for our e-commerce platform. This API allows you to manage products, orders, customers, and more.",
    "version": "2.1.0"
  },
  "item": [
    {
      "name": "Authentication",
      "description": "Endpoints for user authentication and authorization",
      "item": [
        {
          "name": "Login",
          "request": {
            "method": "POST",
            "url": {
              "raw": "{{baseUrl}}/auth/login",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "auth",
                "login"
              ]
            },
            "header": [
              {
                "key": "Content-Type",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{\n  \"email\": \"user@example.com\",\n  \"password\": \"password123\"\n}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "description": "Authenticate user credentials and receive access token"
          },
          "response": [
            {
              "name": "Successful Login",
              "status": "OK",
              "code": 200,
              "header": [
                {
                  "key": "Content-Type",
                  "value": "application/json"
                }
              ],
              "body": "{\n  \"success\": true,\n  \"data\": {\n    \"token\": \"eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...\",\n    \"user\": {\n      \"id\": \"usr_123456\",\n      \"email\": \"user@example.com\",\n      \"name\": \"John Doe\"\n    }\n  }\n}",
              "_postman_previewlanguage": "json"
            }
          ]
        }
      ]
    },
    {
      "name": "Products",
      "description": "Product management endpoints",
      "item": [
        {
          "name": "List Products",
          "request": {
            "method": "GET",
            "url": {
              "raw": "{{baseUrl}}/api/products?category=electronics&sort=price&limit=20",
              "host": [
                "{{baseUrl}}"
              ],
              "path": [
                "api",
                "products"
              ],
              "query": [
                {
                  "key": "category",
                  "value": "electronics",
                  "description": "Filter by category"
                },
                {
                  "key": "sort",
                  "value": "price",
                  "description": "Sort field (price, name, date)"
                },
                {
                  "key": "limit",
                  "value": "20",
                  "description": "Number of results per page"
                }
              ]
            },
            "header": [
              {
                "key": "Authorization",
                "value": "Bearer {{token}}",
                "description": "JWT authentication token"
              }
            ],
            "auth": {
              "type": "bearer",
              "bearer": [
                {
                  "key": "token",
                  "value": "{{token}}"
                }
              ]
            },
            "description": "Get a paginated list of products with optional filters"
          },
          "response": [
            {
              "name": "Success",
              "status": "OK",
              "code": 200,
              "header": [
                {
                  "key": "Content-Type",
                  "value": "application/json"
                }
              ],
              "body": "{\n  \"success\": true,\n  \"data\": {\n    \"products\": [\n      {\n        \"id\": \"prod_789\",\n        \"name\": \"Wireless Headphones\",\n        \"price\": 99.99,\n        \"category\": \"electronics\",\n        \"stock\": 150\n      }\n    ],\n    \"pagination\": {\n      \"total\": 245,\n      \"page\": 1,\n      \"limit\": 20\n    }\n  }\n}",
              "_postman_previewlanguage": "json"
            }
          ]
        },
        {
          "name": "Create Product",
          "request": {
            "method": "POST",
            "url": "{{baseUrl}}/api/products",
            "header": [
              {
                "key": "Authorization",
                "value": "Bearer {{token}}"
              },
              {
                "key": "Content-Type",
                "value": "application/json"
              }
            ],
            "body": {
              "mode": "raw",
              "raw": "{\n  \"name\": \"Smart Watch\",\n  \"description\": \"Advanced fitness tracking smartwatch\",\n  \"price\": 299.99,\n  \"category\": \"electronics\",\n  \"stock\": 50,\n  \"images\": [\n    \"https://example.com/watch1.jpg\"\n  ]\n}",
              "options": {
                "raw": {
                  "language": "json"
                }
              }
            },
            "auth": {
              "type": "bearer"
            }
          }
        }
      ]
    },
    {
      "name": "Orders",
      "item": [
        {
          "name": "Get Order by ID",
          "request": {
            "method": "GET",
            "url": "{{baseUrl}}/api/orders/{{orderId}}",
            "header": [
              {
                "key": "Authorization",
                "value": "Bearer {{token}}"
              }
            ],
            "description": "Retrieve detailed information about a specific order"
          },
          "response": [
            {
              "name": "Order Found",
              "status": "OK",
              "code": 200,
              "header": [
                {
                  "key": "Content-Type",
                  "value": "application/json"
                }
              ],
              "body": "{\n  \"success\": true,\n  \"data\": {\n    \"id\": \"ord_456\",\n    \"status\": \"processing\",\n    \"total\": 359.98,\n    \"items\": [\n      {\n        \"productId\": \"prod_789\",\n        \"quantity\": 2,\n        \"price\": 99.99\n      }\n    ],\n    \"customer\": {\n      \"name\": \"Jane Smith\",\n      \"email\": \"jane@example.com\"\n    },\n    \"createdAt\": \"2024-01-15T10:30:00Z\"\n  }\n}",
              "_postman_previewlanguage": "json"
            },
            {
              "name": "Order Not Found",
              "status": "Not Found",
              "code": 404,
              "header": [
                {
                  "key": "Content-Type",
                  "value": "application/json"
                }
              ],
              "body": "{\n  \"success\": false,\n  \"error\": {\n    \"code\": \"ORDER_NOT_FOUND\",\n    \"message\": \"The requested order could not be found\"\n  }\n}",
              "_postman_previewlanguage": "json"
            }
          ]
        }
      ]
    }
  ],
  "variable": [
    {
      "key": "baseUrl",
      "value": "https://api.example.com",
      "type": "string"
    },
    {
      "key": "token",
      "value": "your-auth-token-here",
      "type": "string"
    },
    {
      "key": "orderId",
      "value": "ord_123456",
      "type": "string"
    }
  ]
}

Field notes

From a test collection to publishable docs

A Postman collection is one of the richest descriptions of an API a team already owns: it has the real endpoint URLs, the headers that actually work, example bodies and — crucially — the saved example responses captured while testing. Yet that knowledge usually stays locked inside Postman. This converter walks the exported v2.1 JSON the same way Postman renders it — recursing through folders, normalising both the string and structured url forms, skipping disabled headers and query params — and turns it into a reference that anyone can read in a browser without installing anything.

The output is deliberately faithful rather than reinvented. Each request becomes a documented endpoint with a colour-coded method, a query-parameter table, a headers table, the request body rendered in its declared language, and every example response grouped under its status code (2xx, 3xx, 4xx/5xx). When a request carries an auth block, the docs add an explicit “Authentication Required” callout so consumers know credentials are needed before they call it. Nothing is fabricated — if it isn’t in your collection, it isn’t in the docs.

Because the whole pipeline runs in your browser, your collection never leaves the page — which matters when those endpoint URLs and saved tokens belong to an internal or unreleased service. The HTML export is fully self-contained (inline CSS, a built-in light/dark toggle, per-block copy buttons, Prism highlighting), so it drops onto any static host with no build step; the Markdown export is GitHub/GitLab-ready for a docs repo; and the JSON export hands the parsed collection to the next tool in your chain.

This is one stage of a larger documentation pipeline. If you start from raw commands rather than a collection, the cURL to docs converter does the equivalent job from a cURL command; if you maintain a formal contract, the OpenAPI / Swagger generator turns a spec into a browsable reference; and when you need to compose and test a single call, the API request builder assembles it and emits copyable client code.

Postman to Docs FAQs

What does the Postman Collection to Docs Converter do?

You give it an exported Postman collection JSON (the v2.1 format Postman produces from Export → Collection v2.1) and it walks the whole structure — every folder and request, recursively — to produce browsable API documentation. For each endpoint it extracts the HTTP method, the full URL, query parameters, headers, the request body (raw, form-data or url-encoded) and every saved example response with its status code. You can preview the result live, then export it as a self-contained styled HTML site, GitHub-flavoured Markdown, or the raw JSON.

Is my collection uploaded anywhere?

No. The file is read with the browser's FileReader and parsed entirely in JavaScript on your machine — nothing is sent to a server, there is no account and no telemetry. The live preview is rendered in a sandboxed iframe from the generated HTML string, and the download/copy actions use a local Blob and your clipboard. Because it is fully client-side it also works offline once the page has loaded, which makes it safe for internal or unreleased API collections that contain real endpoint URLs.

Which Postman collection format is supported?

The Collection v2.1 schema, which is what Postman exports by default today. Validation is intentionally lenient: as long as the JSON has an info object and an item array it will parse, so lightly hand-edited or programmatically generated collections work too. The URL field is accepted both as a plain string (e.g. "{{baseUrl}}/api/products") and as the structured object form with raw, host, path and query — the generator normalises both.

How are nested folders handled?

Postman lets you group requests into folders, and folders can be nested arbitrarily deep. The converter recurses through that tree: a folder becomes a section heading (with its description if present) and its child requests are rendered beneath it, preserving your original organisation. The table of contents is generated from the same walk, so the docs read in the same order you arranged the collection.

What gets extracted for each endpoint?

For every request the docs show: the method as a colour-coded tag, the full request URL, a query-parameters table (key, value, description — disabled params are skipped), a headers table (also skipping disabled headers), the request body, and example responses. Raw bodies are shown as a syntax-highlighted code block in their declared language; form-data and url-encoded bodies become tables. Each saved example response is rendered with its status code colour-coded by class (2xx success, 3xx redirect, 4xx/5xx error) and its body in a code block.

How is authentication shown in the output?

If a request carries an auth block in the collection, the generated docs add a clear 'Authentication Required' callout on that endpoint so consumers know credentials are needed before calling it. The Markdown export adds the same note as a 🔐 line. The tool does not invent or expose secret values — it simply surfaces the presence of an auth requirement and renders any Authorization header you have saved (typically a {{token}} variable placeholder) in the headers table.

What export formats are available?

Three. HTML produces a standalone document with all CSS embedded, a sticky table of contents, a built-in light/dark theme toggle, copy buttons on every code block and Prism syntax highlighting — it works on any static host with no build step. Markdown produces clean GitHub/GitLab-friendly output with anchored headings and tables, ideal for a README or a docs repo. JSON re-exports the parsed collection for piping into another tool. Every format can be downloaded as a file or copied to the clipboard, and the file is named after the collection.

Can I try it without my own collection?

Yes — a realistic sample E-Commerce API collection is seeded so documentation appears immediately when you open the tool. It includes an Authentication folder, a Products folder with GET and POST endpoints, an Orders folder with success and 404 example responses, and a set of environment variables — so you can see exactly how folders, query params, headers, request bodies, multiple responses and variables all render before loading your own file. Loading your own collection replaces the sample.

Where can I host the generated HTML documentation?

Anywhere that serves a static file, because the HTML export is fully self-contained — all styles are inline and the only external references are the Prism syntax-highlighting CDN scripts. Drop the single .html file onto GitHub Pages, Netlify, Cloudflare Pages, S3, or commit it to a docs folder in your repo. The embedded theme toggle and the per-block copy buttons keep working with no server, build pipeline or framework.

How is this different from generating docs from cURL or an OpenAPI spec?

They start from different sources for different workflows. This tool starts from a Postman collection — the artefact most teams already maintain while testing — and turns it into reference docs without re-describing anything. If you work from raw commands, the curl-to-docs converter does the same job from a cURL command; if you maintain a formal contract, the OpenAPI / Swagger generator turns a spec into a browsable reference; and the API request builder helps you compose individual calls. They are complementary stages of the same documentation pipeline.

Have more questions? Contact us

Trusted by API Teams

4.6

Based on 3,210 reviews

“We already keep an exhaustive Postman collection for QA, so getting publishable docs out of it for free was a no-brainer. Export, drop the JSON in, and the nested folders, query params and saved example responses all come across exactly as organised. The standalone HTML went straight onto GitHub Pages with zero build step.”

Priya Nandakumar

API platform engineer

June 11, 2026

“The Markdown export is the killer feature for us — clean tables, anchored headings, the auth callout on protected endpoints — it drops straight into our docs repo and renders perfectly in GitLab. And because it parses in the browser, I can run it against our internal collection without anything leaving my laptop.”

Marcus Feld

Backend lead

May 19, 2026

“I use the live preview in onboarding sessions: load the sample, show how a request becomes a documented endpoint with its response examples, then have folks load their own collection. The light/dark toggle baked into the generated HTML is a nice touch. I'd love a custom-theme colour option, but the default output already looks professional.”

Sofia Almeida

Developer advocate

April 22, 2026

“Handles the string-form and object-form URLs in our messy older collections without choking, and skips disabled headers and params the way you'd want. Multiple example responses per endpoint with the status codes colour-coded by class is exactly how API consumers want to read it. Saved us writing a converter ourselves.”

Daniel Cho

Solutions architect

March 8, 2026

Love using our calculator?

Connected instruments

Related API tools

Compose & generate code

All API tools

The full suite

Similar Calculators

More tools in the same category

OpenAPI/Swagger Documentation Generator

Generate interactive API documentation from OpenAPI specifications

cURL to Documentation Converter

Transform cURL commands into structured API documentation

Interactive API Playground Generator

Create interactive API testing playgrounds for your documentation

GraphQL Schema Visualizer

Visualize GraphQL schemas with interactive diagrams and documentation

Webhook Documentation Generator

Generate comprehensive webhook documentation with payload examples

CSV Pro - Advanced Data Analysis

Professional CSV processing tool with comparison, analytics, and data transformation capabilities

Often Used Together

Complementary tools for complete analysis

AI Prompt Cost Estimator

Meeting Cost Calculator

Color Contrast Ratio Checker

Package Vulnerability Scanner

Learn More

Dive deeper with our expert guides and tutorials related to Postman Collection to Docs Converter

Loading articles...

endpoints · params · headers · bodies · responses · HTML / Markdown / JSON · in-browser · Last reviewed: 2026-06