Postman

Introduction

The Postman toolkit integrates ELITEA with your Postman workspace, enabling Agents, Pipelines, and Chat conversations to automate API collection management, execute requests, and streamline API testing workflows — all directly from within ELITEA.

Brief Overview of Postman

Postman is a leading web-based API platform that helps teams of all sizes efficiently design, test, document, and manage APIs.

API Request Management

Create, organize, and manage API requests and collections with rich documentation and environment variables.

Automated Testing

Define and execute automated API tests, track results in real-time, and integrate with CI/CD pipelines.

Collection Organization

Structure API requests into logical collections and folders for improved maintainability and discoverability.

Integration with Development Tools

Seamlessly integrates with version control, CI/CD, and other tools, making it a central hub for your API ecosystem.

Collaboration & Sharing

Share collections, environments, and test results with your team for better collaboration.

Integrating Postman with ELITEA brings these robust API management capabilities directly into your AI-driven workflows. Your ELITEA Agents, Pipelines, and Chat conversations can intelligently interact with your Postman workspace to automate API-related tasks, manage collections and requests, and improve team collaboration.

Toolkit’s Account Setup and Configuration

Account Setup If you don’t already have a Postman account, follow these steps to create one:

Visit Postman: Navigate to postman.com
Sign Up: Click the “Sign Up” button
Enter Details: Provide your email address, enter your name, and create a secure password
Verify Email: Check your inbox for a verification email from Postman and click the verification link to activate your account
Log In: Once verified, log in to Postman with your credentials

Generate an API Key

For secure integration with ELITEA, you must use a Postman API Key. This method is significantly more secure than using your primary Postman account password directly. Follow these steps to generate an API Key in Postman:

Log in to Postman: Access your Postman account at postman.com.
Navigate to API Keys:
- In the Postman app: Click your profile icon in the top-right corner → “Settings” → “API Keys” tab.
- In the browser: Click the settings icon → “Account Settings” → “API Keys” tab.
Create API Key: Click the “Generate API Key” button and provide a descriptive name (e.g., “ELITEA Integration Key”).
Copy and Store the API Key: Immediately copy the generated API key — this is the only time it will be displayed in full. Store it securely in a password manager or ELITEA’s Secrets feature.

Principle of Least Privilege: The Postman API Key grants access to your Postman workspace using your account’s permissions. Store keys securely and rotate them periodically.Use ELITEA Secrets: Always reference your API key through ELITEA’s Secrets feature rather than entering it directly in configuration fields.

Find Your Collection ID and Workspace ID

To configure the Postman toolkit in ELITEA, you will need the Collection ID and Workspace ID. Here’s how to find them in the Postman web interface:

How to Find the Workspace ID

Option 1: From the Postman App

Open Postman and navigate to the workspace you want to use.
Open Workspace info: Click the ellipsis (...) icon next to the workspace name, then select “Workspace Info”.
Copy the Workspace ID: The Workspace ID (UUID) is displayed in the modal window. Copy it directly.

Option 2: From the Browser URL

Open Postman in the browser and select the workspace you want to use.
Locate the Workspace ID in the URL:
- The URL follows the pattern: https://<team>.postman.co/workspace/<workspace-name>~<workspace-id>/overview
- The UUID value after the ~ symbol is your Workspace ID.

The workspace URL contains both the workspace name and its UUID separated by ~. Copy only the UUID part that comes after the ~ symbol — do not include the workspace name or the ~ itself.Example:

URL: https://myteam.postman.co/workspace/MyWorkspace~12345678-abcd-efgh-ijkl-1234567890ab/overview
Workspace ID: 12345678-abcd-efgh-ijkl-1234567890ab

How to Find the Collection ID

Open Postman and navigate to the workspace containing your collection.
Select the Collection you want to use.
Locate the Collection ID:
- In the browser URL, you will see a path like https://web.postman.co/workspace/<workspace-name>/collection/<collection-id>.
- The UUID value after /collection/ is your Collection ID.

URL: https://web.postman.co/workspace/MyWorkspace/collection/12345678-90ab-cdef-1234-567890abcdef
Collection ID: 12345678-90ab-cdef-1234-567890abcdef

