📌Overview

Purpose: The Postman MCP Server aims to provide an integrated solution for managing Postman collections, environments, and APIs within the Model Context Protocol (MCP) framework.

Overview: This server, built with TypeScript, interfaces with the Postman API, facilitating comprehensive management capabilities for users working with Postman resources, thereby enhancing productivity and ease of use.

Key Features:

Collections Management: Supports CRUD operations for Postman collections, including folder and request management, response management, and version control, allowing users to organize and manipulate collections efficiently.
Environment Management: Enables the creation and manipulation of environments, including full CRUD operations, which facilitate seamless setup for various development configurations.
API Management: Provides comprehensive API handling, including schema support and tagging features, to streamline the management and organization of APIs.
Authentication & Authorization: Implements secure access through API key authentication and role-based access control, ensuring that permissions are appropriately managed at both workspace and collection levels.
Advanced Features: Includes private API network capabilities, webhook support, and advanced role controls aimed at enterprise users, enhancing the server's functionality and adaptability to different use cases.

Postman MCP Server

Version: v0.2.0

An MCP server that provides access to the Postman API. Functionality is based on the official OpenAPI specification. For more information, see the Postman API documentation.

This project is part of the Model Context Protocol (MCP) initiative from Anthropic. For more information, visit the MCP GitHub repository and the announcement on the Anthropic blog.

WARNING
This project is currently under active development. Please use with caution and expect breaking changes.

NOTE
AI Generated Code. I used Cline v2.2.2 with Claude 3.5 Sonnet (2024-10-22). See docs/README.md for prompts and details about how this code was generated.

Overview
Features
- Collections
- Environments
- APIs
- Authentication & Authorization
- Additional Features
Installation
- Prerequisites
- Steps
Usage
- Setting up API Keys
- Using Claude Desktop
- Using Cline
- Using Zed
Documentation
- Project Overview
Rationale
Development
Debugging
Other MCP Servers
License

Overview

Postman MCP Server is a TypeScript-based MCP server that integrates with the Postman API, providing comprehensive management of Postman collections, environments, and APIs.

Features

Collections

CRUD Operations: Create, retrieve, update, and delete Postman collections.
Folder Management: Organize requests into folders within collections.
Request Management: Add, update, and delete requests within collections.
Response Management: Manage responses associated with requests.
Version Control: Fork, merge, and pull changes for collections.
Comments: Add and manage comments on collections.

Environments

Manage Environments: Create and retrieve environments for different setups.
CRUD Operations: Full support for creating, updating, and deleting environments.

APIs

API Management: Create, retrieve, update, and delete APIs.
Schema Support: Manage API schemas with multi-file support.
Tagging: Add and manage tags for APIs.
Comments: Add and manage comments on APIs.

Authentication & Authorization

API Key Authentication: Secure access using API keys.
Role-Based Access Control: Manage permissions at workspace and collection levels.
Workspace Permissions: Define permissions specific to workspaces.

Additional Features

Private API Network: Manage elements and folders within a private API network.
Webhooks: Create webhooks to trigger collections with custom payloads.
Enterprise Features: Advanced role controls and SCIM support for enterprise environments.

Installation

Installing via Smithery

To install Postman MCP Server for Claude Desktop automatically via Smithery:

npx -y @smithery/cli install postman-api-server --client claude

Prerequisites

Node.js installed.

Steps

Clone the repository:

git clone https://github.com/delano/postman-api-server.git
cd postman-api-server

Install dependencies:
```
pnpm install
```
Build the server:
```
pnpm run build
```
Run in development mode with auto-rebuild:
```
pnpm run watch
```

Usage

Setting up API Keys

Generate your API Key
- Visit https://go.postman.co/settings/me/api-keys
- Click "Generate API Key"
- Save the key securely - it will not be shown again
Configure the API Key
- Add the key to your environment as POSTMAN_API_KEY
- For Claude Desktop or Cline, include it in your config file (see configuration examples below)
- Never commit API keys to version control
Verify Access
- The API key provides access to all Postman resources you have permissions for
- Test access by running a simple query (e.g., list workspaces)

NOTE
If you're using the Postman API collection directly, store your API key as a postman-api-key collection variable.

Using Claude Desktop

Add the server config at the following location:

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
Windows: %APPDATA%/Claude/claude_desktop_config.json

IMPORTANT
Restart Claude after updating this provider to pick up API changes since Claude caches tool definitions on startup.

Example configuration

{
  "mcpServers": {
    "postman": {
      "command": "node",
      "args": [
        "/path/to/postman-api-server/build/index.js"
      ],
      "env": {
        "POSTMAN_API_KEY": "CHANGEME"
      }
    }
  }
}

Using Cline

Use the same configuration example above in your Cline MCP Servers configuration.

Using Zed

Integration is still in progress. According to the Zed docs, it needs to be implemented as an extension.

Documentation

The official Postman API documentation is available in the Postman Public Workspace.

Project Overview

Postman API References & Summaries

This project uses the Claude model and Cline extension to convert the OpenAPI specification into TypeScript code for better type safety and integration.

The GitHub project includes API references documentation that provides detailed guidance on using the Postman platform programmatically, covering authentication, rate limits, API endpoints such as workspaces, collections, environments, mock servers, and monitors, along with prerequisites and quick-start instructions.

Summaries in markdown format outline API endpoints, request and response formats, and implementation details crucial for MCP server verification.

Building the MCP Server

Refer to the Handlers Documentation for detailed specifications on implementing MCP server handlers, including URI formats, prompt requirements, and resource handling patterns. This guide is crucial for development and enhancement of Postman API functionalities within the MCP server.

Rationale

The MCP wrapper for Postman tools is suited as an AI interaction layer for complex, multi-step operations where structure and safety are important. It is especially valuable for:

Complex Operations
- Managing multiple collections
- Coordinating environments
- Generating reports
AI-Driven Automation
- Automated testing workflows
- API documentation maintenance
- Environment management
Error-Sensitive Operations
- Critical API testing
- Production deployments
- Compliance checking

It is less beneficial for:

Simple operations like quick API calls or basic collection runs
Direct CLI usage for developer-driven local testing

Development

Install dependencies:

pnpm install

Build the server:

pnpm run build

Develop with auto-rebuild:

pnpm run watch

Debugging

MCP servers communicate over stdio, which can complicate debugging. Use the MCP Inspector available via the package script:

pnpm run inspector

The Inspector opens debugging tools in your browser at http://localhost:5173. Add the POSTMAN_API_KEY before connecting and start in the "Tools" section.

Other MCP Servers

Awesome MCP Servers by AppCypher
Awesome MCP Servers by PunkPeye

License

This project is licensed under the MIT License. See the LICENSE file for details.

postman-mcp-server