Apideck

npm version MCP Registry Glama score CI License: MIT

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

330 tools across 10 unified APIs:

Workflow tools

On top of the 330 endpoint tools, the server ships intent-grouped workflows — single MCP tools that orchestrate 2-4 underlying calls behind a high-level intent. Saves agents the round-trips and the field-plumbing they routinely get wrong (AR vs AP, allocation arrays, customer vs supplier refs).

Workflows propagate Vault OAuth elicitations (so a missing connection still hands the user a consent URL) and surface upstream errors with failingStep so the agent knows which leg broke. See docs/authoring-workflow-tools.md for the pattern.

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 (.mcpb plugin bundle)

Apideck ships a Claude plugin bundle (.mcpb — Anthropic's Model Context Protocol Bundle format). Drop it into Claude Desktop and you get the full server (330 endpoint tools + 4 workflow tools) with API key / consumer ID / app ID prompted via the standard plugin UI.

# Build the bundle locally:
npm run mcpb:build      # → mcp-server.mcpb (~590 KB)

Or grab a prebuilt bundle from the latest GitHub Release. Open it with Claude Desktop's plugin installer; Claude Desktop reads manifest.json to wire credentials and spawn the server.

Claude Desktop / Cursor / Windsurf (manual config)

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 330 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: all unified APIs except SMS (330 tools)
python generate-overlay.py accounting,ats,connector,crm,ecommerce,fileStorage,hris,issueTracking,proxy,vault,webhook

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

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

# All APIs including SMS (~334 tools)
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

Contributing

The repo ships a .mcp.json with two project-scope MCP servers that Claude Code / Cursor / Windsurf pick up automatically:

No credentials are committed — each entry reads its token from the environment.

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.

{
  "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 

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

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

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

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_input: Returns the input schema for one or more tools by name.
• execute_tool: Executes a tool by name with its arguments.
• 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
    }
  }
}