You can also use the Postman API to programmatically list collections and workspaces, which will include their IDs in the response.

System Integration with ELITEA

To integrate Postman with ELITEA, you need to follow a three-step process: Create Credentials → Create Toolkit → Use in Agents. This workflow ensures secure authentication and proper configuration.

Step 1: Create Postman Credentials

Before creating a toolkit, you must first create Postman credentials in ELITEA:

Navigate to Credentials Menu: Open the sidebar and select Credentials.
Create New Credential: Click the + Create button.
Select Postman: Choose Postman as the credential type.

Configure Credential Details:

Field	Description	Example
Display Name	Enter a descriptive name	`Postman - My Workspace`
ID	Unique identifier for the credential	Auto-populated from the Display Name
Base URL	Enter the Postman API base URL	`https://api.getpostman.com`
Workspace ID	Enter your Postman Workspace ID	`abcdef12-3456-7890-abcd-ef1234567890`
API Key	Enter your Postman API Key	`PMAK-xxxxxxxxxxxxxxxx`

Save Credential: Click Save to create the credential

It’s highly recommended to use Secrets for API Keys instead of entering them directly. Create a secret first, then reference it in your credential configuration.

Step 2: Create Postman Toolkit

Once your credentials are configured, create the Postman toolkit:

Navigate to Toolkits Menu: Open the sidebar and select Toolkits.
Create New Toolkit: Click the + Create button.
Select Postman: Choose Postman from the list of available toolkit types.

Configure Toolkit Settings:

Field	Description	Example
Toolkit Name	Enter a descriptive name for your toolkit	`Postman - API Collection Manager`
Description	Add a description of the toolkit’s purpose (optional)	`Manages Postman API collections and automates request workflows`
Postman Configuration	Select your previously created Postman credential	`Postman - My Workspace`
Collection ID	Enter the default collection ID to scope all toolkit operations	`12345678-90ab-cdef-1234-567890abcdef`
Environment Config	Enter a JSON object with variables to override when executing requests (auth headers, base URLs, project IDs, etc.)	`{"base_url": "https://api.example.com", "api_key": "your-key"}`

Enable Desired Tools: In the “Tools” section, select the checkboxes next to the specific Postman tools you want to enable. Enable only the tools your agents will actually use to follow the principle of least privilege.
- Make Tools Available by MCP — (optional checkbox) Enable this option to make the selected tools accessible through external MCP clients.
Save Toolkit: Click Save to create the toolkit

The Collection ID is required and scopes the toolkit to a single Postman collection. All folder, request, and analysis operations work within this collection. To work with multiple collections, create separate toolkit instances with different Collection IDs.

Environment Config Format

The Environment Config field accepts a JSON object that provides variable values used when executing requests. The variable names should match the environment variables defined in your Postman environment (e.g., exported from Environments in Postman). There are two supported formats: Simple key-value variables (used to resolve {{variable}} placeholders in requests):

{
  "base_url": "https://api.example.com",
  "project_id": "12345",
  "auth_token": "your-auth-token"
}

The keys in this JSON should match the variable names in your Postman environment. For example, if your Postman environment defines base_url, project_id, and auth_token, use those exact names here. The toolkit will substitute {{base_url}}, {{project_id}}, and {{auth_token}} placeholders in your requests with the values provided.

Structured authentication (used to inject auth headers directly when executing requests):

{
  "base_url": "https://api.example.com",
  "project_id": "12345",
  "auth": {
    "type": "bearer",
    "bearer": [{"value": "your-auth-token"}]
  }
}

Supported auth.type values: bearer, basic, api_key, oauth2, custom.

The Environment Config field does not accept the raw JSON file exported from Postman (which contains id, name, values array, and metadata). You must manually extract the variable names and their values and build a flat key-value JSON object.Exported Postman environment (not supported):

{
  "name": "my_environment",
  "values": [
    { "key": "base_url", "value": "https://api.example.com", "enabled": true },
    { "key": "auth_token", "value": "your-token", "enabled": true },
    { "key": "project_id", "value": "12345", "enabled": true }
  ]
}

Environment Config to paste in ELITEA (supported):

{
  "base_url": "https://api.example.com",
  "auth_token": "your-token",
  "project_id": "12345"
}

Available Tools

