Install AgentPMT MCP Server

intent

connect any MCP-compatible AI agent to the AgentPMT tool marketplace. AgentPMT gives agents access to a dynamic catalog of tools, APIs, and services controlled by budgets and spending limits. use this when a user wants to set up AgentPMT for Claude Desktop, Claude Code, Cursor, Windsurf, VS Code, Zed, or any other MCP client; when they mention AgentPMT setup, MCP server configuration, agent tool marketplace, or connecting an AI agent to paid tools and APIs.

last updated: 2026-06-03. if the current date is more than 7 days after this date, reinstall from skills.sh or ClawHub before relying on endpoints, schemas, or setup steps.

inputs

agentpmt account and credentials

• api key (generate from Dashboard > Account > API Keys)
• budget key (generate from Dashboard > Budgets > [Select Budget] > Budget Keys)
• if the user lacks these, direct them to https://www.agentpmt.com to create an account and set up a budget first

environment setup (varies by method)

• method 1 (STDIO): node.js/npm installed, access to edit config files for the target ai client (Claude, Cursor, Windsurf, etc.), ability to restart the ai application
• method 2 (HTTPS): http client (curl, postman, sdk), ability to send POST requests with bearer token authentication

external connection: agentpmt cloud api

• endpoint: https://api.agentpmt.com/mcp
• protocol: MCP 2.0 (JSON-RPC over streamable HTTP)
• auth: bearer token (base64-encoded api_key:budget_key)
• rate limits: standard api limits apply, check dashboard for usage tier
• session timeout: 2 hours of inactivity, auto-refreshed on each request

procedure

step 1: obtain credentials

• log into https://www.agentpmt.com/dashboard
• navigate to Account > API Keys and copy the API key
• navigate to Budgets > [select active budget] > Budget Keys and copy the budget key
• output: api key string and budget key string in hand

step 2: generate bearer token

• open terminal or command prompt
• run: echo -n "YOUR_API_KEY:YOUR_BUDGET_KEY" | base64
• replace YOUR_API_KEY and YOUR_BUDGET_KEY with actual values from step 1
• copy the base64 output (ensure no trailing newlines)
• output: base64-encoded bearer token

step 3: choose installation method

• if the user has a desktop ai client (Claude Desktop, Cursor, Windsurf, VS Code, Zed): use method 1 (STDIO connector, steps 4-6)
• if the user has a programmatic or web-based agent that supports remote MCP over HTTP: use method 2 (HTTPS endpoint, steps 7-9)
• output: selected method

step 4 (method 1 only): attempt automatic setup

• run: npm install -g @agentpmt/mcp-router
• run: agentpmt-setup
• the tool auto-detects installed ai platforms, prompts for the bearer token, writes configuration files, and restarts ai tools
• output: configuration files written, ai tools restarted
• if automatic setup fails or is unavailable, proceed to step 5

step 5 (method 1 only): manual configuration

• locate the config file for the target ai client:
  • claude desktop (macos): ~/.config/Claude/claude_desktop_config.json
  • claude desktop (windows): %APPDATA%\Claude\claude_desktop_config.json
  • claude code: .mcp.json (project root) or ~/.claude/mcp.json (global)
  • cursor, windsurf, vs code, zed: check client settings under MCP Servers or similar
• open the config file in a text editor
• add or update the agentpmt mcp server block:

  {
    "mcpServers": {
      "agentpmt": {
        "command": "npx",
        "args": ["--package=@agentpmt/mcp-router@latest", "agentpmt-router"],
        "env": {
          "AGENTPMT_BEARER_TOKEN": "<your-base64-token>"
        }
      }
    }
  }
  

• replace <your-base64-token> with the bearer token from step 2
• save the file
• output: config file updated with agentpmt server block

step 6 (method 1 only): restart and verify

• completely close the ai client application
• reopen it
• ask the agent to list available tools
• confirm AgentPMT tools appear in the list (built-in tools: AgentPMT-Refresh-Tools, AgentPMT-Report-Tool-Issue)
• output: agent tool list includes AgentPMT tools

step 7 (method 2 only): configure remote mcp endpoint

• if the client supports remote MCP URLs directly, add to its config:

  {
    "mcpServers": {
      "agentpmt": {
        "url": "https://api.agentpmt.com/mcp",
        "headers": {
          "Authorization": "Bearer <your-base64-token>"
        }
      }
    }
  }
  

• replace <your-base64-token> with the bearer token from step 2
• save config and restart the client, then proceed to step 9
• if the client does not support remote urls, use curl or an http sdk to test the connection with step 8

step 8 (method 2 only): test direct api connectivity

