Postman User Manual: Complete Guide (2026)

Postman User Manual: Complete Guide (2026)

Postman remains the most widely used API development platform in 2026. Whether you are testing a REST API, designing a GraphQL endpoint, mocking services, or running automated test suites, Postman provides the tools to get it done.

This comprehensive user manual covers everything from sending your first request to advanced automation workflows. It is written for both beginners and experienced developers who want a single reference for all Postman features.

Getting Started

Installation

Download Postman from postman.com/downloads. It is available for macOS, Windows, and Linux. There is also a web version at go.postman.co.

# macOS (via Homebrew)
brew install --cask postman

# Linux (via Snap)
snap install postman

Creating an Account

While you can use Postman's Scratch Pad without an account, signing in unlocks cloud sync, collaboration, and most features. Create a free account at identity.getpostman.com.

Sending Your First Request

Basic GET Request

1. Click the + tab to open a new request
2. Select GET from the method dropdown
3. Enter the URL: https://jsonplaceholder.typicode.com/users
4. Click Send

You will see the response body, status code, time, and size in the response panel.

Common HTTP Methods

Method	Purpose	Example
GET	Retrieve data	GET /api/users
POST	Create a resource	POST /api/users
PUT	Replace a resource	PUT /api/users/1
PATCH	Partially update	PATCH /api/users/1
DELETE	Remove a resource	DELETE /api/users/1
OPTIONS	Check capabilities	OPTIONS /api/users
HEAD	Get headers only	HEAD /api/users

Sending a POST Request with JSON Body

1. Select POST as the method
2. Enter the URL: https://jsonplaceholder.typicode.com/posts
3. Go to the Body tab
4. Select raw and choose JSON from the dropdown
5. Enter the body:

{
  "title": "My Post",
  "body": "This is the content of my post.",
  "userId": 1
}

6. Click Send

Adding Headers

Go to the Headers tab and add key-value pairs:

Key	Value
Content-Type	application/json
Authorization	Bearer your-token-here
Accept	application/json

Query Parameters

You can add query parameters in two ways:

Option A: In the URL

https://api.example.com/users?page=1&limit=20&sort=name

Option B: In the Params tab

Key	Value
page	1
limit	20
sort	name

Both produce the same result. The Params tab is easier to manage for complex queries.

Collections

Collections are folders that organize your API requests. They are the foundation of working efficiently in Postman.

Creating a Collection

1. Click Collections in the left sidebar
2. Click + or New Collection
3. Name it (e.g., "User Management API")
4. Add a description (optional but recommended)

Adding Requests to a Collection

Right-click the collection and select Add Request. You can also drag existing requests into collections.

Organizing with Folders

Create folders within collections to group related requests:

User Management API/
  Authentication/
    POST Login
    POST Register
    POST Refresh Token
    POST Logout
  Users/
    GET List Users
    GET Get User by ID
    POST Create User
    PUT Update User
    DELETE Delete User
  Admin/
    GET System Stats
    POST Bulk Import

Running a Collection

The Collection Runner executes all requests in a collection sequentially:

1. Click Run on the collection
2. Configure iterations, delay, and data files
3. Click Run Collection

This is powerful for integration testing and data seeding.

Environments and Variables

Environments let you switch between different API configurations (dev, staging, production) without changing your requests.

Creating an Environment

1. Click the Environments tab in the sidebar
2. Click + to create a new environment
3. Add variables:

Variable	Initial Value	Current Value
base_url	https://api-dev.example.com	https://api-dev.example.com
api_key	dev-key-123	dev-key-123
user_id	42	42

Create separate environments for each stage:

• Development: https://localhost:3000
• Staging: https://api-staging.example.com
• Production: https://api.example.com

Using Variables in Requests

Reference variables with double curly braces:

URL: {{base_url}}/api/users/{{user_id}}
Header: Authorization: Bearer {{api_key}}

Variable Scopes

Postman variables have a hierarchy (highest to lowest priority):

Scope	Visibility	Use Case
Local	Current request	Temporary overrides
Data	Collection run	Iteration-specific values
Environment	Selected environment	Stage-specific config
Collection	Collection-wide	Shared across requests in collection
Global	All workspaces	Rarely used, avoid for secrets

Dynamic Variables

Postman provides built-in dynamic variables:

{{$randomFirstName}}    → "John"
{{$randomEmail}}        → "john@example.com"
{{$randomUUID}}         → "550e8400-e29b-41d4-a716-446655440000"
{{$timestamp}}          → 1738857600
{{$isoTimestamp}}       → "2026-02-06T12:00:00.000Z"

Authentication

Postman supports multiple authentication methods. Configure them in the Authorization tab.

Bearer Token

Type: Bearer Token
Token: {{access_token}}

API Key

Type: API Key
Key: X-API-Key
Value: {{api_key}}
Add to: Header

OAuth 2.0

1. Select OAuth 2.0 as the type
2. Click Get New Access Token
3. Fill in the OAuth configuration:

Field	Value
Grant Type	Authorization Code
Auth URL	https://auth.example.com/authorize
Access Token URL	https://auth.example.com/token
Client ID	your-client-id
Client Secret	your-client-secret
Scope	read write