The Postman toolkit provides the following tools for interacting with Postman collections, folders, and requests, organized by functional category:

Tool Category	Tool Name	Description	Primary Use Case
Collection Access
	Get collections	Retrieves all collections accessible in the configured workspace	List and browse available API collections
	Get collection	Retrieves the configured collection in flattened format with path-based structure. Accepts an optional collection ID; defaults to toolkit configuration	Inspect collection structure and full content
Folder Management
	Get folder	Retrieves a specific folder in flattened format using a path-based identifier (e.g., `API/Users`)	Access folder structure and its requests
	Create folder	Creates a new folder within the collection, optionally nested under a parent path	Organize requests into logical groups
	Update folder	Updates folder properties: name, description, and/or authentication settings	Modify folder metadata
	Delete folder	Permanently deletes a folder and all its contents	Remove obsolete folder hierarchies
	Move folder	Moves a folder to a different location within the collection	Reorganize collection structure
Request Access
	Get request by path	Retrieves a specific request using its hierarchical path (e.g., `API/Users/Get User`)	Access request details without knowing the ID
	Get request by ID	Retrieves a specific request by its unique Postman ID	Direct lookup of a known request
	Get request script	Retrieves the test or pre-request script content attached to a request	Review or audit automation scripts
	Search requests	Searches for requests across the collection by name, URL, description, or all fields; supports HTTP method filter	Find requests matching specific criteria
Request Management
	Create request	Creates a new API request in a specified folder with method, URL, headers, body, auth, and scripts	Add new API endpoints to the collection
	Update request name	Renames a request identified by its path	Clarify request naming for readability
	Update request method	Changes the HTTP method of a request (GET, POST, PUT, etc.)	Correct or update request type
	Update request URL	Updates the URL of a request	Modify the target endpoint
	Update request description	Updates the description of a request	Add or improve inline documentation
	Update request headers	Replaces the header list of a request using `Header-Name: value` format (one per line)	Update authentication or content type headers
	Update request body	Updates the request body; supports `raw`, `formdata`, and `urlencoded` modes	Modify request payload
	Update request auth	Updates the authentication settings on a request (bearer, basic, apikey, etc.)	Configure request-level authentication
	Update request tests	Replaces the test (post-response) script on a request	Add or modify automated test assertions
	Update request pre script	Replaces the pre-request script on a request	Add or modify pre-execution setup logic
	Duplicate request	Creates a copy of an existing request, optionally in a different folder	Create variants or template-based requests
	Move request	Moves a request to a different folder within the collection	Reorganize requests
	Delete request	Permanently deletes an API request	Remove outdated or duplicate entries
Collection Management
	Update collection description	Updates the description of the collection	Improve collection-level documentation
	Update collection variables	Replaces the variables defined at the collection level	Manage shared variable values across all requests
	Update collection auth	Updates the default authentication settings at the collection level	Configure collection-wide authentication
	Duplicate collection	Creates a copy of the configured collection with a new name	Back up or create test variants of collections
	Delete collection	Permanently deletes the configured collection	Remove an obsolete collection
Execution & Analysis
	Execute request	Executes a request by path, resolving `{{variable}}` placeholders from the Environment Config and optional per-call overrides	Run requests and validate API responses in real-time
	Analyze	Analyzes the collection, a specific folder, or a specific request for API quality, documentation completeness, security issues, and best practices	Identify quality gaps and improvement opportunities

The Delete collection, Delete folder, and Delete request tools permanently remove data from your Postman workspace. Enable only these tools if your agent genuinely requires deletion capabilities, and always follow the principle of least privilege.

Testing Toolkit Tools

After configuring your Postman toolkit, you can test individual tools directly from the Toolkit detail page using the Test Settings panel. This lets you verify credentials and validate tool behavior before deploying to your workflows. General Testing Steps:

Select LLM Model: Choose a Large Language Model from the model dropdown in the Test Settings panel
Configure Model Settings: Adjust model parameters as needed
Select a Tool: Choose the specific Postman tool you want to test
Provide Input: Enter any required parameters for the selected tool
Run the Test: Execute the tool and wait for the response
Review the Response: Confirm the tool returns expected results

