Skip to content
Postman API Testing Tips

How To Hit Multiple Requests On A Url Using Postman

API Testing Blog

Executing Multiple API Requests Using Postman: A Comprehensive Guide

In the world of API testing, it’s often necessary to execute multiple requests in a specific sequence to simulate real-world user interactions or to test complex workflows. This is where Postman’s power shines, allowing you to orchestrate a series of API calls with ease. This guide will walk you through various methods for hitting multiple requests on a URL using Postman, equipping you with the tools to streamline your API testing process.

1. Utilizing Collections for Sequential Requests

Postman Collections provide a structured way to group and organize related API requests. This makes it incredibly easy to execute a series of requests in a predefined order, mimicking user journeys.

Step 1: Create a Collection:

  • Open Postman and click on the “Collections” tab.
  • Click “Create Collection” and give it a relevant name (e.g., “User Authentication and Profile Update”).

Step 2: Add Requests:

  • Within the newly created Collection, click “Add Request” to create a request for each step in your workflow.
  • Give each request a descriptive name (e.g., “Login”, “Get User Profile”, “Update Profile”).
  • Configure the request method (GET, POST, PUT, etc.), URL, headers, and body parameters as needed.

Step 3: Define Request Order:

  • You can directly change the order of requests within the collection by dragging and dropping them into the desired sequence.

Step 4: Run the Collection:

  • Click on the “Run” button next to the Collection name.
  • Postman will execute the requests in the order defined within the Collection.

Sample Code: Consider a scenario where you need to login, fetch user data, and update a user’s profile. You could define these actions in a Collection as follows:

Login Request:

POST {{baseUrl}}/login
Authorization: Basic {{authToken}}
Content-Type: application/json


{
    "username": "{{username}}",
    "password": "{{password}}"
}

Get User Profile Request:

GET {{baseUrl}}/users/{{userId}}
Authorization: Bearer {{accessToken}}

Update Profile Request:

PUT {{baseUrl}}/users/{{userId}}
Authorization: Bearer {{accessToken}}
Content-Type: application/json


{
    "firstName": "{{newFirstName}}",
    "lastName": "{{newLastName}}"
}

2. Leveraging Postman’s Runner for Automated Testing

Postman’s Runner feature allows you to execute collections repetitively, making it ideal for automated API testing. It enables you to define data-driven tests, iterate through multiple data sets, and track the results of your test runs.

Step 1: Create a Runner Environment:

  • Go to the “Environments” tab and click “Create Environment”.
  • Define variables that will be used in your Collection requests, such as base URLs, usernames, passwords, etc.
  • Use the “Current Value” field to specify the initial values for these variables.

Step 2: Run the Collection in the Runner:

  • Navigate to the Collection you’ve created and click “Run” to open the Runner.
  • Select the environment you have created.
  • Specify the number of iterations if you need to run the collection multiple times.
  • You can also choose to run the request in a sequential or parallel manner.

Step 3: Analyze Results:

  • The Runner provides a comprehensive report with details about each request, including response codes, response times, and any errors.
  • This report helps you identify issues and debug your tests efficiently.

Sample Code: Let’s assume you want to automate user registration and login using the Runner. You could set up the environment with variables like username, password, and email, then loop through a list of test data within the Runner to register and login multiple users.

3. Using Postman’s Test Scripting for Dynamic Request Execution

While collections and the Runner are useful for orchestrating requests, Postman’s scripting capability unlocks advanced scenarios. You can write JavaScript code within the “Tests” tab of each request to dynamically control the flow of your API calls.

Step 1: Add a Test Script:

  • Access the “Tests” tab in any request within your Collection.
  • Start writing JavaScript code to define the logic for your requests.

Step 2: Trigger Subsequent Requests:

  • Use the pm.sendRequest function to execute a new request within the test script based on the results of the previous request.
  • For example, you could use a if statement to send a request only if the initial request is successful.

Step 3: Handle Response Data:

  • The pm.response.json() method allows you to retrieve and process response data from the previous request.
  • This data can then be used in subsequent requests to pass dynamic values.

Sample Code: Imagine you need to retrieve user data based on a successful login:

pm.test('Login successful', function () {
    pm.response.to.have.status(200);
});


if (pm.response.json().success) {
    var userId = pm.response.json().userId;


    pm.sendRequest({
        method: 'GET',
        url: '{{baseUrl}}/users/' + userId
    }, function (err, response) {
        // Handle the response from the user data request
    });
}

4. Combining Collections, Runner, and Scripting for Ultimate Control

To achieve truly intricate and automated API testing, combining the three techniques described above is often the most effective approach.

Step 1: Define Your Workflow in a Collection:

  • Create a Collection that outlines the sequence of requests in your API workflow.

Step 2: Automate with the Runner:

  • Use the Runner to execute the collection repeatedly and leverage environments to manage variables like authentication tokens or test data.

Step 3: Add Dynamic Logic with Scripting:

  • Within the “Tests” tab, use JavaScript to control the flow, modify requests based on response data, and handle conditional scenarios.

This powerful combination allows you to build complex API tests that mimic real-world usage scenarios and provide in-depth insight into your application’s behavior.

Conclusion

Postman’s comprehensive capabilities enable you to seamlessly execute multiple API requests and meticulously test your API workflows. By leveraging Collections, the Runner, and scripting, you can implement various strategies for hitting multiple requests on a URL, making your testing process more effective, automated, and data-driven. This guide provides a foundation for exploring the full potential of Postman for API testing, empowering you to confidently assess and improve your API’s reliability and performance.

API Testing Blog