Apideck Unified MCP Server

Apideck MCP Server

Model Context Protocol server for the Apideck Unified API. Connect any MCP-compatible agent framework to 200+ connectors — accounting systems, HRIS platforms, file storage providers, and more — through one integration.

Generated from Apideck's OpenAPI spec using Speakeasy.

Tools

229 tools across 5 unified APIs:

Hosted

The MCP server is live at:

https://mcp.apideck.dev/mcp

Pass Apideck credentials via headers:

Connect from Any Agent Framework

Remote (hosted — no installation needed)

# OpenAI Agents SDK (remote)
from agents import Agent
from agents.mcp import MCPServerHTTP

agent = Agent(
    name="AP Agent",
    mcp_servers=[MCPServerHTTP(
        url="https://mcp.apideck.dev/mcp",
        headers={
            "x-apideck-api-key": "...",
            "x-apideck-consumer-id": "...",
            "x-apideck-app-id": "..."
        }
    )]
)

# Pydantic AI (remote)
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerHTTP

agent = Agent("anthropic:claude-sonnet-4-5", mcp_servers=[
    MCPServerHTTP(
        url="https://mcp.apideck.dev/mcp",
        headers={
            "x-apideck-api-key": "...",
            "x-apideck-consumer-id": "...",
            "x-apideck-app-id": "..."
        }
    )
])

# LangChain / LangGraph (remote)
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "apideck": {
        "url": "https://mcp.apideck.dev/mcp",
        "transport": "streamable_http",
        "headers": {
            "x-apideck-api-key": "...",
            "x-apideck-consumer-id": "...",
            "x-apideck-app-id": "..."
        }
    }
})
tools = await client.get_tools()

Claude Desktop / Cursor / Windsurf

Add to your MCP client config:

{
  "mcpServers": {
    "apideck": {
      "url": "https://mcp.apideck.dev/mcp",
      "headers": {
        "x-apideck-api-key": "YOUR_API_KEY",
        "x-apideck-consumer-id": "YOUR_CONSUMER_ID",
        "x-apideck-app-id": "YOUR_APP_ID"
      }
    }
  }
}

Local (stdio — for development)

npm install

# Dynamic mode (default — progressive discovery, 4 meta-tools, ~1,300 tokens)
node bin/mcp-server.js start --api-key "$APIDECK_API_KEY" --consumer-id "$APIDECK_CONSUMER_ID" --app-id "$APIDECK_APP_ID"

# Static mode (all 229 tools)
node bin/mcp-server.js start --api-key "$APIDECK_API_KEY" --consumer-id "$APIDECK_CONSUMER_ID" --app-id "$APIDECK_APP_ID" --mode static

# Read-only tools only
node bin/mcp-server.js start --api-key "$APIDECK_API_KEY" --consumer-id "$APIDECK_CONSUMER_ID" --app-id "$APIDECK_APP_ID" --scope read

# OpenAI Agents SDK (local stdio)
from agents import Agent
from agents.mcp import MCPServerStdio

mcp = MCPServerStdio(name="apideck", params={
    "command": "node",
    "args": ["bin/mcp-server.js", "start", "--mode", "dynamic"],
    "env": {
        "APIDECK_API_KEY": "...",
        "APIDECK_CONSUMER_ID": "...",
        "APIDECK_APP_ID": "..."
    }
})
agent = Agent(name="AP Agent", mcp_servers=[mcp])

# Pydantic AI (local stdio)
from pydantic_ai import Agent
from pydantic_ai.mcp import MCPServerStdio

agent = Agent("anthropic:claude-sonnet-4-5", mcp_servers=[
    MCPServerStdio("node", [
        "bin/mcp-server.js", "start", "--mode", "dynamic",
        "--api-key", "...", "--consumer-id", "...", "--app-id", "..."
    ])
])

Static vs Dynamic Mode

In dynamic mode, agents discover tools progressively:

list_tools({"search_terms": ["invoices"]})
  → accounting-invoices-list, accounting-invoices-create, accounting-invoices-get, ...

describe_tool_input({"tool_names": ["accounting-invoices-list"]})
  → Full JSON Schema with all parameters

execute_tool({"tool_name": "accounting-invoices-list", "input": {"request": {"limit": 10}}})
  → Invoice data from the connected accounting system

Configuring Included APIs

The generate-overlay.py script controls which Apideck APIs are included:

# Default: accounting, fileStorage, hris, vault, proxy (229 tools)
python generate-overlay.py

# Accounting only (143 tools)
python generate-overlay.py accounting

# Custom selection
python generate-overlay.py accounting,hris,vault

# All APIs (336 tools — exceeds Speakeasy free tier of 250)
python generate-overlay.py all