Verify that Postman credentials and connection are configured correctly
Validate that tools function as expected with your Postman collection
Test different parameter combinations before production use
Familiarize yourself with tool capabilities and expected outputs

For detailed instructions on how to use the Test Settings panel, see How to Test Toolkit Tools.

Step 3: Add Postman Toolkit to Your Workflows

Now you can add the configured Postman toolkit to your agents, pipelines, or use it directly in chat:

In Agents
In Pipelines
In Chat

Navigate to Agents: Open the sidebar and select Agents
Create or Edit Agent: Either create a new agent or select an existing agent to edit
Add Postman Toolkit:
- In the “TOOLKITS” section of the agent configuration, click the “+Toolkit” icon
- Select your desired Postman toolkit from the dropdown menu
- The toolkit will be added to your agent with the previously configured tools enabled

Instructions and Prompts for Using the Postman Toolkit

To effectively instruct your ELITEA Agent to use the Postman toolkit, provide clear and precise instructions within the Agent’s “Instructions” field. These instructions guide the Agent on when and how to utilize the available Postman tools.

Instruction Creation for Agents

When crafting instructions for the Postman toolkit, clarity and precision are paramount. Break down complex tasks into a sequence of simple, actionable steps and explicitly define all parameters required for each tool. Agents respond best to instructions that are:

Direct and Action-Oriented: Use strong action verbs and clear commands, for example: “Use the get_collections tool…”, “Execute the request using execute_request…”, “Analyze the collection using analyze…”.
Parameter-Centric: Enumerate each required parameter by name and specify how the Agent should determine its value — from user input, from a previous step, from a hardcoded value, or from a variable.
Contextually Rich: Provide sufficient background so the Agent understands the overarching objective and which tool to apply within each step of the workflow.
Step-by-Step Structure: Organize instructions into numbered steps for complex multi-tool workflows.
Add Conversation Starters: Include example conversation starters that users can use to trigger the functionality.

When instructing your Agent to use a Postman toolkit tool, follow this structured pattern:

State the Goal: Clearly state the objective. For example, “Goal: Execute a specific API request and display the response.”
Specify the Tool: Indicate the tool to use. For example, “Tool: Use the execute_request tool.”
Define Parameters: List all required parameters, including how the Agent should obtain each value.
Describe Expected Outcome (Optional): Briefly describe what should happen after tool execution.
Add Conversation Starters: Include example prompts that users can try.

Agent Instructions for Executing an API Request:

Goal: Execute a specific API request in Postman and display the response.
Tool: Use the "execute_request" tool.
Parameters:
    - request_path: "Ask the user for the request path, e.g., 'Auth/Login' or 'Users/Get User'."
    - override_variables: "Ask the user if they want to override any variables, or pass '{}'."
Outcome: Display the response status code, headers, and body. Confirm successful execution to the user.
Conversation Starters: "Execute the login request", "Run the Get User request with user_id=123"

Agent Instructions for Analyzing a Collection:

1. Goal: Analyze the Postman collection for API quality, documentation gaps, and best practices.
2. Tool: Use the "analyze" tool.
3. Parameters:
    - scope: "Use 'collection' to analyze the full collection, 'folder' for a specific folder, or 'request' for a single request."
    - target_path: "If scope is 'folder' or 'request', ask the user for the path. Leave empty for 'collection' scope."
    - include_improvements: "Set to true to include improvement suggestions."
4. Outcome: Present the analysis report with score, issues found, and recommendations.
5. Conversation Starters: "Analyze my Postman collection", "Check the Auth folder for best practices"

Chat Usage Examples by Tool Category

The following examples demonstrate how to interact with the Postman toolkit in ELITEA Chat, organized by functional category.

Collection Access - Get Collections

Chat Example:

User: "Show me all Postman collections in my workspace."

Agent Response: [Agent uses get_collections tool]

**Postman Collections** (3 collections):

1. **User API** (col_123) — 12 requests
2. **Payment Gateway** (col_456) — 8 requests
3. **Analytics API** (col_789) — 15 requests

Collection Access - Get Collection

Chat Example:

User: "Show me the structure of my collection."

Agent Response: [Agent uses get_collection tool]

**Collection: User API**

- Auth/
  - POST Auth/Login
  - POST Auth/Refresh
  - POST Auth/Logout
