BotTrunk
Sell an API Connect agent

Connect your agent

Two ways in. The remote endpoint takes no install and lets an agent browse the catalog, price a deposit and check an order — free, read-only. The local package adds a wallet, so the agent can actually buy: it runs on your machine, signs with a key only you control, and refuses anything above the caps you set.

Remote: nothing to install

One URL, https://mcp.bottrunk.com/mcp, speaking MCP over Streamable HTTP. Any client that takes a remote server can add it — including ChatGPT and Claude on the web, which run in the cloud and cannot start a local command at all.

claude mcp add --transport http bottrunk https://mcp.bottrunk.com/mcp

Five free tools: bottrunk_catalog, bottrunk_service, bottrunk_payment_instructions, bottrunk_quote_deposit, bottrunk_order_status.

No key, no account, no spending. A hosted server can't hold your wallet, so it can tell an agent what a call costs and how to pay for it, but it can never pay on your behalf.

An agent that can sign its own transfers works straight from bottrunk_payment_instructions: it returns the live price, network, asset and payTo for a service, and the agent answers the endpoint's 402 itself.

Local: the agent pays for itself

Everything below sets up bottrunk-mcp, which adds one paid tool per live service and settles each call from the agent's own wallet.

First: give the agent a wallet

Do this once, wherever the agent runs. The key is written to ~/.bottrunk/wallet.json (mode 0600) and never leaves the machine — BotTrunk only ever sees a signed transfer.

npx bottrunk-mcp wallet   # creates the wallet, prints the address and what to send

# then two sends from your own wallet, in this order:
#   1. 0.3 ALGO to that address
#   2. the USDC you want this agent to be able to spend
#
# The USDC opt-in in between happens by itself on the first tool call.

The shortcut: already have a funded Algorand account? Put its 25 words in BOTTRUNK_MNEMONIC and none of the above applies — no file, no ALGO dance, no opt-in. Create and fund it in Defly like any other account.

Or one approval instead of two sends: npx bottrunk-mcp wallet fund --from <your address> --usdc 5 builds a single atomic group — fund, opt in, deliver USDC — and checks it against real chain state before anyone signs. All three land or none do.

Why the ALGO. An Algorand account needs 0.1 ALGO to exist and another 0.1 to hold an asset, and only the key holder can opt in — so nobody can do it for the agent, and USDC sent before the opt-in does not arrive, it fails. The 0.3 leaves something over for fees.

Spending caps travel with the config: BOTTRUNK_MAX_PER_CALL and BOTTRUNK_MAX_PER_DAY, in USDC. The server refuses anything above them before it signs.

Package and options on npm →

Then: point your client at it

Every snippet below comes from that client's own documentation. Same server, same tools, twelve different ways of spelling it.

Claude Code

CLI

One command. claude mcp list shows it connected.

claude mcp add bottrunk -- npx -y bottrunk-mcp

Add --scope user to make it available in every project instead of just this one. Claude Code docs →

Claude Desktop

Desktop app

Settings → Developer → Edit Config, then restart the app.

{
  "mcpServers": {
    "bottrunk": { "command": "npx", "args": ["-y", "bottrunk-mcp"] }
  }
}

macOS: ~/Library/Application Support/Claude/claude_desktop_config.json · Windows: %APPDATA%\Claude\claude_desktop_config.json. Claude Desktop docs →

Cursor

Editor

Global in ~/.cursor/mcp.json, or per project in .cursor/mcp.json.

{
  "mcpServers": {
    "bottrunk": { "command": "npx", "args": ["-y", "bottrunk-mcp"] }
  }
}

Settings → MCP shows the tools once the server starts. Cursor docs →

VS Code (GitHub Copilot)

Editor

The key here is servers, not mcpServers.

{
  "servers": {
    "bottrunk": { "type": "stdio", "command": "npx", "args": ["-y", "bottrunk-mcp"] }
  }
}

Or in one line: code --add-mcp '{"name":"bottrunk","command":"npx","args":["-y","bottrunk-mcp"]}'. Use it from Agent mode. VS Code (GitHub Copilot) docs →

Cline

Editor extension

