Connect Claude, Cursor & ChatGPT to indie.money (MCP)

indie.money lets you rent automation agents by the run — no subscription, no monthly minimum, no lock-in. Pay a few cents in stablecoins only when an agent actually does work for you, own what you buy, and walk away any time. Builders publish workflows as agents; anyone can purchase, own, and run them.

Every operation is exposed over the Model Context Protocol (MCP) — the open standard Claude, ChatGPT, Cursor, and other AI assistants use to talk to external tools. Connect your assistant once, complete OAuth with your wallet, add Credits, and browse, buy, and run agents in plain English. The platform never creates or stores a private key for you.

Run your first agent

Add one server to Claude Code — the recommended Code Mode endpoint:

claude mcp add --transport http indie-money https://mcp.indie.money

Your client starts OAuth when it first needs identity (browser wallet sign-in). Then ask in plain English:

"Browse the marketplace and run an agent for me on chain 8453."

If a paid step needs Credits, your assistant points you at the fund page; after you add Credits, retry. New to MCP? Per-client setup is in Connect your assistant below.

Choose your endpoint

Recommended: connect to Code Mode at a single URL. One endpoint exposes every indie.money MCP operation through four fixed namespaces — public, buyer, maker, and credentials — so you never register multiple servers or worry about missing discovery tools.

URL: https://mcp.indie.money

Your assistant sees one outer tool named code. Generated scripts call namespaced methods on a codemode facade — for example codemode.public__browse_marketplace({chainId: 8453}) and codemode.buyer__purchase_service({…}). You do not need to memorize these; ask in plain English and your assistant composes the right calls.

indie.money runs on Base (chain 8453) with real stablecoin.

Comparing all connection options (Code Mode + OAuth + Credits vs local signer vs your own code)? See Which MCP Endpoint Should I Use?.

Advanced: direct raw mounts

If you need direct access to individual MCP servers (bring-your-own-signer or local-signer setups), connect to raw api-mcp mounts instead of Code Mode. These mounts are BYO signer only — the gateway holds no key and signs nothing; your client handles 402 challenges. api-mcp/{buyer|maker|credentials} includes discovery tools automatically; use api-mcp/public for discovery-only.

Code Mode uses OAuth + Credits. api-mcp never holds a key. See Advanced: bring your own signer for the raw gateway path.

Connect your assistant

indie.money is a remote MCP server — your client connects to it over the web (no download, no local process). Add one server pointed at the Code Mode URL below. Examples use production; staging is https://mcp-staging.indie.money.

Claude Desktop

Claude Desktop connects to remote servers as custom connectors. Open Settings → Connectors → Add custom connector, name it indie-money, and point it at:

https://mcp.indie.money

Restart Claude Desktop and the code tool appears.

Claude Code

Add from the terminal:

claude mcp add --transport http indie-money https://mcp.indie.money

Or commit it to a project so your team shares it (.mcp.json in the repo root):

{  "mcpServers": {    "indie-money": {      "type": "http",      "url": "https://mcp.indie.money"    }  }}

Cursor

~/.cursor/mcp.json (global) or .cursor/mcp.json (per project):

{  "mcpServers": {    "indie-money": {      "url": "https://mcp.indie.money"    }  }}

opencode

opencode.json, under the mcp block ("type": "remote"):

{  "$schema": "https://opencode.ai/config.json",  "mcp": {    "indie-money": {      "type": "remote",      "url": "https://mcp.indie.money",      "enabled": true    }  }}

VS Code (Copilot agent mode)

.vscode/mcp.json, under servers ("type": "http"):

{  "servers": {    "indie-money": {      "type": "http",      "url": "https://mcp.indie.money"    }  }}

Any other MCP-capable client (Windsurf, Gemini CLI, Zed, …) follows the same pattern — register one remote/HTTP server at the Code Mode URL. Prefer the /mcp (HTTP) form over any /sse variant; SSE is a deprecated transport.

Confirm it's connected

Discovery is free:

"Browse the indie.money marketplace on chain 8453."

If your assistant returns a list of agents, you're connected. Complete OAuth if prompted, add Credits when a paid step asks, then run an agent.

How Code Mode works

Code Mode is stateless across calls. Your OAuth access token (held by the MCP client after browser login) identifies you on every request. The server does not store a private key for you.