- Users/
  - GET Users/List
  - GET Users/Get User
  - POST Users/Create User
  - PUT Users/Update User
  - DELETE Users/Delete User

Request Access - Search Requests

Chat Example:

User: "Find all requests related to 'authentication'."

Agent Response: [Agent uses search_requests tool]

**Search Results for "authentication"** (3 matches):

1. **POST Auth/Login** — Authenticate user with email and password
2. **POST Auth/Refresh** — Refresh authentication token
3. **POST Auth/Logout** — Invalidate user session

Execution - Execute Request

Chat Example:

User: "Execute the Auth/Login request."

Agent Response: [Agent uses execute_request tool]

**Request Executed Successfully!**

- **Request**: POST /api/auth/login
- **Status**: 200 OK
- **Response Time**: 145ms

**Response Body**:
{
  "status": "success",
  "token": "eyJhbGci...",
  "expires_in": 3600
}

Execution - Execute with Variable Overrides

Chat Example:

User: "Execute the Users/Get User request with user_id set to 42."

Agent Response: [Agent uses execute_request tool with override_variables='{"user_id": "42"}']

**Request Executed Successfully!**

- **Request**: GET /api/users/42
- **Status**: 200 OK

**Response Body**:
{
  "id": 42,
  "name": "Jane Doe",
  "email": "jane@example.com"
}

Analysis - Analyze Collection

Chat Example:

User: "Analyze my collection for best practices and issues."

Agent Response: [Agent uses analyze tool with scope='collection', include_improvements=true]

**Analysis Report: User API**

- **Quality Score**: 72%
- **Security Score**: 80%
- **Documentation Score**: 65%
- **Total Requests**: 12

**Issues Found**:
1. Missing descriptions on 4 requests
2. Hardcoded base URLs in 2 requests — use {{base_url}} variable instead
3. No test scripts on 5 requests

**Recommendations**:
- Add descriptions to all requests for better discoverability
- Replace hardcoded URLs with environment variables
- Add test assertions to validate response structure and status codes

Folder Management - Create Folder

Chat Example:

User: "Create a new folder called 'Webhooks' in my collection."

Agent Response: [Agent uses create_folder tool]

**Folder Created Successfully!**

- **Name**: Webhooks
- **Path**: Webhooks

The folder is ready for organizing your webhook-related requests.

Request Management - Create Request

Chat Example:

User: "Create a new GET request for fetching user profiles in the Users folder."

Agent Response: [Agent uses create_request tool]

**Request Created Successfully!**

- **Method**: GET
- **URL**: {{base_url}}/api/users/profile
- **Folder**: Users
- **Description**: Retrieve the authenticated user's profile

Request Management - Update Request Body

Chat Example:

User: "Update the body of the Auth/Login request to add a 'remember_me' field."

Agent Response: [Agent uses update_request_body tool]

**Request Body Updated Successfully!**

- **Request**: Auth/Login

**New Body**:
{
  "email": "{{user_email}}",
  "password": "{{user_password}}",
  "remember_me": false
}

Troubleshooting

Connection Issues

Problem: Agent fails to connect to Postman or experiences timeout errorsPossible Error Messages:

“Postman API request failed: connection refused”
“Postman API request failed: connection timed out”
“Invalid JSON response from Postman API”

Solutions:

Verify Base URL Format:
- Use https://api.getpostman.com (without a trailing slash)
- Ensure the URL starts with https://
Check Network Connectivity:
- Verify you can access https://api.getpostman.com from your environment
- Check firewall or proxy settings that may block outbound API calls
API Endpoint Validation:
- Errors surface when the first API call is made (e.g., when a tool is first invoked after saving the toolkit)
- Verify your API key and workspace settings are correctly configured if an initial tool call returns an error

Authentication Errors

Problem: “Unauthorized”, “Forbidden”, or API key-related errorsPossible Error Messages:

“401 Unauthorized”
“403 Forbidden”
“Authentication failed”

Solutions:

Verify API Key:
- Ensure the API key is copied correctly without leading or trailing spaces
- Confirm the API key has not been revoked or expired in Postman Settings → API Keys
Regenerate if Necessary:
- If the key is compromised or invalid, generate a new one in Postman Settings
- Update the toolkit credential with the new key and delete the old key for security