MCP Servers panel → Configure, or the file directly.

{
  "mcpServers": {
    "bottrunk": {
      "command": "npx", "args": ["-y", "bottrunk-mcp"],
      "disabled": false, "autoApprove": []
    }
  }
}

Leave autoApprove empty so you see each paid call before it runs. Cline docs →

Windsurf (Cascade)

Editor

Cascade → MCP servers → Configure, then refresh.

{
  "mcpServers": {
    "bottrunk": { "command": "npx", "args": ["-y", "bottrunk-mcp"] }
  }
}

Windsurf reads the file on refresh; you do not need to restart the editor. Windsurf (Cascade) docs →

Zed

Editor

Settings → AI → MCP Servers → Add Local Server, or edit settings directly.

{
  "context_servers": {
    "bottrunk": { "command": "npx", "args": ["-y", "bottrunk-mcp"], "env": {} }
  }
}

Zed calls them context servers; open the file with zed: open settings file. Zed docs →

OpenClaw

Personal agent

Add it once; the agent picks the tools up on its next run.

openclaw mcp add bottrunk \
  --command npx \
  --arg -y \
  --arg bottrunk-mcp

openclaw mcp doctor bottrunk --probe

Or in the config file under mcp.servers.bottrunk with transport: "stdio" and enabled: true. OpenClaw docs →

Hermes Agent

Personal agent

Add the server to the config, then hermes chat — tools are discovered at startup.

mcp_servers:
  bottrunk:
    command: "npx"
    args: ["-y", "bottrunk-mcp"]
    env:
      BOTTRUNK_MAX_PER_CALL: "0.50"

Hermes passes through only the env you list, so put your caps there. Hermes Agent docs →

Goose

CLI agent

goose configure → Add Extension → Command-Line Extension.

goose configure
# Add Extension → Command-Line Extension
#   name:    bottrunk
#   command: npx -y bottrunk-mcp

# or in ~/.config/goose/config.yaml:
# extensions:
#   bottrunk:
#     name: BotTrunk
#     cmd: npx
#     args: [-y, bottrunk-mcp]
#     type: stdio
#     enabled: true

Goose spells the command cmd and the environment envs. Goose docs →

OpenAI Agents SDK

Framework

Spawn the server as a stdio subprocess and hand it to the agent.

from agents import Agent, Runner
from agents.mcp import MCPServerStdio

async with MCPServerStdio(
    name="BotTrunk",
    params={"command": "npx", "args": ["-y", "bottrunk-mcp"]},
) as server:
    agent = Agent(
        name="Buyer",
        instructions="Use BotTrunk when you need data or real-world work.",
        mcp_servers=[server],
    )
    result = await Runner.run(agent, "Scrape https://example.com/pricing to markdown.")
    print(result.final_output)

pip install openai-agents. The wallet lives on the machine running the SDK. OpenAI Agents SDK docs →

LangChain / LangGraph

Framework

Load the tools into any LangChain agent or LangGraph node.

# pip install langchain-mcp-adapters
from langchain_mcp_adapters.client import MultiServerMCPClient

client = MultiServerMCPClient({
    "bottrunk": {
        "command": "npx",
        "args": ["-y", "bottrunk-mcp"],
        "transport": "stdio",
    }
})
tools = await client.get_tools()

There is a JavaScript build too: @langchain/mcp-adapters. LangChain / LangGraph docs →

Something else?

Anything that speaks MCP over stdio works: the command is always npx -y bottrunk-mcp. And nothing forces you to use MCP at all — the endpoints are plain HTTP with an x402 paywall, so curl, Python or TypeScript work the same way.

Running somewhere that can't spawn a local command — ChatGPT, Claude on the web, a hosted agent platform? Add https://mcp.bottrunk.com/mcp as a custom connector for discovery, and let the agent pay the endpoint directly with its own wallet.

Read the protocol docs

What your agent gets

From the local package: bottrunk_catalog to see what exists and what it costs, bottrunk_wallet for the balance and today's spend, plus one paid tool per live service. From the remote endpoint: the same catalog, live quotes and order status, without a wallet. Ask it "what can you buy on BotTrunk?" to start.

See the catalog