← Back to directory
O

OpenAPI Proxy MCP Server

Community
Dynamically expose any OpenAPI-defined REST API as MCP tools.
GitHub source repository ↗
★ 153 Stars Category · Dev Tools Popular Source revision 5a5e4c955047
51FMRS · D
Reliability
8/20
Security and permissions
7/20
Maintenance
10/20
Documentation
13/20
Setup experience
13/20

mcp-openapi-proxy is a practical generic proxy that dynamically converts OpenAPI-defined REST APIs into MCP tools, simplifying integration. It supports multiple authentication schemes and filtering options, with rich examples and verified client compatibility. However, tool lists are dynamic and cannot be enumerated upfront; some clients have limited prompts/resources support. Overall, it's a powerful tool for quickly connecting a wide range of REST APIs.

Read the FMRS scoring method →

mcp-openapi-proxy is a Python package that implements a Model Context Protocol (MCP) server designed to dynamically expose REST APIs—defined by OpenAPI specifications—as MCP tools, facilitating seamless integration of OpenAPI-described APIs into MCP-based workflows. It offers two operational modes: Low-Level Mode (default) renders each valid endpoint as a tool; FastMCP Mode (simple mode) exposes a static set of tools (list_functions and call_function). It supports OpenAPI v3 (with potential v2 support), endpoint filtering via whitelist, flexible authentication (Bearer in Authorization header, custom schemes, api-key header), and payload token stripping via JMESPath. It also provides additional MCP resources (e.g., use-case documents) and prompts (summarize_spec, whimsical_blog).

Tools

The tool list has not been reviewed yet.

Setup

Install from PyPI:\n\n``bash\nuvx mcp-openapi-proxy\n`\n\nConfigure within your MCP ecosystem's mcpServers settings:\n\n`json\n{\n "mcpServers": {\n "mcp-openapi-proxy": {\n "command": "uvx",\n "args": ["mcp-openapi-proxy"],\n "env": {\n "OPENAPI_SPEC_URL": "${OPENAPI_SPEC_URL}",\n "API_KEY": "${API_OPENAPI_KEY}"\n }\n }\n }\n}\n``\n\nSet the required OPENAPI_SPEC_URL environment variable and optional ones like API_KEY, TOOL_WHITELIST, etc.

claude_desktop_config.json
{
  "mcpServers": {
    "mcp-openapi-proxy": {
      "command": "uvx",
      "args": [
        "mcp-openapi-proxy"
      ],
      "env": {
        "OPENAPI_SPEC_URL": "${OPENAPI_SPEC_URL}",
        "API_KEY": "${API_OPENAPI_KEY}"
      }
    }
  }
}

Fit and risk

Best for

  • Developers and teams who want to integrate existing REST APIs described by OpenAPI into the MCP ecosystem.
  • Scenarios where you need quick conversion of APIs to MCP tools with dynamic tool generation.

Not for

  • APIs without OpenAPI specifications (would need manual generation or conversion).
  • Use cases requiring fine-grained control over each tool's behavior (this server is generic and spec-driven).
  • APIs with complex authentication flows (e.g., OAuth) unless handled manually via custom headers and EXTRA_HEADERS.

Required permissions

  • Access to the OpenAPI spec URL (HTTP or local file).
  • API keys or tokens for the target API (via API_KEY or custom headers).
  • Read/write permissions to the target API depending on exposed tools.

Risks and side effects

  • Exposing many tools may consume tokens or degrade performance; use TOOL_WHITELIST to limit.
  • Credentials are passed via environment variables; ensure secure configuration.
  • Remote spec downloads can be slow or fail, causing startup issues (mitigated by caching).
  • Some clients have incomplete prompts/resources support; features may be limited.

Troubleshooting

  1. Ensure OPENAPI_SPEC_URL is set to a valid OpenAPI JSON URL or local file path.
  2. Verify the OpenAPI document is standard-compliant.
  3. Check TOOL_WHITELIST matches desired endpoint paths (dot-separated paths need exact match).
  4. Confirm API_KEY and API_AUTH_TYPE are correct (e.g., for Fly.io use Api-Key).
  5. Set DEBUG=true for verbose logging to stderr.

Use cases

Exposing internal or third-party REST APIs (e.g., Slack, Notion, Asana, NetBox) to MCP clients so they can be called via natural language.
Dynamically generating tools in MCP workflows without writing custom code.
Controlling exposed endpoints via whitelist for security and performance.

Supported clients

Claude DesktopPartial support
CodexFull support
GeminiPartial support
QwenPartial support
KilocodePartial support
opencodeFull support
VibePartial support
LettaPartial support