Collection or Resource Not Found

Problem: Cannot find specified collection, folder, or requestPossible Error Messages:

"Postman API request failed: 404 Client Error" (invalid Collection or Workspace ID)
"Folder '{folder_path}' not found in collection '{collection_id}'" (incorrect folder path)
"Request '{request_path}' not found" (incorrect request path)
"Parent folder '{parent_path}' not found" (invalid parent path in create_folder)
"Source folder '{source_path}' not found" / "Source request '{source_path}' not found" (move or duplicate operations)

Solutions:

Verify Collection ID:
- Confirm the Collection ID in the toolkit settings matches the UUID visible in the Postman URL
- Collection IDs are case-sensitive UUIDs (e.g., 12345678-90ab-cdef-1234-567890abcdef)
Verify Workspace ID:
- Confirm the Workspace ID in the credential matches the UUID in the Postman URL
- Verify the collection belongs to the specified workspace
Path-Based Resources:
- Folder and request paths are case-sensitive and must exactly match the names in Postman
- Use the get_collection tool to inspect the actual names before using path-based tools
- Nested paths use / as separator: ParentFolder/ChildFolder/RequestName

Request Execution Failures

Problem: The execute_request tool fails or returns unexpected resultsPossible Error Messages:

“Request not found at path”
HTTP error responses from the target API

Solutions:

Verify Request Path:
- Use get_request_by_path or search_requests to confirm the correct path before executing
- Paths are case-sensitive
Check Variable Resolution:
- If the request uses {{variable}} placeholders, ensure the Environment Config JSON contains matching keys
- Use override_variables for per-call overrides: '{"base_url": "https://api.example.com"}'
- If override_variables contains invalid JSON it is silently ignored — execution continues with no overrides applied. If variable substitution is not working, check the JSON syntax of the override_variables argument.
Authentication Configuration:
- Ensure the auth block in Environment Config is correctly structured for your authentication type
- Supported types: bearer, basic, api_key, oauth2, custom
- Example for bearer auth: {"auth": {"type": "bearer", "bearer": [{"value": "your-token"}]}}
Target API Availability:
- Verify the target API endpoint is accessible from the ELITEA environment
- Check that all required variable values are provided in Environment Config

Support Contact

If you encounter issues not covered in this guide or need additional assistance, please refer to Contact Support for detailed information on how to reach the ELITEA Support Team.

FAQ

Can I use my regular Postman password instead of an API Key?

No, you must use a Postman API Key for integration. Regular passwords are not supported. API Keys are more secure, can be individually revoked without changing your account password, and are the recommended authentication method for API integrations.Generate your API Key at: Postman Settings → API Keys.

Where do I find Collection IDs, Folder IDs, and Request IDs?

Collection ID: Visible in the Postman web URL when viewing a collection: .../collection/<collection-id>
Workspace ID: Visible in the Postman web URL when viewing a workspace: .../workspace/<workspace-id>
Request paths: Use the get_collection tool to list all paths in the collection in flattened format, then use those paths with path-based tools (e.g., Auth/Login)
Request IDs: Use search_requests or get_request_by_path to discover request IDs programmatically

Can the toolkit work with multiple collections?

Each toolkit instance is scoped to a single collection via the Collection ID setting. To work with multiple collections, create separate toolkit instances — each can reference the same credential but point to a different collection.Example Setup:

Toolkit 1: "Postman - User API"
- Collection ID: 12345678-...

Toolkit 2: "Postman - Payment API"
- Collection ID: abcdef12-...

Can I execute requests that require authentication?

Yes. The execute_request tool resolves authentication at execution time using:

Environment Config variables — Simple key-value pairs that replace {{variable}} placeholders in the request
Environment Config auth object — A structured auth block that injects authentication headers into the outbound HTTP call
Override variables — Per-call overrides passed as a JSON string to the override_variables parameter

Example Environment Config with bearer authentication:

{
  "auth": {
    "type": "bearer",
    "bearer": [{"value": "your-token"}]
  },
  "base_url": "https://api.example.com"
}

Other supported auth types use a params key:

Basic
API Key
OAuth2
Custom

