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: the wallet it pays from

Two ways. If you already hold USDC on Algorand, the first one is a single line of config and you are done.

You already have a funded Algorand account

Put its 25 words in BOTTRUNK_MNEMONIC and there is nothing else to do — no wallet file, no ALGO, no opt-in, no terminal. The agent pays from that account, within the caps you set.

{
  "mcpServers": {
    "bottrunk": {
      "command": "npx",
      "args": ["-y", "bottrunk-mcp"],
      "env": {
        "BOTTRUNK_MNEMONIC": "word1 word2 … word25",
        "BOTTRUNK_MAX_PER_CALL": "100000000000"
      }
    }
  }
}

Use an account you funded for this and nothing else. Those words are the account, they sit in a config file in plain text, and some clients write their environment to a log. Put in it only what you are willing to let an agent spend.

Any Algorand wallet can create one — Defly, Pera — and it needs to hold USDC (asset 31566704) plus a little ALGO for the minimum balance.

To get both on the Algorand network: Kraken, Coinbase or Binance (not for US residents) withdraw ALGO and USDC on Algorand, and Pera Fund sells USDC on Algorand by card. OKX, Bitso and KuCoin send only the ALGO.

You are starting from nothing

Add the server with no environment at all. It creates a wallet the first time it starts — written to ~/.bottrunk/wallet.json (mode 0600), never leaving the machine; BotTrunk only ever sees a signed transfer. Then ask your agent "what is my BotTrunk wallet?" and it answers with the address and exactly what is missing.

# the wallet already exists once the server has started; this just shows it
npx bottrunk-mcp wallet

# 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.

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 either way: BOTTRUNK_MAX_PER_CALL and BOTTRUNK_MAX_PER_DAY, in USDC. The server refuses anything above them before it signs. Set them: the catalog goes up to $5000.00 a call.

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: "100000000000"

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