# Postman MCP

> Postman MCP brings your entire API development workflow directly to your AI client. You can manage collections, environments, mock servers, and health monitors without leaving the chat window. It lets your agent read internal schemas, check differences between Staging and Production URLs, and even report on failing endpoints—all in one go.

## Overview
- **Category:** loved-by-devs
- **Price:** Free
- **Tags:** api-testing, api-documentation, mock-servers, rest-api, collection-management, endpoint-testing

## Description

Your agent connects to this MCP and instantly gains access to all your API documentation, bypassing manual downloads or reading raw cURL files. Instead of dumping JSONs into a prompt, you just ask the question: 'How does my user creation endpoint work?' Your AI client pulls the complete schema from your collections and gives you the exact requirements. It lets you map out development environments across different stages (like Staging vs. Production) and test how they differ automatically. Need to simulate a payment gateway response while the front-end is ready? You can pull active mock server URLs instantly. This MCP makes API testing, documentation, and environment management conversational—a huge win for any team using Vinkius as their central catalog.

## Tools

### list_collections
Lists every full API Collection available in your Postman account so the agent knows what APIs exist.

### list_workspaces
Lists all engineering team workspaces configured within your Postman account.

### list_environments
Retrieves a list of development environments, showing which variables are set for Staging or Production.

### list_mocks
Lists all configured Mock Servers, letting you see which endpoints are ready to simulate responses for front-end testing.

### list_monitors
Checks the API health monitors and reports on their schedules and last run status (Success or Failure).

### get_collection
Downloads the complete, structured schema of a Postman Collection, detailing all endpoints, methods, headers, and request bodies.

## Prompt Examples

**Prompt:** 
```
Are there any Mock servers currently simulating our Auth API?
```

**Response:** 
```
I checked your Postman configurations and found 1 active mock server tied to 'User Onboarding Flows'. It exposes exactly 4 static JSON responses for `/login` and `/token` and operates at URL `https://c123.mock.pstmn.io`. Shall I pull its schema details?
```

**Prompt:** 
```
Download our core API Collection. Tell me exactly what parameters I need to submit to the Create User endpoint.
```

**Response:** 
```
I extracted Collection `col-x71...`, the 'Create User' endpoint (POST `/api/v2/users`) expects a JSON body containing `email` (string, required), `role` (string, defaults to 'viewer'), and `department_id` (number, required). Would you like me to write a Javascript snippet invoking it?
```

**Prompt:** 
```
Did any of our scheduled Postman monitors fail over the weekend?
```

**Response:** 
```
Looking at the `list_monitors` data, your 'Checkout Flow Monitor' failed consecutively on Saturday morning. The internal log indicates an assertion error mapping a `502 Bad Gateway` status on step 3 (`POST /cart`). All other monitors are currently healthy and passing.
```

## Capabilities

### Examine full API schemas
The system extracts complete internal JSON schemas from your Postman Collections, exposing every endpoint, method, and required header.

### Compare development environments
You can list all configured workspaces and environments, allowing the agent to compare variables between Staging and Production setups.

### Test simulated API responses
The MCP lists active mock servers, letting your AI client pull specific URLs and static JSON data for testing decoupled front-ends.

### Review scheduled health status
Retrieve a history of automated cron checks, showing which API monitors passed or failed over time.

### Discover all available APIs
The agent lists every API Collection associated with your Postman account.

## Use Cases

### Debugging environment drift
The QA tester noticed the Staging site was broken. Instead of opening Postman and comparing variables manually, they ask their agent to list environments and immediately confirm that the `api_base_url` variable is different between Staging and Production.

### Building a new feature UI
The frontend developer needs to build a user profile widget. They ask the agent to get_collection for the User API, which extracts the full schema, showing them exactly what JSON fields are required for name and email.

### Verifying payment flow stability
The team suspects the checkout process failed overnight. They ask the agent to list_monitors, which immediately reports that the 'Payment Gateway Monitor' failed on step 3 with a specific status code, pointing them exactly where to look.

### Creating isolated API demos
A teammate needs a quick demo of how the user signup process works. They ask the agent to list_mocks and get the mock server URL for 'User Onboarding Flows,' allowing them to test it without hitting any real backend services.

## Benefits

- Stop manually jumping between tools. You can use the agent to check environment differences between Staging and Production without ever clicking away from your chat window.
- Get precise data payloads instantly. Instead of downloading JSONs, ask the AI client to extract a Collection's schema right in your conversation so you know exactly what parameters are needed for an endpoint.
- Test decoupled UIs easily. By listing mocks or using the mock server URLs, you can get simulated JSON responses immediately, which is critical when the backend isn't ready yet.
- Never miss a failure. Use the list_monitors tool to ask about scheduled checks and see real-time reports on any API endpoints that failed over the weekend.
- Simplify onboarding. Instead of showing new hires dozens of collections, you can simply let your agent list all available Collections so they know where to start.

## How It Works

The bottom line is that you get real-time visibility into your entire API landscape without ever opening the Postman GUI.

1. Subscribe to this MCP and provide your Postman Developer API Key.
2. Your AI client connects the key, giving it read access to all your collections, environments, and monitors.
3. You ask a natural language question (e.g., 'What are my Staging URLs?') and the agent executes the necessary tools and returns the structured data.

## Frequently Asked Questions

**How do I use Postman MCP to check if my APIs are stable?**
You use the list_monitors tool. The agent checks your scheduled health monitors and tells you exactly which endpoints have failed, what status code they reported (like 502 Bad Gateway), and when they last ran.

**Can Postman MCP help me compare Staging vs Production?**
Yes. You ask the agent to list_environments. It reads all configured variables for both environments, letting you see if critical URLs or keys differ without ever opening the main Postman app.

**What is get_collection doing when I use Postman MCP?**
The get_collection tool downloads the complete internal JSON schema of a specific API Collection. This exposes all endpoints, HTTP methods, and required parameters so your AI can understand exactly how the API works.

**Do I need to manually set up mock servers?**
No. You just ask the agent to list_mocks. It reports on the active simulated endpoints, which is useful for frontend developers who need temporary data without a live backend.

**Is Postman MCP only for basic API listing?**
Not at all. Beyond simply listing collections or workspaces, it allows deep comparison of variables and retrieval of complex schemas needed for development tasks.