4. Click Request Token and authorize in the browser
5. The token is automatically added to your requests

Basic Auth

Type: Basic Auth
Username: {{username}}
Password: {{password}}

Writing Tests

Postman includes a powerful test scripting engine. Write tests in the Scripts > Post-response tab using JavaScript.

Basic Status Code Test

pm.test("Status code is 200", function () {
    pm.response.to.have.status(200);
});

Response Body Tests

pm.test("Response has correct structure", function () {
    const json = pm.response.json();

    pm.expect(json).to.be.an("array");
    pm.expect(json.length).to.be.greaterThan(0);

    // Check first item structure
    pm.expect(json[0]).to.have.property("id");
    pm.expect(json[0]).to.have.property("name");
    pm.expect(json[0]).to.have.property("email");
});

Response Time Test

pm.test("Response time is less than 500ms", function () {
    pm.expect(pm.response.responseTime).to.be.below(500);
});

Header Tests

pm.test("Content-Type is JSON", function () {
    pm.response.to.have.header("Content-Type", "application/json; charset=utf-8");
});

Chaining Requests with Variables

Extract a value from one response and use it in the next request:

// In the Login request's post-response script
pm.test("Save access token", function () {
    const json = pm.response.json();
    pm.collectionVariables.set("access_token", json.token);
    pm.collectionVariables.set("user_id", json.user.id);
});

Now subsequent requests can use {{access_token}} and {{user_id}}.

Common Test Patterns

What to Test	Code
Status code	pm.response.to.have.status(200)
JSON property exists	pm.expect(json).to.have.property("id")
Value equals	pm.expect(json.name).to.eql("John")
Array length	pm.expect(json.items.length).to.eql(10)
Type check	pm.expect(json.id).to.be.a("number")
Response time	pm.expect(pm.response.responseTime).to.be.below(500)
Header exists	pm.response.to.have.header("X-Request-Id")

Pre-Request Scripts

Pre-request scripts run before a request is sent. Use them to set up dynamic values:

// Generate a timestamp
pm.collectionVariables.set("timestamp", Date.now().toString());

// Generate a random email
const email = `user_${Date.now()}@test.com`;
pm.collectionVariables.set("test_email", email);

// Calculate HMAC signature for API authentication
const CryptoJS = require("crypto-js");
const secret = pm.collectionVariables.get("api_secret");
const body = pm.request.body.raw;
const signature = CryptoJS.HmacSHA256(body, secret).toString();
pm.collectionVariables.set("signature", signature);

Mock Servers

Mock servers simulate API responses without a live backend. Useful for frontend development and testing.

Creating a Mock

1. Right-click a collection
2. Select Mock Collection
3. Name the mock and click Create
4. Copy the mock URL (e.g., https://abc123.mock.pstmn.io)

Adding Mock Responses

For each request in the collection, add example responses:

1. Open a request
2. Click Add Example
3. Set the response status, headers, and body
4. Save

The mock server returns the example response when the matching request is made.

Newman: CLI Runner

Newman is Postman's command-line collection runner. Use it for CI/CD integration.

Installation

npm install -g newman

Running a Collection

# From an exported file
newman run my-collection.json -e staging-env.json

# From a Postman URL
newman run https://api.getpostman.com/collections/YOUR_COLLECTION_ID?apikey=YOUR_API_KEY

CI/CD Integration

# GitHub Actions example
name: API Tests
on: [push]
jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: actions/setup-node@v4
      - run: npm install -g newman
      - run: newman run tests/api-collection.json -e tests/staging.json --reporters cli,junit --reporter-junit-export results.xml

Newman Options

Flag	Description
-e	Environment file
-g	Globals file
-n	Number of iterations
--delay-request	Delay between requests (ms)
--timeout	Request timeout (ms)
--reporters	Output format (cli, json, junit, html)
--bail	Stop on first failure

Tips and Tricks

Keyboard Shortcuts

Shortcut	Action
Cmd+Enter	Send request
Cmd+S	Save request
Cmd+N	New request
Cmd+Shift+S	Save As
Cmd+/	Toggle comment in scripts
Cmd+B	Toggle sidebar

Console Debugging

Open the Postman Console (Cmd+Alt+C) to see full request/response details and console.log() output from your scripts.

// Debug in pre-request or test scripts
console.log("Request URL:", pm.request.url.toString());
console.log("Response body:", pm.response.json());

Import/Export

• Import: Supports OpenAPI 3.x, Swagger 2.0, cURL, RAML, GraphQL, and HAR formats
• Export: Collections and environments export as JSON v2.1 format

Conclusion

Postman remains a comprehensive API development platform in 2026. From basic request testing to complex automated workflows with Newman, it covers the full API lifecycle. Mastering collections, environments, test scripts, and the runner will make you significantly more productive.

If you are building or testing APIs that involve AI media generation such as image creation, video synthesis, or text-to-speech, Hypereal AI provides well-documented REST APIs that are easy to test in Postman. Import the Hypereal API collection and start integrating AI media into your applications today.