MCP Server

NoHoldPay runs a hosted Model Context Protocol (MCP) server so AI agents can work with your account as tools instead of raw HTTP. An agent connected to it can create a payment, spin up a payment link, draft an invoice, and read status, all from a natural-language prompt. It is the same merchant API you already use, exposed to Claude, Cursor, Codex, and other MCP clients.

It is non-custodial like the rest of the platform. The agent creates and reads payment records through your key. It never holds funds and cannot move money.

Endpoint

The server is remote and hosted by us. There is nothing to download, install, or run locally. You connect a client by pointing it at the URL and supplying your API key as the Authorization header. Every client below does this in its own config format.

Before you connect

Tools

The server exposes your merchant API as these tools. Read tools are annotated read-only. Mutating tools are marked so a client can ask for confirmation before running them.

Payments, links, and invoices

Account and reference

Every result is tagged with the key's mode (test or live). Actions that create, cancel, or settle payments carry a live-funds label when run with a live key. Invoice send and resend, which email your customer, do not carry the label. To keep an agent from touching wallet material, the MCP surface never goes beyond the API-key surface: get_prepaid_credit is a read-only view of your platform-fee credit and is pinned to the key's mode (a pk_test_ key can never read your live credit). Wallet material, top-up provisioning, and account settings are not exposed.

Prompts

The server also ships guided prompts that drive the agent through a task using the tools above in the right order:

In Claude Code these appear as slash commands (for example /mcp__noholdpay__reconcile_payment). Other clients surface them in a prompt or command picker.

Connect your tool

Each example uses an environment variable NOHOLDPAY_API_KEY holding your key. Set it in your shell first:

export NOHOLDPAY_API_KEY="pk_test_your_key_here"

Claude Code

Add the server with one command. Use --scope user to make it available in every project, or --scope project to share it with your team through a checked-in .mcp.json.

claude mcp add --transport http noholdpay https://mcp.noholdpay.com/mcp \
  --header "Authorization: Bearer $NOHOLDPAY_API_KEY"

Or configure it in a project .mcp.json. The type field is required for a remote server, and ${NOHOLDPAY_API_KEY} is expanded from the environment so the key stays out of the file:

{
  "mcpServers": {
    "noholdpay": {
      "type": "http",
      "url": "https://mcp.noholdpay.com/mcp",
      "headers": { "Authorization": "Bearer ${NOHOLDPAY_API_KEY}" }
    }
  }
}

Cursor

Add the server to ~/.cursor/mcp.json (global) or a project .cursor/mcp.json. Remote servers use url and headers, with ${env:VAR} interpolation:

{
  "mcpServers": {
    "noholdpay": {
      "url": "https://mcp.noholdpay.com/mcp",
      "headers": { "Authorization": "Bearer ${env:NOHOLDPAY_API_KEY}" }
    }
  }
}

Then enable the server in Cursor Settings > MCP. You can also generate a one-click Add to Cursor deeplink of the form cursor://anysphere.cursor-deeplink/mcp/install?name=noholdpay&config=<base64>, where <base64> encodes the inner server object. Do not put a live key in a shared deeplink.

Codex CLI

Recent Codex versions support remote streamable-HTTP servers natively. Add the server and point it at an environment variable for the bearer token:

codex mcp add noholdpay --url https://mcp.noholdpay.com/mcp \
  --bearer-token-env-var NOHOLDPAY_API_KEY

This writes an entry to ~/.codex/config.toml. You can also add it directly. Codex reads the token from the named environment variable and sends it as Authorization: Bearer <value>:

[mcp_servers.noholdpay]
url = "https://mcp.noholdpay.com/mcp"
bearer_token_env_var = "NOHOLDPAY_API_KEY"

If your Codex build only recognizes local (command-based) servers and errors on the entry above, upgrade Codex. Native remote support shipped in late 2025.

Claude Desktop and Claude.ai

On a Team or Enterprise workspace, an organization admin can add a custom connector under Settings > Connectors > Add custom connector, enter https://mcp.noholdpay.com/mcp, and supply the API key as a request header. Header-based auth for custom connectors is currently in beta, and the key is entered once by the admin and shared across the workspace.

For a Claude Desktop app that only accepts local servers in claude_desktop_config.json, use the community mcp-remote bridge, which runs a small local process that forwards to our endpoint and injects the header:

{
  "mcpServers": {
    "noholdpay": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.noholdpay.com/mcp",
        "--header",
        "Authorization: Bearer ${NOHOLDPAY_API_KEY}"
      ],
      "env": { "NOHOLDPAY_API_KEY": "pk_test_your_key_here" }
    }
  }
}

Claude Desktop cannot read your shell environment, so the key has to live in this file's env block. Keep it a pk_test_ key, and never commit or share the file.

VS Code (GitHub Copilot)

Add the server to .vscode/mcp.json. The inputs block prompts you for the key on first connect and stores it securely, so it never sits in the file:

{
  "inputs": [
    {
      "type": "promptString",
      "id": "noholdpay-key",
      "description": "NoHoldPay API key (pk_test_ or pk_live_)",
      "password": true
    }
  ],
  "servers": {
    "noholdpay": {
      "type": "http",
      "url": "https://mcp.noholdpay.com/mcp",
      "headers": { "Authorization": "Bearer ${input:noholdpay-key}" }
    }
  }
}

The tools are then available in Copilot Agent mode.

Other clients

Any client that supports a remote streamable-HTTP MCP server with a custom Authorization header can connect the same way: point it at https://mcp.noholdpay.com/mcp and send Authorization: Bearer <your key>. This covers Windsurf, Zed, Cline, and the OpenAI Responses and Agents APIs (which accept a headers field on the hosted MCP tool).

The one exception today is the ChatGPT consumer app. Its custom-connector UI supports only OAuth or no authentication, not a static API-key header, so a pk_ key cannot be added there directly. Developers building on the OpenAI API can still pass the key as a header on the API's MCP tool.

Verify the connection

Once the server is added, ask the agent something read-only to confirm it works:

"Using NoHoldPay, list the chains and coins I can accept."

The agent calls list_chains and returns your enabled chains for the key's mode. Then try a test-mode action:

"Create a NoHoldPay payment for 5 USD and give me the checkout link."

The agent calls create_payment and returns the hosted checkout URL. Open it to see the live checkout. No blockchain address is derived until the customer picks a chain on that page.

Notes

• The key is required on every request. The server is stateless, so a client that sends the Authorization header only on the first request will fail on later calls. All configs above set the header per request.
• Mode follows the key. A pk_test_ key only ever sees test data, and a pk_live_ key only ever sees live data. There is no cross-mode access.
• A 401 means the key is missing or wrong. Check that the header is Authorization: Bearer pk_... and that the key is active in the dashboard.
• Live keys during rollout. MCP is being rolled out on test keys first. Connect with a pk_test_ key to start. See the auth reference for the current posture.