Using Mock Data in Postman : Complete API Testing Guide

Why Use Mock Data in Postman?

Postman is a powerful tool for API development and testing, but its true potential is unlocked when combined with realistic mock data. Whether you're testing POST requests, validating response structures, or creating automated test collections, mock data enables you to test comprehensively without depending on real user data or database state.

Method 1: Using Environment Variables

Store mock data in Postman environment variables for reuse across requests:

Step 1: Create Environment Variables

1. Click Environments in Postman
2. Create New Environment
3. Add variables like:
- testUserId: "550e8400-e29b-41d4-a716-446655440000"
- testEmail: "john.doe@example.com"
- testPhone: "+1-555-123-4567"

// POST /api/users
// Request Body
{
  "email": "{{testEmail}}",
  "name": "{{testName}}",
  "phone": "{{testPhone}}"
}

// Tests tab
pm.test("User created successfully", function () {
    pm.response.to.have.status(201);
    const jsonData = pm.response.json();
    pm.expect(jsonData.email).to.eql(pm.environment.get("testEmail"));
});

Method 2: Using Pre-request Scripts

Generate dynamic mock data using Postman's built-in libraries or external data:

// Pre-request Script
// Generate random user data
pm.environment.set("randomEmail", `user${Math.random().toString(36).substring(7)}@example.com`);
pm.environment.set("randomName", `User ${Math.floor(Math.random() * 1000)}`);
pm.environment.set("randomPhone", `+1-555-${Math.floor(Math.random() * 900) + 100}-${Math.floor(Math.random() * 9000) + 1000}`);

// Use Postman's dynamic variables
pm.environment.set("timestamp", new Date().toISOString());
pm.environment.set("uuid", pm.variables.replaceIn('{{$guid}}'));

Postman Dynamic Variables

Postman provides built-in dynamic variables: $guid,$timestamp,$randomInt,$randomEmail, and more!

Method 3: Importing External Mock Data

For comprehensive testing, generate mock data externally and import it into Postman:

Step-by-Step Process:

Generate mock data using our tool (e.g., 100 user records)
Save as mockUsers.json
In Postman, create a collection variable or global variable
Paste the JSON array as the variable value
Reference in your requests using JSON.parse()

// Pre-request Script
const mockUsers = JSON.parse(pm.collectionVariables.get("mockUsersData"));
const randomUser = mockUsers[Math.floor(Math.random() * mockUsers.length)];

pm.environment.set("testUser", JSON.stringify(randomUser));

// Request Body
{
  "email": "{{testUser.email}}",
  "name": "{{testUser.name}}",
  "phone": "{{testUser.phone}}"
}

Testing Multiple Scenarios with Mock Data

1. Bulk Operations Testing

// Pre-request Script - Generate array of users
const users = [];
for (let i = 0; i < 10; i++) {
  users.push({
    email: `user${i}@example.com`,
    name: `Test User ${i}`,
    role: i % 2 === 0 ? 'admin' : 'user'
  });
}
pm.environment.set("bulkUsers", JSON.stringify(users));

// Request Body for POST /api/users/bulk
{{bulkUsers}}

2. Edge Case Testing

// Pre-request Script - Test with edge cases
const edgeCases = {
  veryLongName: "A".repeat(255),
  specialChars: "Test@User#123!",
  emptyString: "",
  unicodeChars: "用户测试",
  sqlInjection: "'; DROP TABLE users--"
};

pm.environment.set("edgeCase", JSON.stringify(edgeCases));

// Tests - Verify API handles edge cases
pm.test("Handles long names", function() {
    const response = pm.response.json();
    pm.expect(response.error).to.not.be.undefined;
});

Collection Runner with Mock Data

Use Postman's Collection Runner to execute tests with different mock datasets:

Setup Data-Driven Testing:

Generate mock data as CSV or JSON
Open Collection Runner
Select your collection
Upload data file
Tests run once for each data row

// Example CSV structure: users.csv
email,name,expectedStatus
john@test.com,John Doe,201
invalid-email,Test User,400
existing@test.com,Duplicate,409

// Request uses CSV columns
// POST /api/users
{
  "email": "{{email}}",
  "name": "{{name}}"
}

// Test validates expected response
pm.test("Status matches expected", function() {
    pm.response.to.have.status(parseInt(pm.iterationData.get("expectedStatus")));
});

Best Practices

1. Organize Mock Data by Collection

Keep mock data relevant to each API collection. Use collection variables for collection-specific data and global variables for data shared across collections.

2. Version Control Your Collections

Export and commit Postman collections to version control. This ensures team members use the same tests and mock data configurations.

3. Clean Up After Tests

If your tests create data, add cleanup requests to delete test records. Use test teardown scripts to reset the environment.

4. Use Realistic Data

Test with realistic data that matches production patterns. This helps catch validation issues, UI bugs, and edge cases that simple test data might miss.

Generate API Test Data Instantly

Create comprehensive mock datasets for your Postman tests in seconds. No coding required!

Generate Mock Data →

Conclusion

Mock data transforms Postman from a simple API client into a comprehensive testing platform. By leveraging environment variables, pre-request scripts, and external data sources, you can create robust test suites that catch bugs early and ensure API reliability.

Start small with environment variables, then graduate to data-driven testing with Collection Runner as your testing needs grow. Your APIs will thank you!