Request Chain

Build and execute sequences of dependent API requests without writing code. Extract variables from responses, automatically map dependencies, preview resolved requests, and visualize complete API workflows with Request Chain.

Request Chain is useful when one API depends on data returned by another API. You can extract values from an API response and automatically use those values in subsequent requests, including URLs, request bodies, headers, and authentication. With features such as Request Chaining, Variable Extraction, Chain Analyzer, Auto Mapping, Chain Viewer, and Parameter Dashboard, you can visually build and manage complete API workflows.

Key capabilities

• Build API workflows without writing code.
• Import requests from an existing collection.
• Add new requests to a chain.
• Define the execution order using drag and drop.
• Extract variables from API responses.
• Pass extracted variables into subsequent requests.
• Reuse authentication tokens across requests.
• Automatically detect parameter dependencies.
• Get intelligent suggestions for parameter mappings.
• Preview resolved URLs before execution.
• Preview resolved request bodies.
• Visualize variable flow and request dependencies.
• View extracted values and where they are used.
• Execute the complete chain before saving.
• Review execution logs and results.
• Receive execution notifications.
• Share execution results with your team.
• Raise issues directly from execution results.

Creating a Request Chain

Follow these steps to create and execute a Request Chain.

1. 1

   Create a Request Chain

   Click Create Request Chain to create a new chain, and provide the chain name, description, status, target environment, and tags. Set the chain status to Active and select the environment in which the chain should be executed.

2. 2

   Add requests to the chain

   Add API requests by importing from an existing collection, which lets you reuse existing requests instead of creating them again, or by adding a new request directly within the Request Chain.

3. 3

   Define the request execution order

   Use drag and drop to reorder requests and define the sequence in which they should be executed — for example, Create User → Login → Get User → Create Order → Add Product → Checkout. The request order determines how APIs are executed and how extracted variables are passed between them.

4. 4

   Extract variables from responses

   Expand the request, execute it using Run, view the API response, hover over the required response value, select Extract, and define the variable. The extracted value can then be used by another request in the chain.

5. 5

   Pass extracted variables to other requests

   Hover over a URL, query parameter, request body, header, or authentication field in a later request and select an available extracted variable. During execution, the system resolves the variable automatically.

Example: extracting and passing a variable

A login API may return the following response:

{
  "token": "eyJhbGciOi...",
  "userId": "12345"
}

You can extract token and userId. These variables can then be used in subsequent requests — for example, a later request written as GET /users/{{userId}} resolves during execution to GET /users/12345. This allows dependent API workflows to be created without manually copying values between requests.

Authentication and token passing

Request Chain supports extracting authentication information from one API and passing it to subsequent requests, allowing authentication generated by one request to be reused throughout the chain.

Chain Analyzer

The Chain Analyzer analyzes the requests in a chain and identifies parameter dependencies between APIs, providing smart dependency detection so users can understand the relationships between APIs in the chain. It helps answer questions such as:

• Which request generates a value?
• Which request consumes that value?
• Where is an extracted variable being used?
• Which requests depend on another request?
• Are there missing parameter mappings?

Auto Mapping Intelligence

Auto Mapping automatically identifies possible relationships between extracted response values and parameters required by subsequent requests, and suggests mappings to reduce manual configuration. Users can review the suggested mappings and apply the appropriate ones.

Previewing resolved requests

Live URL Preview

The Live URL Preview shows the resolved URL after extracted variables are substituted, allowing users to verify that the correct values will be passed before executing the chain.

/users/{{userId}}/orders/{{orderId}}

Request Body Preview

Request Chain also provides a preview of the resolved request body, helping users verify variable substitution and request data before execution.

{
  "userId": "{{userId}}",
  "productId": "{{productId}}",
  "quantity": 2
}

Chain Viewer

The Chain Viewer provides a visual representation of the complete request chain and its variable dependencies, giving users a complete picture of how data flows through the API workflow. It helps users understand:

• Request execution order
• Which request extracts a variable
• Which request consumes the variable
• Variable flow between requests
• Authentication dependencies
• Relationships between APIs

Login
  |
  └── accessToken ──────────────┐
                                 ↓
                          Get Customer
                                 |
                                 └── customerId ────────┐
                                                          ↓
                                                   Create Order
                                                          |
                                                          └── orderId

Parameter Dashboard

The Parameter Dashboard provides an overview of extracted values and their usage throughout the chain, making it easier to identify broken or unused dependencies. It can help users understand:

• Which variables have been extracted.
• Which request generated each variable.
• Where each variable is used.
• Which requests consume the variable.
• Variable dependencies across the chain.

Run and validate the chain

Before saving the Request Chain, users can click Run All to execute the complete chain. If a request fails or a variable cannot be resolved, users can identify the issue before saving or sharing the chain. Running the chain before saving allows users to verify:

• Request execution order.
• API responses.
• Variable extraction.
• Variable substitution.
• Authentication propagation.
• Parameter mappings.
• Resolved URLs.
• Resolved request bodies.
• Dependency relationships.

Save and execute

Once the chain has been configured and validated:

1. Click Save to save the Request Chain.
2. Optionally execute the chain immediately.
3. Review the execution results.
4. Share the results with the team when required.

Execution results

After executing a Request Chain, users can review the execution results and logs to identify:

• Successful requests
• Failed requests
• API responses
• Variable extraction results
• Variable substitution
• Request and response details
• Execution failures
• Dependency-related failures

Users can use these results to troubleshoot issues within the API workflow.

Notifications and collaboration

Request Chain execution results can be shared with the team. Users can receive execution notifications through supported communication channels such as:

• Email
• Microsoft Teams
• Slack

Execution results can also be shared with team members, and issues can be raised directly from the execution page when a problem is identified.

Network Recording

Request Chain can also be built from real user journeys captured through the Network Interceptor extension. Instead of manually identifying every API call, users can record the operations performed in a web application. Because the recorded collection retains the sequence of API calls and request data, it can significantly reduce the effort required to build an API workflow.

1. 1

   Install the extension

   Install the Network Interceptor extension.

2. 2

   Start recording

   Start recording before performing any actions.

3. 3

   Perform the operations

   Perform the required operations in the web application.

4. 4

   Capture the calls

   The extension records the network/API calls.

5. 5

   Download the collection

   Download the recorded requests as a Postman collection.

6. 6

   Import the collection

   Import the collection into the API testing application.

7. 7

   Build the chain

   Use the recorded sequence and request data to build the Request Chain.

Array and Object Variable Extraction

Request Chain can also support extracting objects or arrays from API responses and using the extracted data in subsequent requests. This is useful when a response contains a list of objects and the complete object or selected object data needs to be reused.

{
  "products": [
    { "id": 101, "name": "Product A", "price": 250 },
    { "id": 102, "name": "Product B", "price": 500 }
  ]
}

Instead of extracting each field individually, users can extract a product object and reuse it in a subsequent request — for example, extracting products[0] as a Product variable and using it directly as test data for an Add to Cart request. This provides a more efficient way to construct complex API workflows and test data.

No-Code API Workflow Management

Request Chain provides a no-code approach to API workflow automation, without writing custom scripts to transfer data between API requests.

Request Chain feature summary

Complete Request Chain workflow

1. Create Request Chain
2. Select Environment
3. Add Tags
4. Import Collection / Add Requests
5. Arrange Request Order
6. Run Requests
7. Extract Variables
8. Map Variables to Subsequent Requests
9. Analyze Dependencies
10. Preview Resolved Requests
11. Run All & Validate
12. Save Request Chain
13. Execute
14. Review Execution Results
15. Notify / Share with Team
16. Raise Issues

Core value proposition