# MCP API Translator [Health: Active]

**Category:** 💻 Developer Tools  
**Repository:** https://github.com/krishgok/mcp-api-translator  
**GitHub Stars:** 1  
**Views:** 0  
**Installs:** 0  
**Upvotes:** 0  
**Directory Page:** https://allmcps.com/mcp/mcp-api-translator

## Description
Turn OpenAPI / Postman specs into runnable MCP servers, or serve any API as live MCP tools.

## Claude Desktop Quick Installation
Install path detected from listing signals. Uses `npx` (confidence: high):

```json
"mcpServers": {
  "mcp-api-translator": {
    "command": "npx",
    "args": ["-y","mcp-api-translator"]
  }
}
```

## Documentation

## What MCP API Translator does

MCP API Translator MCP server converts API descriptions into tools that MCP-compatible agents can call. It accepts OpenAPI 3.0, OpenAPI 3.1, and Postman collection definitions in JSON or YAML, supplied either inline or from a local file.

The project supports two workflows. Generation creates a normal TypeScript or Python project with per-tool source files, environment-based authentication, a Dockerfile, server metadata, and client configuration guidance. Runtime serving exposes API operations directly without creating generated files. The generated project is intended for teams that want to inspect, edit, build, and self-host the resulting server.

The tool belongs in the Developer Tools category and is useful when an existing API specification is the source of truth for agent access. It also supports combining multiple API definitions into one MCP server while keeping each API's credentials separate.

## How it works

Start with `analyze_spec` to inspect the operations that would become tools. Filtering options include HTTP methods, tags, path patterns, and excluded operations. This preview step helps reduce an oversized tool set before any project files are written; the server also warns when a generated server exceeds 40 tools.

`generate_mcp_server` writes a complete project to the selected output directory. Choose TypeScript by default or request Python, and select stdio or HTTP transport where supported by the generation options. `extend_mcp_server` adds another specification to an existing project and is idempotent, preserving hand-edited tool files. The `serve` command uses the same request planning and environment-based authentication approach as generated output, but runs as a proxy instead.

For runtime serving, stdio is the default transport. Stateless Streamable HTTP can be selected with the HTTP transport option and a port. Structured logs are written to stderr, with JSON lines in containers and readable text on a TTY.

## Setup and configuration

No global installation is required. Run the published package with Node 20 or newer through `npx -y mcp-api-translator`, or use the documented Docker image when Node is not available. Claude Code, Claude Desktop, Cursor, Cline, and Continue can register the process with their MCP configuration formats. Restart the client after changing MCP configuration because settings are read at startup.

Generated projects include `.env.example`; copy it to `.env` and provide the API base URL and credentials required by the source API. Credentials are not embedded in generated code. When APIs are combined, each API can read namespaced variables derived from its title, with the generated summary and example environment file showing the exact names. Docker users must mount host directories when specifications need to be read from disk or projects need to be written outside the container.

## Tools and capabilities

The MCP API Translator MCP server provides four primary tools:

- `analyze_spec` previews proposed tools, authentication information, and required environment variables without writing files.
- `generate_mcp_server` creates a runnable TypeScript or Python MCP project.
- `extend_mcp_server` appends operations from another specification to an existing project.
- `list_supported_features` reports supported formats, authentication schemes, transports, and limits.

The command-line runtime can also load multiple specifications, apply method filters, and serve the resulting operations directly.

## Limitations and notes

This project is designed for generated code that can be owned and maintained, rather than a temporary in-memory wrapper. Large specifications may produce too many tools for reliable agent selection, so curation is recommended. The generated server still requires its dependencies to be installed, built, configured with the source API's credentials, and started before an agent can use it.

The license is AGPL-3.0, with a commercial license also available according to the repository materials. A Docker deployment requires explicit volume mounts for host-side files. API responses shown in the project demonstration are illustrative and do not establish access to the referenced third-party accounts.

_Full upstream README: https://allmcps.com/mcp/mcp-api-translator/readme_