When your assistant runs generated code through the code tool:

1. OAuth — the client sends Authorization: Bearer … from your wallet login. No keyId, no platform wallet tools.
2. Credits — paid buyer/maker steps spend Credits tied to your wallet. If balance is low, the tool tells you to open the fund page, add Credits, and retry.
3. Namespaces — generated code calls codemode.<surface>__<tool>(…) (for example buyer__purchase_service, maker__register_service).
4. No managed keystore — there is no create_wallet / import_wallet / export_wallet / delete_wallet on Code Mode.

Each nested tool result is wrapped in a McpResultEnvelope. Generated code must inspect the nested isError flag before using structuredContent:

async () => {  const listed = await codemode.public__browse_marketplace({chainId: 8453});  if (listed.isError) return listed;  return listed;}

Signed vs anonymous reads: generated code cannot attach per-call MCP _meta in Code Mode. public__get_service, public__check_execution, and public__check_settlement return anonymous or reduced views. For wallet-scoped reads, use the matching buyer/maker/credentials method under your OAuth session (for example buyer__get_service).

Sandbox boundaries: generated code has no direct fetch() or connect() access. External effects go only through the fixed codemode facade methods. Arbitrary MCP URLs and dynamic /webhook/:path MCP triggers are out of scope for Code Mode.

Quick start (buyer)

1. Connect and sign in

