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 and it can browse the marketplace, create a wallet, buy agents, and run them for you in plain English.

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

Then ask in plain English:

"Create a wallet, fund it, browse the marketplace, and run an agent for me on chain 8453."

Your assistant creates a wallet, handles the USDC payment, picks an agent, signs for you, and hands back the result — the whole loop, no dashboards. 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.buyer__create_wallet({}) and codemode.public__browse_marketplace({chainId: 8453}). 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 vs managed wallet 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 (for example bring-your-own-signer or local-signer setups), connect to the raw mounts instead of Code Mode. Platform-managed wallet-mcp mounts sign payments for you but do not include no-auth discovery tools — add api-mcp/public as a second server. api-mcp/{buyer|maker|credentials} includes discovery automatically.

See Advanced: bring your own signer for the api-mcp 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

No wallet needed — this call is free:

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

If your assistant returns a list of agents, you're connected. Now create a wallet and run one.

How Code Mode works

Code Mode is stateless across calls. Each request is independent; the server does not remember your wallet between conversations.

When your assistant runs generated code through the code tool:

1. create_wallet returns a keyId and Base address. Your assistant or you must retain that keyId (wallet key, format wk_…) for every later buyer, maker, or credentials call.
2. Production funding happens between calls — transfer Base USDC to the returned address through an external wallet or on-ramp before purchasing or running agents.
3. Later calls pass keyId explicitly to wallet-backed methods such as buyer__purchase_service or maker__register_service.
4. import_wallet, export_wallet, and delete_wallet remain available on every wallet namespace.
5. fund_caller_wallet funds the existing prepaid caller-wallet rail — it does not initially fund a newly created managed wallet with Base USDC.

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

async () => {  const created = await codemode.buyer__create_wallet({});  const wallet = created.structuredContent;  if (created.isError || !wallet || typeof wallet.keyId !== "string") return created;  return codemode.buyer__get_address({keyId: wallet.keyId});}

Signed vs anonymous reads: generated code cannot attach per-call MCP _meta in Code Mode 0.4.3. public__get_service, public__check_execution, and public__check_settlement therefore return anonymous or reduced views. For signed, wallet-scoped reads, use the matching Wallet namespace — for example buyer__get_service with keyId.

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.

Platform limits: the hosting platform enforces an approximately 6,000-token selected-result limit and a 32-invocation ceiling per request. Code Mode adds no lower tool-call or spend ceiling on top of those platform constraints. One outer code tool still embeds declarations for 101 namespaced methods; current schemas are roughly 19,000 prompt tokens before TypeScript generation. Code Mode reduces intermediate-result context, not declaration context.

Quick start (buyer)

1. Create a wallet

"Create a wallet on indie.money."

You'll receive a wallet key (format wk_Ab3xY9z2k) and an Ethereum address. This is a managed (custodial) wallet — the platform securely holds the key and signs payments on your behalf for convenience. Guard the wallet key like a password: anyone who has it can move these funds. Save it in a password manager; it's the only way back to this wallet. For true self-custody, where your key never leaves your machine, use the bring-your-own-wallet path instead — see Advanced: bring your own signer.

2. Fund it

Get USDC into your wallet — buy it with a credit card through the on-ramp, or send USDC on Base. That wallet USDC pays for agent purchases and passes directly. To run agents without signing each call, optionally deposit some into your prepaid balance — see Prepaid balance. (Purchases, agent budgets, and your prepaid balance are separate — funding one doesn't credit another.)

3. Browse and use

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

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

"Purchase service 0x1234… with wk_Ab3xY9z2k on chain 8453."

Your assistant handles payment and on-chain signing automatically.

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 from wk_Ab3xY9z2k 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: wallet management (create_wallet, import_wallet, export_wallet, delete_wallet, get_address), execute_service (webhooks already know their chain), and the stateless utilities (convert_workflow, validate_workflow_nodes, check_node_support).

Wallet management

Your wallet lives on indie.money's platform, keyed by a short ID starting with wk_. These tools are available on every wallet namespace (buyer, maker, credentials).

Your wallet key is the sole handle to your funds — by design. Keep it in a password manager. If you delete a wallet, withdraw first, or the tokens are stranded.

Checking balances

"Check the USDC balance of wk_Ab3xY9z2k on chain 8453."

"Check the prepaid balance of wk_Ab3xY9z2k on chain 8453."

Withdrawing to USDC

"Withdraw $50 to USDC for wk_Ab3xY9z2k 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… with wk_Ab3xY9z2k 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 with wk_Ab3xY9z2k 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 with wk_Ab3xY9z2k on chain 8453."

4. Register a webhook

"Register a webhook for service 0x1234… token 1 with wk_Ab3xY9z2k 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\"} using wk_Ab3xY9z2k."

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, with wk_Ab3xY9z2k 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 for wk_Ab3xY9z2k on chain 8453."

"List service 0x1234… on the marketplace with wk_Ab3xY9z2k 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 for wk_Ab3xY9z2k on chain 8453."

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

Favorites, categories, referrals

Favorites

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

Categories

"Set my category assignments to {\"0x1234…\":\"research\"} with wk_Ab3xY9z2k 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

The mounts above (wallet-mcp) hold an encrypted key and sign payments for you. If you'd rather keep your key material entirely on your side, connect to the api-mcp gateway instead — it signs nothing and never holds a wallet:

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, browsing/discovery tools live on api-mcp/public and are not on wallet-mcp/{buyer|maker|credentials} — add the public mount as a second server. Publishing tools need the maker mount; credential tools need credentials; buying/running need buyer.

"Wallet not found" — Check the wallet key. They start with wk_ and are case-sensitive. Code Mode is stateless — pass the same keyId on every wallet-backed call.

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

"Insufficient balance" — Your prepaid balance is empty. Fund with a credit card or deposit USDC on Base, then purchase an agent or fund a budget.

"Signer does not match registrant" — The wallet you're using must be the one that registered the service.

Payment required error with x402/error details — You called a paid tool without a wallet key. Add the wallet key, or sign the payment yourself and retry (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.