{
  "auth": {
    "type": "basic",
    "params": {
      "username": "your-username",
      "password": "your-password"
    }
  }
}

{
  "auth": {
    "type": "api_key",
    "params": {
      "key": "X-API-Key",
      "value": "your-api-key",
      "in": "header"
    }
  }
}

"in" accepts "header" (default), "query", or "cookie".

{
  "auth": {
    "type": "oauth2",
    "params": {
      "access_token": "your-oauth2-access-token"
    }
  }
}

{
  "auth": {
    "type": "custom",
    "params": {
      "headers": {"X-Custom-Header": "value"},
      "query": {"api_flag": "1"},
      "cookies": {"session": "abc123"}
    }
  }
}

What happens if I update a request while someone else is editing it?

Postman uses collaborative, last-write-wins editing. Changes made through the ELITEA toolkit are synchronized to the Postman workspace immediately. Be aware that concurrent modifications may overwrite each other. For critical collections, coordinate changes with your team or use Postman’s fork and pull request features.

Can the toolkit analyze private or team collections?

Yes, as long as the API key used in the credential has access to the collection’s workspace. The analyze tool works on any collection accessible to the API key. Verify your workspace membership and collection visibility settings in Postman if access issues arise.

Why are some tools not available (e.g., create_collection)?

The Available Tools table reflects only the tools that are currently active in the SDK implementation. Some capabilities (such as create_collection and update_collection_name) are not yet exposed as toolkit tools. The list will expand as the toolkit evolves.

How to Use Chat Functionality — Learn interactive Postman operations in Chat
Create and Edit Agents from Canvas — Quick agent creation for Postman automation
Create and Edit Toolkits from Canvas — Streamline Postman toolkit configuration
Create and Edit Pipelines from Canvas — Build automated Postman workflows
Toolkit Run History — Track, review, and audit Postman toolkit execution runs

Postman Website — Access the main Postman platform
Postman API Key Settings — Create and manage API keys
Postman API Documentation — Official Postman REST API reference
ELITEA Support — Contact support team for assistance

MCP

Toolkits

Applications

Third-Party Integrations

Extensions

Introduction

Brief Overview of Postman

API Request Management

Automated Testing

Collection Organization

Integration with Development Tools

Collaboration & Sharing

Toolkit’s Account Setup and Configuration

Generate an API Key

Find Your Collection ID and Workspace ID

How to Find the Workspace ID

How to Find the Collection ID

System Integration with ELITEA

Step 1: Create Postman Credentials

Step 2: Create Postman Toolkit

Environment Config Format

Available Tools

Testing Toolkit Tools

Step 3: Add Postman Toolkit to Your Workflows

Instructions and Prompts for Using the Postman Toolkit

Instruction Creation for Agents

Chat Usage Examples by Tool Category

Troubleshooting

Support Contact

FAQ

​Introduction

​Brief Overview of Postman

API Request Management

Automated Testing

Collection Organization

Integration with Development Tools

Collaboration & Sharing

​Toolkit’s Account Setup and Configuration

​Generate an API Key

​Find Your Collection ID and Workspace ID

​How to Find the Workspace ID

​How to Find the Collection ID

​System Integration with ELITEA

​Step 1: Create Postman Credentials

​Step 2: Create Postman Toolkit

​Environment Config Format

​Available Tools

​Testing Toolkit Tools

​Step 3: Add Postman Toolkit to Your Workflows

​Instructions and Prompts for Using the Postman Toolkit

​Instruction Creation for Agents

​Chat Usage Examples by Tool Category

​Troubleshooting

​Support Contact

​FAQ

Introduction

Brief Overview of Postman

Toolkit’s Account Setup and Configuration

Generate an API Key

Find Your Collection ID and Workspace ID

How to Find the Workspace ID

How to Find the Collection ID

System Integration with ELITEA

Step 1: Create Postman Credentials

Step 2: Create Postman Toolkit

Environment Config Format

Available Tools

Testing Toolkit Tools

Step 3: Add Postman Toolkit to Your Workflows

Instructions and Prompts for Using the Postman Toolkit

Instruction Creation for Agents

Chat Usage Examples by Tool Category

Troubleshooting

Support Contact

FAQ