Skip to content
Postman API Testing Tips

How To Create Multiple Records Using Postman

API Testing Blog

Creating Multiple Records in Postman: A Comprehensive Guide

Postman is a powerful tool for API testing, including creating and managing data for your applications. While Postman is primarily used to send requests to APIs, it also offers features to streamline the process of creating multiple records. This guide explores various methods for creating multiple records using Postman, providing practical examples and step-by-step instructions.

Using Postman Collections: Efficiently Creating Records

Postman Collections provide a way to group related API requests, making it easier to manage complex workflows. They are particularly useful when creating multiple records, as you can define a single request template and iterate through different data values.

1. Define a Collection with a Base Request

  • Create a new collection in Postman.
  • Add a new request to the collection, representing the basic structure of the record you want to create.
  • In the request body, use variables or placeholders to represent the data points that will vary for each record.

Example: Creating Users

Let’s assume you need to create multiple users with unique names and email addresses. Your base request might look like this:

POST {{url}}/users


{
  "name": "{{name}}",
  "email": "{{email}}"
}

2. Create a Data File

  • Create a CSV file (.csv) containing the different data values for each record.
  • Each row represents a single record, with columns corresponding to the variables in your request body.

Example:

name,email
John Doe,john.doe@example.com
Jane Doe,jane.doe@example.com
Peter Pan,peter.pan@example.com

3. Utilize Data Files in Postman

  • In the Postman request, access the data from the CSV file.
  • Use {{csv[row][column]}} to access the corresponding data in each row. The row and column indexes start from 0.

Example (using CSV Data):

POST {{url}}/users


{
  "name": "{{csv[row][0]}}",
  "email": "{{csv[row][1]}}"
}

4. Run the Collection with Iteration

  • Select the collection from the Postman interface.
  • Choose the “Runner” tab and select your Data file.
  • Set the “Iteration count” to the number of records you want to create.
  • Click “Run”.

Postman will execute the request for each row in the CSV file, iterating through the data and creating the specified records.

Utilizing Postman’s “Collection Runner” with External Data

Postman gives you the flexibility to import data from external sources, allowing for more complex data structures.

1. Prepare External Data

  • Store your data in a format recognized by Postman: JSON, CSV, or an Excel spreadsheet.
  • Ensure the data structure aligns with the request body variables.

2. Import External Data into Postman

  • Go to the “Runner” tab in your Postman collection.
  • Select “External data” and choose the data file type.
  • Upload your file and connect the appropriate variable names in your request with the corresponding columns in the data file.

Example:

  • {{data.name}} for a data column named “name” in your JSON file.

3. Customize Iterations

  • Set the “Iteration count” based on the number of records in your external data source.

4. Run the Collection for Record Creation

  • Click “Run” to execute the collection using the external data.
  • Postman will iterate through the data, sending requests for each record according to your defined request body structure.

Using Postman’s “Newman” for Scripting and Automation

Postman’s command-line interface tool, Newman, allows for more advanced scripting and automation.

1. Create a Newman Script

  • Write a Newman script that defines your request and data.
  • Utilize Newman’s features to iterate through your data and send requests.

Example:

// Newman script for creating users
const newman = require('newman');


const collection = 'users-collection.json';
const dataFile = 'data.json';


newman.run({
  collection: collection,
  environment: 'default', //  Set any environment variables if needed
  iterationData: dataFile,
}, function (err, summary) {
  if (err) {
    console.error('Error running collection: ' + err);
  } else {
    console.log('Collection run successful. Summary:');
    console.log(summary);
  }
});

2. Run the Script

  • Execute the script in your command line using newman run <your-script-file.js>.
  • Newman will iterate through your data and create the specified records.

Creating Multiple Records with Dynamic Values

Postman also provides functionality for generating dynamic data during script execution. This is useful for scenarios where you need to create records with non-static values.

1. Utilize Postman’s pm Object

  • In your Postman request, use the pm.environment.get() method to retrieve existing environment variables.
  • Use pm.environment.set() to set new environment variables.
  • Combine these methods with JavaScript functions to create dynamic values.

Example:

POST {{url}}/users


{
  "name": "User_" + pm.environment.get("counter"),
  "email": "user_" + pm.environment.get("counter") + "@example.com",
}


// Create a variable to keep track of the record count
pm.environment.set("counter", 0);


// Increment the counter for each record
pm.environment.set("counter", pm.environment.get("counter") + 1);

2. Implement Dynamic Data Generation

  • Use JavaScript’s Math.random() function or other methods to create unique values.

Example:

POST {{url}}/products


{
  "name": "Product_" + Math.random().toString(36).substring(7),
  "description": "A new product",
  "price": Math.floor(Math.random() * 100) + 1, // Generates a random price between 1 and 100
}

Addressing Potential Issues

  • Data Consistency: Ensure your data is structured correctly and that the column names in your CSV or external data match the variables in your request.
  • Validation: Implement assertions in your Postman requests to verify successful record creation and handle any errors.
  • API Limitations: Be aware of any rate limits or constraints on the API you are interacting with.
  • Timeouts: Use timeouts to prevent long-running requests from hindering your testing process.
  • Error Handling: Implement error handling in your Newman scripts or collection runs to gracefully deal with unexpected issues.

By leveraging the techniques outlined above, you can effectively create multiple records using Postman, streamlinimg workflows and enhancing the efficiency of your API testing processes.

API Testing Blog