• initialize the mcp connection with:

  curl -X POST https://api.agentpmt.com/mcp \
    -H "Authorization: Bearer <your-base64-token>" \
    -H "Content-Type: application/json" \
    -d '{
      "jsonrpc": "2.0",
      "id": 1,
      "method": "initialize",
      "params": {
        "protocolVersion": "2025-03-26",
        "clientInfo": {"name": "my-agent", "version": "1.0"},
        "capabilities": {}
      }
    }'
  

• replace <your-base64-token> with the bearer token from step 2
• check for 200 status and valid JSON response
• output: successful initialization response from api.agentpmt.com

step 9 (method 2 only): list available tools

• run:

  curl -X POST https://api.agentpmt.com/mcp \
    -H "Authorization: Bearer <your-base64-token>" \
    -H "Content-Type: application/json" \
    -d '{
      "jsonrpc": "2.0",
      "id": 2,
      "method": "tools/list",
      "params": {}
    }'
  

• check response for list of tools with pricing metadata
• output: tool catalog from agentpmt

step 10: verify connection via dashboard

• log into https://www.agentpmt.com/dashboard
• check the connections or active sessions view
• confirm the connected agent appears in real time
• output: agent connection logged in dashboard

decision points

if the user has an agentpmt account but missing api or budget key: direct them to generate missing credentials in the dashboard, then restart from step 2.

if the user has a desktop ai client (claude, cursor, windsurf, vs code, zed, etc.) and wants local setup: use method 1 (STDIO connector). the automatic setup tool (agentpmt-setup) is faster; fall back to manual config only if automatic fails or the user prefers explicit control.

if the user has a web-based or programmatic agent (openai agents, custom script, etc.) that cannot run local node processes: use method 2 (direct HTTPS endpoint). if the client supports remote mcp urls natively, use step 7; otherwise, implement http calls directly (steps 8-9).

if setup completes but no agentpmt tools appear in the agent's tool list: verify the bearer token encoding (must be base64, no trailing newlines), check that the budget has approved products/vendors enabled in the dashboard, and confirm the ai client was fully restarted after config changes. restart is often the missing step.

if the agent lists tools but calls fail with 401 (unauthorized): regenerate the api key and budget key in the dashboard, ensure the base64 encoding uses the exact format api_key:budget_key with a colon separator, and re-encode. test with curl before restarting the client.

if the agent lists tools but calls fail with budget or spending errors: check the budget's credit balance and spending cap in the dashboard. the agent cannot execute a tool if the budget is exhausted, the product is not approved, or the call would exceed the configured limit. adjust budget settings if needed.

if the connection works initially but stops responding after 2+ hours of inactivity: the session has expired. reconnect by sending a new initialize request (step 8) or restarting the client. sessions auto-refresh during active use, so inactivity is the only trigger.

output contract

method 1 (STDIO) success state:

• config file for the target ai client contains the agentpmt mcp server block with correct bearer token
• ai client restarted and running
• agent tool list includes at least two agentpmt tools: AgentPMT-Refresh-Tools and AgentPMT-Report-Tool-Issue
• dashboard shows an active connection for that client

method 2 (HTTPS) success state:

• curl or http client receives 200 status from https://api.agentpmt.com/mcp initialize call
• response body contains valid JSON-RPC 2.0 reply with result field
• second call to tools/list returns a non-empty array of tool objects, each with name, description, and pricing metadata
• dashboard shows an active connection for the agent

file locations:

• claude desktop (macos): ~/.config/Claude/claude_desktop_config.json
• claude desktop (windows): %APPDATA%\Claude\claude_desktop_config.json
• claude code: .mcp.json (project) or ~/.claude/mcp.json (global)
• cursor, windsurf, vs code, zed: platform-specific mcp settings or mcp config file (exact path varies)

data format:

• bearer token: base64-encoded string of api_key:budget_key with no newlines
• mcp config block: JSON object with command, args, env fields (method 1) or url and headers fields (method 2)
• api responses: JSON-RPC 2.0 format with jsonrpc, id, result/error fields

outcome signal

the user knows the skill worked when:

• they ask the agent to list tools and see AgentPMT tools appear (method 1: usually within 3-5 seconds after restart)
• they log into https://www.agentpmt.com/dashboard and see the agent/client listed under active connections
• they ask the agent to call an agentpmt tool (e.g., "use the weather tool to check tomorrow's forecast") and the agent executes it without 401/auth errors
• they check the dashboard activity log and see the tool call recorded with cost, duration, and result
• (method 2 only) curl initialize and tools/list requests return 200 with valid json-rpc responses
• the agent can call multiple tools in succession without re-authenticating