Log inSubmit server
Mcpify logo

Mcpify

Converts OpenAPI 3.x specifications into MCP tools for calling REST APIs through stdio or HTTP.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install Mcpify

Pick your client, then add it in one click or paste the config.

STDIOPython
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "mcpify": {
      "command": "uvx",
      "args": [
        "--from",
        "mcpify-openapi",
        "mcpify"
      ]
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

We couldn’t confirm it starts correctly

The install command installed and started the server, which then stopped for configuration (such as an API key) that our sandbox does not have — expected for servers that connect to your account.

uvx --from mcpify-openapi mcpify

Process exited before answering initialize.

This is an experimental automated check and can have false negatives — missing environment variables, a slow cold install, etc. It doesn’t necessarily mean something’s wrong. Last checked 7d ago.

Overview

The mcpify MCP server converts OpenAPI 3.x specifications into MCP tools that agents can use to call REST APIs. It generates input schemas from parameters and request bodies, resolves internal references, and supports local stdio or shared Streamable HTTP transport. Use it when an API has an OpenAPI description and needs to be exposed to an MCP-compatible client. Optional controls cover authentication, read-only access, redaction, response projection, caching, retries, rate limits, auditing, and metrics.

Use cases

  • Expose an OpenAPI-described internal API to an MCP client
  • Preview generated tools and their context cost before deployment
  • Validate API specifications for agent-facing problems in CI
  • Restrict agents to read-only or explicitly allowed operations
  • Serve multiple REST APIs through one MCP endpoint

Key features

  • OpenAPI 3.x to MCP tool generation
  • Stdio and Streamable HTTP transports
  • Bearer, basic, header, query, and OAuth2 authentication
  • Read-only, allow/deny, and per-token RBAC controls
  • Response projection, truncation, and secret redaction
  • Caching, retries, rate limits, metrics, and audit records

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked 3d ago

Recent health check succeeded.

6/6 checks healthy over the last 41d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 15d ago via OSV.dev · mcpify-openapi (PyPI)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars2Stargazers on the source repository.
Last commit1mo agoMost recent push to the default branch.
Install checkRunsOur sandbox started it; it then asked for an API key or config.
Directory activity1 viewsConfig copies, upvotes, and views on AllMCPs.

How Mcpify works

What mcpify does

The mcpify MCP server turns an OpenAPI 3.x document into an MCP tool surface. Each operation in the specification becomes a callable tool, with input schemas derived from its parameters and request body. Internal $ref references are resolved while the tool definitions are built.

The source specification can be a local file or a URL. A single configuration can expose several APIs through one MCP server, with collision-safe tool renaming and separate settings for authentication, caching, retries, filters, and rate limits. YAML specifications require the optional YAML extra; the core runtime uses Python’s standard library.

The CLI also supports inspecting and validating the generated surface before serving it. list shows available operations and can estimate their context cost. doctor checks for issues such as missing operation IDs or summaries and can probe the upstream API. diff compares two specifications, identifies changed operations, and can fail when breaking changes are found.

How the mcpify MCP server works

At startup, mcpify reads the OpenAPI document and exposes the resulting operations through MCP. Calls are sent to the corresponding REST endpoints using the URL and authentication settings supplied at runtime. Credentials are read from environment variables rather than stored in the specification or passed into model-visible tool definitions.

Local clients can use stdio. For shared access, serve --http PORT provides MCP Streamable HTTP, returning SSE when requested by a client and JSON otherwise. HTTP access can be protected with bearer tokens. Multiple upstream APIs can be served together, and status checks their health in parallel.

The server can reduce context and response size with lazy tool loading, field projection, and structurally valid truncation. It can cache using ETags, retry idempotent requests for selected gateway errors, honor Retry-After for rate limiting, and apply per-upstream request limits. Audit records contain the tool, API, status, latency, and an argument fingerprint rather than raw arguments.

Setup and configuration

Install the mcpify-openapi package with pipx, run it on demand with uvx, install from source, or use the published container image. The basic command is:

bash
mcpify serve https://example.com/openapi.json

mcpify init can create a configuration file. The --base-url option overrides the API location. Authentication supports bearer, basic, header, and query styles, with the common style selected from the specification. OAuth2 client credentials are also supported; access tokens are fetched, cached, refreshed, and retried once after a mid-request 401 response.

Read and write access can use separate credentials. --read-only removes mutating operations, while allow and deny filters and per-token RBAC provide additional surface controls. The --redact option masks values whose keys identify secrets, including values in error responses.

Tools and capabilities

  • Generate MCP tools from OpenAPI operations.
  • Preview tools and estimate their context cost with list --cost.
  • Test calls from a terminal with try.
  • Serve a schema-shaped mock API for CI with mock.
  • Create a shareable serving script with output-server.
  • Expose metrics, OpenTelemetry spans, health probes, and a local dashboard when enabled.
  • Hot-reload configuration with --reload.

Limitations and notes

The input must be an OpenAPI 3.x specification. Runtime dependencies are not required for the standard installation, but YAML support needs the optional mcpify[yaml] package. Authentication credentials must be supplied through the environment or related runtime configuration; they are not taken from the model or embedded in the specification. HTTP sharing, OAuth2, redaction, observability, and other operational controls are optional rather than required for a basic stdio deployment.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about Mcpify

mcpify is an MCP server that connects AI agents to REST APIs described by OpenAPI 3.x documents. It turns API operations into MCP tools, generates input schemas, and supports calling those tools over stdio or Streamable HTTP, with optional authentication, access controls, redaction, caching, and request limits.

Install it with pipx, run it on demand with uvx, install from source, or use the published container image. The package is named mcpify-openapi; for example, `pipx install mcpify-openapi` installs the `mcpify` command.

Run `mcpify serve path/to/openapi.json` to expose the specification as MCP tools. Use `mcpify list` first to preview the generated operations, and add `--base-url` when the API endpoint differs from the URL declared in the document.

Set the credential in an environment variable and pass it with `--auth-env`; mcpify can select bearer, basic, header, or query authentication from the specification. OAuth2 client credentials use the OAuth2 token URL and environment variables for the client ID and secret.

Yes. mcpify exposes standard MCP transports, and the README names Cursor as a supported client. Use stdio for a local setup or Streamable HTTP when sharing the server over a network.

Related MCP servers

All in Developer Tools All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewMcpify AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/mcpify?style=directory)](https://allmcps.com/mcp/mcpify)
HTML Embed
<a href="https://allmcps.com/mcp/mcpify"><img src="https://allmcps.com/api/badge/mcpify?style=directory" alt="Mcpify on AllMCPs" /></a>