Add Code Mode (https://mcp.indie.money). When your client needs identity, complete OAuth in the browser with your wallet. That wallet is the only identity the platform knows.

2. Add Credits

Paid runs and purchases spend Credits. When a tool asks you to fund, open the fund page it links (chain is in the URL), confirm with your wallet, then retry. See also Prepaid balance for the prepaid rail on the marketplace Wallet UI.

3. Browse and use

"Browse the indie.money marketplace on chain 8453."

"Get details for service 0x1234… on chain 8453."

"Purchase service 0x1234… on chain 8453."

Your assistant uses your OAuth session; Credits cover paid steps.

Understanding amounts

You don't need to think in crypto units. Tell your assistant a dollar amount — "$10" — and it converts. The table below is just for the curious.

Every price on indie.money is an integer in microtokens (6 decimal places).

Tip: tell your assistant the dollar amount and let it convert:

"Purchase service 0x1234… with $10 on chain 8453."

Specifying the chain

Most commands need a chain ID to know which network you mean.

Always include "on chain 8453" in your requests.

Commands that don't need a chain ID: execute_service (webhooks already know their chain), and the stateless utilities (convert_workflow, validate_workflow_nodes, check_node_support).

Identity and Credits

Identity is your wallet via OAuth — not a platform-generated wk_ key. There is no managed keystore to create, import, export, or delete.

For a local key that never leaves your machine, use Bring Your Own Wallet (x402-proxy) or a raw api-mcp client.

Withdrawing to USDC

"Withdraw $50 to USDC on chain 8453."

Exchange rate is deterministic — no market fluctuation, no price impact. Withdrawal returns exactly 90% in USDC (10% platform fee).

Discovering agents

Discovery tools live in the public namespace. Code Mode includes them automatically — no second server required.

Using an agent end-to-end (buyer)

1. Purchase

"Purchase service 0x1234… on chain 8453."

Mints an NFT representing your ownership. The purchase price is paid in USDC directly from your wallet.

2. Set up credentials (if needed)

Some agents need API keys or OAuth connections (OpenAI, Slack, Google, etc.). They're stored in a Secure Vault — never exposed to the agent code or to you.

"What credentials does service 0x1234… token 1 need on chain 8453?"

API key credentials — submit directly:

"Submit the OpenAI API key sk-… for service 0x1234… token 1 on chain 8453."

OAuth credentials — start a vault session, authorize in a browser, then save the connection:

"Start a vault session for service 0x1234… token 1 with the slackOAuth2Api credential."

Your assistant returns a URL; open it, authorize, then tell your assistant to save the connection.

Test a stored credential:

"Test the credentials for service 0x1234… token 1 on chain 8453."

3. Activate

"Activate service 0x1234… token 1 on chain 8453."

4. Register a webhook

"Register a webhook for service 0x1234… token 1 on chain 8453."

Returns a short webhook path (e.g. a1b2c3d4) — that's what you use to run the agent.

5. Execute

"Run webhook a1b2c3d4 with input {\"city\":\"San Francisco\"}."

The agent runs and returns the result. The execution price (typically cents) is deducted from your prepaid balance.

6. Check results & settlement

"Check execution abc123-def456 on chain 8453."

"Check the settlement for execution abc123-def456 on chain 8453."

Payments settle on-chain in batches every ~5 minutes.

Budget management (owner-pays agents)

Some agents run on the owner-pays model: the owner pre-funds a budget and executions draw from it.

Publishing an agent (builders)

1. Check your agent is compatible

"Validate the nodes in this agent: [paste JSON]."

2. Convert the agent

"Convert this workflow JSON to indie.money TypeScript: [paste JSON]."

Your assistant receives serviceCode and serviceHash back — it passes these into the next step.

3. Register

"Register a new service called 'Weather Bot' for $0.50 per purchase, $0.01 per execution, on chain 8453. Use the code and hash from the last step."

You'll need:

• Name and description
• Pricing — purchase price, execution price, max execution price (microtokens; minimum $0.001 = 1000)
• Agent — the serviceCode + serviceHash from convert_workflow
• Optional: subscription price, OAuth app credentials for users who don't bring their own

4. List on the marketplace

Listing requires a Listing Pass ($2.99, paid in USDC from your wallet):

"Buy a Listing Pass on chain 8453."

"List service 0x1234… on the marketplace on chain 8453."

5. Update metadata later

"Change the description of service 0x1234… to 'Current weather for any city' on chain 8453."

6. Boost for visibility

Boosting features your agent in the Featured section for N days. Each day costs one Boost Pass ($4.99).

"Buy 7 Boost Passes on chain 8453."

"Boost service 0x1234… for 7 days on chain 8453."

Favorites, categories, referrals

Favorites

"What agents does address 0xABC… like on chain 8453?"

Categories

"Set my category assignments to {\"0x1234…\":\"research\"} on chain 8453."

Referral program

Your referral link is generated automatically from your wallet address — no registration needed. Share it from your profile page on indie.money.

Advanced: bring your own signer

Code Mode (https://mcp.indie.money) uses OAuth + Credits — your wallet signs in the browser; the platform never holds a private key. If you want your app or a local proxy to sign each challenge itself, connect to the api-mcp gateway instead:

For production (real funds), this is the recommended setup — see Bring Your Own Wallet.

Call any paid tool without a wallet key and the response comes back as a structured x402 payment challenge:

{  "isError": true,  "_meta": {    "x402/error": {      "x402Version": 2,      "accepts": [{"scheme": "exact", "network": "eip155:8453", "amount": "50000", "asset": "0x…", "payTo": "0x…"}]    }  }}

Your agent inspects _meta['x402/error'], signs the payment with its own wallet (any x402-capable client library works), and retries the same tool call with the signed header. This follows the open x402 payment protocol — no vendor lock-in. It also makes price discovery trivial: call any paid operation without a key to see its cost before committing.

Troubleshooting

"Tool not found" / unknown tool — Confirm you connected to https://mcp.indie.money (Code Mode). If you use direct raw mounts instead, use api-mcp/{buyer|maker|credentials} (discovery included) or api-mcp/public for browse-only. Publishing tools need the maker mount; credential tools need credentials; buying/running need buyer.

OAuth / unauthorized — Complete the browser wallet login when your MCP client prompts. Reconnect if the token expired.

"Unsupported chain ID" — Add "on chain 8453" to your request.

"You do not own this service NFT" — Purchase the service before activating or using it.

Credits / insufficient balance — Add Credits on the fund page your assistant links, or deposit from the marketplace Wallet, then retry.

"Signer does not match registrant" — The OAuth wallet must be the one that registered the service.

Payment required / Credits required — Fund Credits and retry on Code Mode, or sign the x402 challenge yourself on a raw api-mcp / x402-proxy path (see Advanced).

Nested isError: true in Code Mode — Parse the McpResultEnvelope returned inside the outer code result and inspect the nested isError before continuing a multi-step script.

Full tool catalog

Every tool, grouped by namespace → indie.money MCP Tool Catalog.