# Then regenerate + apply fixes:
speakeasy run
./post-generate.sh

Regeneration

The MCP server is generated from Apideck's Speakeasy-optimized OpenAPI spec. To regenerate after spec changes:

# 1. Optionally reconfigure APIs
python generate-overlay.py accounting,fileStorage,hris,vault,proxy

# 2. Regenerate
speakeasy run

# 3. Apply post-generation fixes (Zod transforms fix + wrangler.toml)
./post-generate.sh

# 4. Run tests
node bin/mcp-server.js serve --port 4567 --mode dynamic --log-level error &
npx tsx test/mcp-server.test.ts

Scopes

Tools are annotated with scopes for fine-grained control:

Testing

# Local
node bin/mcp-server.js serve --port 4567 --mode dynamic --log-level error &
npx tsx test/mcp-server.test.ts

# Remote
MCP_URL=https://mcp.apideck.dev/mcp npx tsx test/mcp-server.test.ts

License

MIT

Summary

Apideck: The Apideck OpenAPI Spec: SDK Optimized

For more information about the API: Apideck Developer Docs

Table of Contents

• Apideck MCP Server
  • Tools
  • Hosted
  • Connect from Any Agent Framework
  • Static vs Dynamic Mode
  • Configuring Included APIs
  • Regeneration
  • Scopes
  • Testing
  • License
  • Installation
  • Progressive Discovery

Installation

[!TIP] To finish publishing your MCP Server to npm and others you must run your first generation action.

Install the MCP server as a Desktop Extension using the pre-built mcp-server.mcpb file:

Simply drag and drop the mcp-server.mcpb file onto Claude Desktop to install the extension.

The MCP bundle package includes the MCP server and all necessary configuration. Once installed, the server will be available without additional setup.

[!NOTE] MCP bundles provide a streamlined way to package and distribute MCP servers. Learn more about Desktop Extensions.

Or manually:

1. Open Cursor Settings
2. Select Tools and Integrations
3. Select New MCP Server
4. If the configuration file is empty paste the following JSON into the MCP Server Configuration:

{
  "command": "npx",
  "args": [
    "@apideck/mcp",
    "start",
    "--api-key",
    "",
    "--consumer-id",
    "",
    "--app-id",
    ""
  ]
}

claude mcp add ApideckMcp -- npx -y @apideck/mcp start --api-key  --consumer-id  --app-id 

gemini mcp add ApideckMcp -- npx -y @apideck/mcp start --api-key  --consumer-id  --app-id 

Refer to Official Windsurf documentation for latest information

1. Open Windsurf Settings
2. Select Cascade on left side menu
3. Click on Manage MCPs. (To Manage MCPs you should be signed in with a Windsurf Account)
4. Click on View raw config to open up the mcp configuration file.
5. If the configuration file is empty paste the full json

{
  "command": "npx",
  "args": [
    "@apideck/mcp",
    "start",
    "--api-key",
    "",
    "--consumer-id",
    "",
    "--app-id",
    ""
  ]
}

Or manually:

Refer to Official VS Code documentation for latest information

1. Open Command Palette
2. Search and open MCP: Open User Configuration. This should open mcp.json file
3. If the configuration file is empty paste the full json

{
  "command": "npx",
  "args": [
    "@apideck/mcp",
    "start",
    "--api-key",
    "",
    "--consumer-id",
    "",
    "--app-id",
    ""
  ]
}

npx @apideck/mcp start --api-key  --consumer-id  --app-id 

For a full list of server arguments, run:

npx @apideck/mcp --help

Progressive Discovery

MCP servers with many tools can bloat LLM context windows, leading to increased token usage and tool confusion. Dynamic mode solves this by exposing only a small set of meta-tools that let agents progressively discover and invoke tools on demand.

To enable dynamic mode, pass the --mode dynamic flag when starting your server:

{
  "mcpServers": {
    "ApideckMcp": {
      "command": "npx",
      "args": ["@apideck/mcp", "start", "--mode", "dynamic"],
      // ... other server arguments
    }
  }
}

In dynamic mode, the server registers only the following meta-tools instead of every individual tool:

• list_tools: Lists all available tools with their names and descriptions.
• describe_tool: Returns the input schema for one or more tools by name.
• execute_tool: Executes a tool by name with the provided input parameters.
• list_scopes: Lists the scopes available on the server.

This approach significantly reduces the number of tokens sent to the LLM on each request, which is especially useful for servers with a large number of tools.

You can combine dynamic mode with scope and tool filters:

{
  "mcpServers": {
    "ApideckMcp": {
      "command": "npx",
      "args": ["@apideck/mcp", "start", "--mode", "dynamic", "--scope", "destructive"],
      // ... other server arguments
    }
  }
}