Postman OpenAPI Import: Generate Collections from Specs (2026)

Postman can churn out fully functional API collections from your OpenAPI specifications, saving you tons of manual setup.

Let’s see it in action. Imagine you have a simple OpenAPI spec for a basic "Todo" API:

openapi: 3.0.0
info:
  title: Todo API
  version: 1.0.0
servers:
  - url: http://localhost:3000
paths:
  /todos:
    get:
      summary: Get all todos
      responses:
        '200':
          description: A list of todos
          content:
            application/json:
              schema:
                type: array
                items:
                  $ref: '#/components/schemas/Todo'
    post:
      summary: Create a new todo
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/NewTodo'
      responses:
        '201':
          description: Todo created successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Todo'
  /todos/{id}:
    get:
      summary: Get a specific todo by ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '200':
          description: A single todo
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Todo'
    put:
      summary: Update a todo by ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      requestBody:
        required: true
        content:
          application/json:
            schema:
              $ref: '#/components/schemas/NewTodo'
      responses:
        '200':
          description: Todo updated successfully
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Todo'
    delete:
      summary: Delete a todo by ID
      parameters:
        - name: id
          in: path
          required: true
          schema:
            type: string
      responses:
        '204':
          description: Todo deleted successfully
components:
  schemas:
    Todo:
      type: object
      properties:
        id:
          type: string
        task:
          type: string
        completed:
          type: boolean
    NewTodo:
      type: object
      properties:
        task:
          type: string
        completed:
          type: boolean

To import this into Postman, you’d go to File > Import. You can then paste the raw YAML, upload the file, or even provide a URL if your spec is hosted. Postman will parse this and generate a collection.

Here’s what the generated collection might look like in Postman:

• Collection Name: "Todo API" (from info.title)
• Base URL: http://localhost:3000 (from servers[0].url)
• Folders: Postman might group endpoints by path prefix, so you’d likely see a "todos" folder.
• Requests: Each path/method combination becomes a request:
  • GET /todos: A GET request to http://localhost:3000/todos.
  • POST /todos: A POST request to http://localhost:3000/todos. Postman will automatically add a JSON body based on #/components/schemas/NewTodo and set the Content-Type to application/json.
  • GET /todos/{id}: A GET request to http://localhost:3000/todos/:id. Postman converts the {id} path parameter into a variable, prompting you to enter a value.
  • PUT /todos/{id}: Similar to GET, with a JSON body based on NewTodo.
  • DELETE /todos/{id}: A DELETE request to http://localhost:3000/todos/:id.

The magic here is that Postman understands the structure of OpenAPI. It maps paths to requests, servers to the base URL, parameters (like path, query, header) to request components, requestBody to request bodies with appropriate Content-Type and schemas, and responses to example responses or placeholders. It also creates variables for path parameters, making your collection immediately interactive.

The most surprising thing about this import process is how it handles components/schemas and requestBody/responses content. Postman doesn’t just create a request; it attempts to generate a meaningful request body structure and can even populate example response data based on your schema definitions, making the generated collection immediately useful for testing or documentation. It intelligently maps OpenAPI data types (like string, integer, boolean, object, array) to Postman’s request body builders.

When Postman generates requests with path parameters like /todos/{id}, it automatically creates a variable (e.g., :id). You can then go into the "Variables" tab of your collection or the specific request and set a default value. For instance, you could set :id to 1 so that requests using this parameter are ready to go. This is crucial for making your imported collection immediately runnable.

The generated collection isn’t just a static representation; it’s an interactive testing tool. You can send requests, inspect responses, and use Postman’s scripting features to build more complex test scenarios, all derived from your API’s specification.

The next step after importing is to explore how Postman handles more complex OpenAPI features like authentication schemes, which can also be mapped to Postman’s authorization helpers.