Skip to content
Postman API Testing Tips

How To Use Postman Collection

API Testing Blog

Using Postman Collections for Effortless API Testing

Postman Collections streamline your API testing workflow by organizing requests, defining variables, and automating test execution. This guide will walk you through the essential aspects of working with Postman Collections, equipping you with the knowledge to enhance your API testing efficiency.

Creating and Editing Collections

  1. Start with a New Collection:

    • Click the “New” button in the left sidebar.
    • Choose “Collection” from the menu.
    • Give your Collection a descriptive name (e.g., “Weather API Tests”).

  2. Add Requests:

    • Click the “Add Request” button within your Collection.
    • Set the request method (GET, POST, PUT, DELETE, etc.).
    • Enter the API endpoint URL.
    • Add any necessary headers or body parameters.

  3. Organizing Requests:

    • You can create folders within your Collection to group related requests. This helps maintain organization as your test suite grows.

Example:

// Sample Postman Collection (weatherapi.postman_collection.json)
{
  "info": {
    "_postman_id": "f49cb108-ba40-44f3-9a00-d0ea8b3427e6",
    "name": "Weather API Tests",
    "schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json"
  },
  "item": [
    {
      "name": "Get Current Weather",
      "request": {
        "method": "GET",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "https://api.openweathermap.org/data/2.5/weather?q=London&appid=YOUR_API_KEY",
          "host": [
            "api",
            "openweathermap",
            "org"
          ],
          "path": [
            "data",
            "2.5",
            "weather"
          ],
          "query": [
            {
              "key": "q",
              "value": "London"
            },
            {
              "key": "appid",
              "value": "YOUR_API_KEY"
            }
          ]
        }
      },
      "response": []
    },
    {
      "name": "Get 5-Day Forecast",
      "request": {
        "method": "GET",
        "header": [
          {
            "key": "Content-Type",
            "value": "application/json"
          }
        ],
        "url": {
          "raw": "https://api.openweathermap.org/data/2.5/forecast?q=London&appid=YOUR_API_KEY",
          "host": [
            "api",
            "openweathermap",
            "org"
          ],
          "path": [
            "data",
            "2.5",
            "forecast"
          ],
          "query": [
            {
              "key": "q",
              "value": "London"
            },
            {
              "key": "appid",
              "value": "YOUR_API_KEY"
            }
          ]
        }
      },
      "response": []
    }
  ]
}

Utilizing Environment Variables

Environment variables let you manage dynamic values (e.g., API keys, base URLs) in a centralized manner.

  1. Define Environment Variables:

    • Go to “Environments” in Postman.
    • Create a new environment, giving it a name (e.g., “Production”).
    • Add variables within the environment:
      • Key: The variable’s name (e.g., API_KEY).
      • Value: The actual value (e.g., your API key).

  2. Using Variables:

    • In your request URL or body, use the syntax {{variable_name}} to reference the environment variable.

Example:

  • In the previous weather API example, replace "YOUR_API_KEY" in both requests with {{API_KEY}}. Then, store your actual API key as the value of the API_KEY variable in your “Production” environment.

Running and Managing Tests

Postman allows you to add assertions and tests within your requests to validate API responses.

  1. Adding Tests:

    • Go to the Tests tab within a request.
    • Use the built-in test functions (e.g., pm.test()), or write custom JavaScript code to perform checks.
    • Common tests include:
      • Status Code Assertions: pm.test("Status code is 200", () => { pm.response.to.have.status(200); });
      • Response Body Validation: pm.test("Response has message property", () => { pm.expect(pm.response.json()).to.have.property('message'); });

  2. Running Tests:

    • Select the “Collection Runner” from the Postman interface.
    • Choose the Collection you’d like to run.
    • Select your environment (e.g., “Production”).
    • Optionally set iterations and delay between requests.
    • Click “Run” to execute your tests.

Example:

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


  pm.test("Response has 'weather' property", () => {
    pm.expect(pm.response.json()).to.have.property('weather');
  });

Creating a Shared Collection

Sharing Postman Collections enables collaboration within your development team and empowers them to reuse your test suite.

  1. Exporting the Collection:

    • Click the “Share” button on your Collection.
    • Select “Export” and choose the desired format (e.g., JSON).
    • Save the exported file to your chosen location (e.g., GitHub repository).

  2. Importing the Collection:

    • Open Postman and click “Import.”
    • Select the exported Collection file.
    • The imported Collection will be added to your Postman workspace.

Working with Postman Collections: Best Practices

  • Descriptive Naming: Use clear and informative names for your Collections, requests, and folders.
  • Modular Structure: Break down complex workflows into smaller, well-organized collections.
  • Document Your Tests: Add comments in your collection to describe each request, test, and variable.
  • Version Control: Integrate your collections with a version control system (like Git) to track changes and collaborate effectively.

By adhering to these best practices and leveraging the power of Postman Collections, you can elevate your API testing efficiency, ensure high-quality API functionality, and streamline your development process.

API Testing Blog