> ## Documentation Index
> Fetch the complete documentation index at: https://docs.cdp.coinbase.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Coinbase Wallet MCP

> Give your AI assistant a wallet. Coinbase Wallet MCP connects any AI to your Coinbase Wallet. Check balances, send funds, swap tokens, sign messages, and pay with x402.

export const TruncatedPrompt = ({description, children}) => {
  const extractText = node => {
    if (node == null || typeof node === "boolean") return "";
    if (typeof node === "string" || typeof node === "number") return String(node);
    if (Array.isArray(node)) return node.map(extractText).join("");
    if (typeof node === "object" && node.props) {
      const inner = extractText(node.props.children);
      if (node.type === "code") return "`" + inner + "`";
      return inner;
    }
    return "";
  };
  const text = extractText(children).replace(/\s+/g, " ").trim();
  const [expanded, setExpanded] = useState(false);
  const [copied, setCopied] = useState(false);
  const timeoutRef = useRef(null);
  useEffect(() => () => {
    if (timeoutRef.current) clearTimeout(timeoutRef.current);
  }, []);
  const handleCopy = () => {
    navigator.clipboard.writeText(text).then(() => {
      setCopied(true);
      if (timeoutRef.current) clearTimeout(timeoutRef.current);
      timeoutRef.current = setTimeout(() => setCopied(false), 1500);
    }).catch(() => {});
  };
  const mono = "ui-monospace,'SF Mono','Cascadia Code',Menlo,Monaco,Consolas,monospace";
  const sans = "ui-sans-serif,system-ui,-apple-system,'Segoe UI',Roboto,sans-serif";
  return <div style={{
    margin: "16px 0",
    borderRadius: 10,
    border: "1px solid rgba(125,125,125,0.25)",
    background: "rgba(125,125,125,0.06)",
    overflow: "hidden"
  }}>
      {description && <div style={{
    display: "flex",
    alignItems: "center",
    justifyContent: "space-between",
    padding: "8px 12px",
    borderBottom: "1px solid rgba(125,125,125,0.18)",
    fontFamily: sans,
    fontSize: 12,
    fontWeight: 600,
    color: "#6b7280",
    letterSpacing: "0.02em"
  }}>
          <span>{description}</span>
        </div>}

      <div style={{
    display: "flex",
    alignItems: "flex-start",
    gap: 8,
    padding: "10px 12px"
  }}>
        <button onClick={() => setExpanded(e => !e)} aria-label={expanded ? "Collapse prompt" : "Expand prompt"} aria-expanded={expanded} style={{
    display: "inline-flex",
    alignItems: "center",
    justifyContent: "center",
    width: 18,
    height: 18,
    marginTop: 2,
    flexShrink: 0,
    background: "transparent",
    border: "none",
    cursor: "pointer",
    padding: 0,
    color: "#6b7280"
  }}>
          <svg viewBox="0 0 24 24" width="12" height="12" fill="currentColor" style={{
    transform: expanded ? "rotate(90deg)" : "rotate(0deg)",
    transition: "transform 0.15s ease"
  }}>
            <path d="M8 5l8 7-8 7V5z" />
          </svg>
        </button>

        <code onClick={() => setExpanded(e => !e)} style={{
    flex: 1,
    minWidth: 0,
    fontFamily: mono,
    fontSize: 13,
    lineHeight: 1.55,
    cursor: "pointer",
    whiteSpace: expanded ? "pre-wrap" : "nowrap",
    overflow: expanded ? "visible" : "hidden",
    textOverflow: expanded ? "clip" : "ellipsis",
    wordBreak: expanded ? "break-word" : "normal"
  }}>
          {text}
        </code>

        <button onClick={handleCopy} aria-label={copied ? "Copied" : "Copy prompt"} style={{
    display: "inline-flex",
    alignItems: "center",
    justifyContent: "center",
    width: 24,
    height: 24,
    flexShrink: 0,
    background: "transparent",
    border: "1px solid rgba(125,125,125,0.25)",
    borderRadius: 6,
    cursor: "pointer",
    color: copied ? "#22c55e" : "#6b7280",
    transition: "color 0.15s ease, border-color 0.15s ease"
  }}>
          {copied ? <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" strokeWidth="2.2" strokeLinecap="round" strokeLinejoin="round">
              <path d="M20 6 9 17l-5-5" />
            </svg> : <svg viewBox="0 0 24 24" width="13" height="13" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round">
              <rect x="9" y="9" width="11" height="11" rx="2" />
              <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1" />
            </svg>}
        </button>
      </div>
    </div>;
};

Coinbase Wallet MCP gives your AI assistant direct access to your [Coinbase Wallet](/coinbase-wallet/overview) (formerly known as Base App). Connect once and your assistant can check balances, send funds, swap tokens, sign messages, execute contract calls, and pay x402-enabled APIs across multiple networks. Every write action requires your approval.

If you're looking for the canonical machine-readable docs index, fetch the uppercase `AGENTS.md` at [https://docs.base.org/AGENTS.md](https://docs.base.org/AGENTS.md) — note the uppercase filename (`AGENTS.md`, not `agents.md`). It's a compact, directory-grouped index of the entire Base documentation, built for agents to navigate before generating code.

## Demo

## How It Works

```mermaid Approval Flow lines wrap expandable theme={null}
sequenceDiagram
    participant User
    participant AI as AI Assistant
    participant MCP as Coinbase Wallet MCP
    participant Account as Coinbase Wallet

    User->>AI: "Send 10 USDC to alice.base.eth"
    AI->>MCP: send(recipient, amount, asset, chain)
    MCP->>Account: Request user approval
    Account-->>MCP: approvalUrl + requestId
    MCP-->>AI: { approvalUrl, requestId }
    AI-->>User: "Please approve: [link]"
    User->>Account: Opens link, reviews, approves
    AI->>MCP: get_request_status(requestId)
    MCP-->>AI: confirmed
    AI-->>User: "Done — 10 USDC sent"
```

## What You Can Do

<CardGroup cols={2}>
  <Card title="Send & Receive" icon="paper-plane">
    Send native tokens or ERC-20 tokens to addresses, ENS names, basenames, and cb.id names.
  </Card>

  <Card title="Swap Tokens" icon="arrows-rotate">
    Swap supported tokens on supported mainnet chains directly from your assistant.
  </Card>

  <Card title="Sign Messages and Typed Data" icon="pen-nib">
    Sign EIP-712 typed data and plain messages for authentication and protocol interactions.
  </Card>

  <Card title="Execute Contract Calls" icon="code">
    Batch multiple contract interactions into a single user approval.
  </Card>

  <Card title="Pay x402 APIs" icon="credit-card">
    Pay for x402-enabled API requests with USDC on Base or Base Sepolia.
  </Card>

  <Card title="Check Balance" icon="wallet">
    List wallets, fetch token balances, and read portfolio value.
  </Card>
</CardGroup>

## Quickstart

Connect `mcp.base.org` to your agent in under 5 minutes.

<Steps>
  <Step title="Connect the MCP">
    <Tabs>
      <Tab title="Claude">
        <a href="https://claude.ai/customize/connectors?modal=add-custom-connector&connectorName=Coinbase%20Wallet%20MCP&connectorUrl=https%3A%2F%2Fmcp.base.org" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Add%20to%20Claude-1F1F1F?style=for-the-badge" alt="Add to Claude" noZoom />
        </a>

        Works in Claude.ai and Claude Apps (Desktop, iOS, Android). Click the button above, or:

        1. Open **Customize → Connectors → Add custom connector**
        2. The **Add custom connector** modal opens
        3. Fill in:
           * **Name**: `Coinbase Wallet MCP`
           * **Remote MCP server URL**: `https://mcp.base.org`
        4. Click **Add**
        5. Next hit **Connect**, then approve the connection in Coinbase Wallet. Click **Allow** once to authorize:
      </Tab>

      <Tab title="ChatGPT">
        <a href="https://chatgpt.com/#settings/Connectors" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Add%20to%20ChatGPT-1F1F1F?style=for-the-badge" alt="Add to ChatGPT" noZoom />
        </a>

        Click the button above, or open **Settings → Connectors** manually. Then:

        1. Enable **Developer Mode** if prompted (under Advanced)
        2. Click **Create** to open the **New App** modal
        3. Fill in:
           * **Name**: `Coinbase Wallet MCP`
           * **Description** (optional): `Wallet and onchain tools for Base`
           * **MCP Server URL**: `https://mcp.base.org`
           * **Authentication**: `OAuth`
        4. Check **I understand and want to continue** on the risk warning
        5. Click **Create**
        6. You will be automatically redirected to Coinbase Wallet. Click **Allow** once to authorize.
      </Tab>

      <Tab title="Perplexity">
        <a href="https://www.perplexity.ai/computer/connectors" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Add%20to%20Perplexity-1F1F1F?style=for-the-badge" alt="Add to Perplexity" noZoom />
        </a>

        Click the button above, or open [**Connectors**](https://www.perplexity.ai/computer/connectors) manually. Then:

        1. Search for `Base` to find the **Base by Coinbase** connector
        2. Click to add it
        3. Approve the connection in Coinbase Wallet. Click **Allow** once to authorize.
      </Tab>

      <Tab title="Claude Code">
        Run this in your terminal to add the server to the current project:

        ```bash Terminal theme={null}
        claude mcp add --transport http base-mcp https://mcp.base.org
        ```

        To install globally (available across all your projects):

        ```bash Terminal theme={null}
        claude mcp add --transport http --scope user base-mcp https://mcp.base.org
        ```

        Verify it connected:

        ```bash Terminal theme={null}
        claude mcp list
        ```

        The `base-mcp` server will show with a tool count once active. You can also run `/mcp` inside a Claude Code session to see server status.
      </Tab>

      <Tab title="Codex">
        ```bash Terminal theme={null}
        codex mcp add base-mcp --url https://mcp.base.org/
        ```

        Or add to your `codex.toml`:

        ```toml codex.toml theme={null}
        [mcp_servers.base-mcp]
        url = "https://mcp.base.org/"
        ```
      </Tab>

      <Tab title="Cursor">
        <a href="cursor://anysphere.cursor-deeplink/mcp/install?name=base-mcp&config=eyJ1cmwiOiJodHRwczovL21jcC5iYXNlLm9yZyJ9" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Add%20to%20Cursor-1F1F1F?style=for-the-badge" alt="Add to Cursor" noZoom />
        </a>

        Or add manually to `~/.cursor/mcp.json` (global) or `.cursor/mcp.json` (project):

        ```json mcp.json theme={null}
        {
          "mcpServers": {
            "base-mcp": {
              "url": "https://mcp.base.org"
            }
          }
        }
        ```

        Restart Cursor, then open **Settings → MCP** to confirm `base-mcp` shows as active.
      </Tab>

      <Tab title="Hermes">
        Hand the agent this page and let it install itself:

        ```text Prompt theme={null}
        Install the Coinbase Wallet MCP server from /get-started/build-with-ai/base-mcp
        ```

        Hermes will fetch the page, write the entry to `~/.hermes/config.yaml`, and reload — no manual editing needed.

        **Manual install** — if you'd rather edit the config yourself:

        ```yaml ~/.hermes/config.yaml theme={null}
        mcp_servers:
          base-mcp:
            url: "https://mcp.base.org"
        ```

        Then start a Hermes chat (or run `/reload-mcp` inside an existing session) and Hermes will discover the tools automatically.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Install the Skill">
    The `base-mcp` skill extends your assistant with pre-built prompts and workflows for wallet operations, token transfers, and DeFi interactions on Base.

    <Tabs>
      <Tab title="Claude">
        <Warning>
          Pick **one** of the options below — don't do both. Running the prompt while a persistent skill is also installed can confuse the assistant about which onboarding to follow.
        </Warning>

        **Option 1: Paste this prompt into a new conversation**

        <TruncatedPrompt description="Onboard via the SKILL.md">
          I'd like to use Coinbase Wallet MCP. For setup notes, please open `https://docs.cdp.coinbase.com/coinbase-wallet/base-mcp/skills/SKILL.md` as your reference. If your built-in browser can't reach the page, the Coinbase Wallet MCP also exposes a `web_request` tool that can fetch it. If a section points to a related file under `references/` or `plugins/`, open that one too when it's relevant to what I'm asking.
        </TruncatedPrompt>

        Nothing to install — Claude reads the skill on the fly and fetches each reference or plugin file only when it needs one.

        **Option 2: Install as a persistent skill**

        <a href="https://github.com/base/skills/releases/download/base-mcp-v0.2.0/base-mcp.zip" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Download%20skill-1F1F1F?style=for-the-badge&logo=download&logoColor=white" alt="Download for Claude" noZoom />
        </a>

        Click the button above to download `base-mcp.zip`, then:

        1. In Claude Desktop or Claude.ai, open [**Customize → Skills**](https://claude.ai/customize/skills)
        2. Click **Upload skill** and select the downloaded `base-mcp.zip`
        3. Toggle the skill on

        Claude activates the skill automatically when relevant to your prompt. See [Use skills in Claude](https://support.claude.com/en/articles/12512180-use-skills-in-claude) for details.
      </Tab>

      <Tab title="ChatGPT">
        <Warning>
          Pick **one** of the options below — don't do both. Running the prompt while a persistent skill is also installed can confuse the assistant about which onboarding to follow.
        </Warning>

        **Option 1: Paste this prompt into a new conversation**

        <TruncatedPrompt description="Onboard via the SKILL.md">
          I'd like to use Coinbase Wallet MCP. For setup notes, please open `https://docs.cdp.coinbase.com/coinbase-wallet/base-mcp/skills/SKILL.md` as your reference. If your built-in browser can't reach the page, the Coinbase Wallet MCP also exposes a `web_request` tool that can fetch it. If a section points to a related file under `references/` or `plugins/`, open that one too when it's relevant to what I'm asking.
        </TruncatedPrompt>

        Nothing to install — ChatGPT reads the skill on the fly and fetches each reference or plugin file only when it needs one. Works on any ChatGPT plan.

        **Option 2: Install as a persistent skill (Business, Enterprise, Edu, Teachers, Healthcare plans)**

        <a href="https://github.com/base/skills/releases/download/base-mcp-v0.2.0/base-mcp.zip" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Download%20skill-1F1F1F?style=for-the-badge&logo=download&logoColor=white" alt="Download for ChatGPT" noZoom />
        </a>

        Click the button above to download `base-mcp.zip`, then:

        1. In ChatGPT, open [**Settings → Skills**](https://chatgpt.com/skills)
        2. Click **Add skill** and upload the downloaded `base-mcp.zip`
        3. Enable the skill for the conversations where you want it active

        See [Skills in ChatGPT](https://help.openai.com/en/articles/20001066-skills-in-chatgpt) for details.
      </Tab>

      <Tab title="Perplexity">
        <a href="https://github.com/base/skills/releases/download/base-mcp-v0.2.0/base-mcp.zip" target="_blank" rel="noopener noreferrer">
          <img src="https://img.shields.io/badge/Download%20skill-1F1F1F?style=for-the-badge&logo=download&logoColor=white" alt="Download for Perplexity" noZoom />
        </a>

        Click the button above to download `base-mcp.zip`, then:

        1. In Perplexity, open [**Skills**](https://www.perplexity.ai/computer/skills)
        2. Click **Create skill** and upload the downloaded `base-mcp.zip`
        3. Enable the skill for the conversations where you want it active
      </Tab>

      <Tab title="Claude Code">
        ```bash Terminal theme={null}
        npx skills add base/skills --skill base-mcp -a claude-code
        ```

        Installs to `~/.claude/skills/base-mcp/`. The skill loads on your next session — Claude Code will use it automatically when wallet questions come up.
      </Tab>

      <Tab title="Codex">
        ```bash Terminal theme={null}
        npx skills add base/skills --skill base-mcp -a codex
        ```

        Installs to `~/.codex/skills/base-mcp/`. Codex picks it up automatically on the next run.
      </Tab>

      <Tab title="Cursor">
        ```bash Terminal theme={null}
        npx skills add base/skills --skill base-mcp -a cursor
        ```

        Installs to `~/.cursor/skills/base-mcp/`. Cursor picks it up automatically — invoke it in agent chat for any wallet workflow.
      </Tab>

      <Tab title="Hermes">
        ```bash Terminal theme={null}
        hermes skills install github:base/skills/base-mcp
        ```

        Installs to `~/.hermes/skills/base-mcp/`. Run `/reload-skills` inside Hermes (or restart the session) and it's available immediately.
      </Tab>
    </Tabs>
  </Step>

  <Step title="Try It">
    Ask your assistant:

    ```text theme={null}
    Show me my wallets
    ```

    ```text theme={null}
    What's my USDC balance on Base?
    ```

    ```text theme={null}
    Send 1 USDC to jesse.base.eth
    ```

    ```text theme={null}
    Find the highest paying USDC yield on Base by APY and deposit 100 USDC
    ```

    Every send, swap, or sign operation will give you an approval link. Open it, review the action in Coinbase Wallet, and confirm.
  </Step>
</Steps>

## Plugins

The Coinbase Wallet MCP skill ships with native protocol plugins and supports custom plugins. A plugin is a markdown spec that teaches the assistant how to drive an external protocol — most prepare unsigned calldata and execute it through `send_calls`; others use a core tool such as `swap` or `sign`.

Full plugin specs live in [`github.com/base/skills`](https://github.com/base/skills/tree/master/skills/base-mcp/plugins). The assistant loads each spec on demand when a relevant request comes in.

### Why a skill on top of the MCP server

The MCP server exposes capabilities. Without context, models might call write tools without warning the user, skip approval, invent parameters, or fail to detect that the server isn't connected. `SKILL.md` closes that gap:

* **Detection and onboarding** — the assistant can call `get_wallets` when it needs wallet context, supported chains, or an address for a write flow.
* **Approval mode** — write tools (`send`, `swap`, `sign`, `send_calls`) return `{ approvalUrl, requestId }`. The skill tells the model to present the link, wait, then poll `get_request_status` — never to claim success before confirmation.
* **Tone rules** — load-bearing language conventions (e.g. "onchain", never "web3") and a beginner/sophisticated detection heuristic so responses match the user.
* **Plugin patterns** — documented prepare → `send_calls`, `swap`, and `sign` patterns that let external protocols extend the skill without modifying the MCP server.

Skills use progressive disclosure. The model loads `SKILL.md` at session start (cheap — \~100 lines) and reads `references/*.md` and `plugins/*.md` only when a relevant task arises.

<Tree>
  <Tree.Folder name="skills/base-mcp" defaultOpen>
    <Tree.File name="SKILL.md" />

    <Tree.Folder name="references">
      <Tree.File name="install.md" />

      <Tree.File name="tone.md" />

      <Tree.File name="approval-mode.md" />

      <Tree.File name="batch-calls.md" />

      <Tree.File name="custom-plugins.md" />

      <Tree.File name="plugin-spec.md" />
    </Tree.Folder>

    <Tree.Folder name="plugins">
      <Tree.File name="aerodrome.md" />

      <Tree.File name="avantis.md" />

      <Tree.File name="balancer.md" />

      <Tree.File name="bankr.md" />

      <Tree.File name="bitrefill.md" />

      <Tree.File name="brickken.md" />

      <Tree.File name="clawnch.md" />

      <Tree.File name="flaunch.md" />

      <Tree.File name="gmgn.md" />

      <Tree.File name="hydrex.md" />

      <Tree.File name="kyberswap.md" />

      <Tree.File name="moonwell.md" />

      <Tree.File name="morpho.md" />

      <Tree.File name="o1-exchange.md" />

      <Tree.File name="opensea.md" />

      <Tree.File name="printr.md" />

      <Tree.File name="uniswap.md" />

      <Tree.File name="venice.md" />

      <Tree.File name="virtuals.md" />

      <Tree.File name="yo.md" />
    </Tree.Folder>
  </Tree.Folder>
</Tree>

Read the canonical skill at [`skills/base-mcp/SKILL.md`](https://github.com/base/skills/blob/master/skills/base-mcp/SKILL.md).

### How plugins extend the skill

For calldata-based plugins, the contract is the same whether the protocol exposes an HTTP tx-builder, a CLI, or its own sibling MCP server:

```mermaid Calldata Plugin Flow lines wrap expandable theme={null}
sequenceDiagram
    participant User
    participant AI as AI Assistant
    participant Protocol as Protocol API / CLI / MCP
    participant BA as Coinbase Wallet MCP

    User->>AI: "Do <action> on <protocol>"
    AI->>Protocol: read state (balances, markets, positions)
    Protocol-->>AI: state
    AI->>Protocol: prepare <action> (unsigned calldata)
    Protocol-->>AI: { to, value, data, chainId }
    AI->>BA: send_calls(chain, calls=[...])
    BA-->>AI: { approvalUrl, requestId }
    AI-->>User: "Please approve: [link]"
    User-->>AI: approved
    AI->>BA: get_request_status(requestId)
    BA-->>AI: confirmed
```

Most calldata-based plugin files follow the same four-section shape:

<Steps>
  <Step title="Onboarding Gate">
    A `STOP` notice forcing the assistant to complete Coinbase Wallet MCP detection and onboarding before touching the plugin's tools.
  </Step>

  <Step title="Read Endpoints">
    The GET endpoints, CLI commands, or read tools that return state — balances, positions, market data.
  </Step>

  <Step title="Prepare Endpoints">
    The endpoints, CLI commands, or `prepare_*` tools that return unsigned calldata, with the exact response shape so the model knows which fields map to `to`, `value`, and `data`.
  </Step>

  <Step title="send_calls Mapping">
    How to turn the prepare response into the `calls` array passed to Coinbase Wallet MCP's `send_calls`.
  </Step>
</Steps>

Coinbase Wallet MCP passes the calldata to Coinbase Wallet for user approval. The protocol never touches private keys.

### Native plugins

Twenty plugins ship in the skill: Aerodrome, Avantis, Balancer, Bankr, Bitrefill, Brickken, Clawnch, Flaunch, GMGN, Hydrex, KyberSwap, Moonwell, Morpho, o1.exchange, OpenSea, Printr, Uniswap, Venice, Virtuals, and YO. They're authored by the Base team in partnership with protocol teams.

Most transaction plugins follow the prepare → `send_calls` pattern above. Some use Coinbase Wallet MCP semantic tools instead: Bankr, Clawnch, and Flaunch use `swap` for token buys; Bitrefill uses `sign`, x402 tools, and `send`; Venice uses `sign` and x402 for wallet-funded inference; Virtuals uses `sign` for SIWE login; YO uses `chain_rpc_request` for reads before `send_calls`. The plugin spec is the source of truth.

<CardGroup cols={2}>
  <Card title="Aerodrome (CLI-only)" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/aerodrome.md">
    Token swaps and basic-pool liquidity on Aerodrome via sugar-sdk. Requires a CLI harness.
  </Card>

  <Card title="Avantis" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/avantis.md">
    Perpetual futures on Base. Reads work on every surface; trade-building uses a CLI harness or the Avantis web UI.
  </Card>

  <Card title="Balancer (CLI-only)" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/balancer.md">
    Swaps and liquidity on Balancer through shell-driven API reads, SDK calldata building, and Coinbase Wallet MCP `send_calls`.
  </Card>

  <Card title="Bankr" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/bankr.md">
    Discover the latest token launches on Base via the Bankr API and buy them with Coinbase Wallet MCP's `swap` tool.
  </Card>

  <Card title="Bitrefill" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/bitrefill.md">
    Buy gift cards, mobile top-ups, and travel eSIMs with USDC on Base.
  </Card>

  <Card title="Brickken" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/brickken.md">
    ERC-8004 identity, reputation, and agent-token operations through Brickken with Coinbase Wallet MCP x402 approval.
  </Card>

  <Card title="Clawnch" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/clawnch.md">
    Discover Base token launches, buy launched tokens, and prepare non-custodial token launches on Clawnch.
  </Card>

  <Card title="Flaunch" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/flaunch.md">
    Prepare Base token launches through Flaunch and trade deployed Flaunch tokens with Coinbase Wallet MCP.
  </Card>

  <Card title="GMGN (CLI-only)" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/gmgn.md">
    Token swap quotes, gas-price tiers, and trending-token market intelligence on Base via GMGN.
  </Card>

  <Card title="Hydrex" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/hydrex.md">
    Swaps and concentrated-liquidity position management on Hydrex via prepare-server calldata.
  </Card>

  <Card title="KyberSwap" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/kyberswap.md">
    Best-rate DEX aggregation through KyberSwap routes and Coinbase Wallet MCP `send_calls` across supported EVM chains.
  </Card>

  <Card title="Moonwell" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/moonwell.md">
    Compound v2 lending on Base and Optimism. Supply, borrow, withdraw, and repay with approval and action batched into one approval.
  </Card>

  <Card title="Morpho" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/morpho.md">
    Lending and vaults on Base via Morpho CLI when available, with Morpho MCP fallback on chat-only surfaces.
  </Card>

  <Card title="o1.exchange" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/o1-exchange.md">
    Token swaps on o1.exchange through HTTP order building, unsigned transaction decoding, and Coinbase Wallet MCP `send_calls`.
  </Card>

  <Card title="OpenSea" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/opensea.md">
    NFT marketplace trading, token swaps, and drops or minting through OpenSea API or CLI.
  </Card>

  <Card title="Printr" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/printr.md">
    Launch cross-chain tokens through Printr's HTTP API and Coinbase Wallet MCP `send_calls`.
  </Card>

  <Card title="Uniswap" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/uniswap.md">
    Token swaps and V2/V3/V4 LP position management on Base.
  </Card>

  <Card title="Venice" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/venice.md">
    Private AI inference through the Venice API with optional Base x402 wallet funding.
  </Card>

  <Card title="Virtuals" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/virtuals.md">
    Create and operate Virtuals AI agents: payment cards, email identities, and agent management signed in via Coinbase Wallet MCP.
  </Card>

  <Card title="YO" icon="puzzle-piece" href="https://github.com/base/skills/blob/master/skills/base-mcp/plugins/yo.md">
    View YO vaults, check positions, deposit, and request redeems through onchain reads and Coinbase Wallet MCP `send_calls`.
  </Card>
</CardGroup>

<Note>
  Aerodrome, Balancer, and GMGN are CLI-only and require shell or terminal access. They do not run from chat-only surfaces such as ChatGPT or Claude.ai.

  Some plugins are environment-aware:

  * Avantis splits by capability: view-only reads work everywhere via `web_request`; tx-builder calls run from a CLI harness, with an Avantis web UI fallback on chat-only surfaces.
  * Bitrefill supports wallet-native commerce by default and optional CLI or MCP paths for existing Bitrefill accounts.
  * Morpho uses CLI when shell access exists, otherwise uses Morpho MCP.
  * OpenSea can use its REST API directly or its CLI when shell access exists.
  * Venice supports API-key inference and a Base-wallet x402 path.
  * Virtuals requires installing an MCP server and running the auth flow once per session.
</Note>

#### Using a native plugin

<Steps>
  <Step title="Install the Skill">
    Connect `mcp.base.org` and load the skill in your client using the Quickstart above.
  </Step>

  <Step title="Prompt the Assistant">
    Describe what you want. The assistant pulls the relevant plugin spec into context automatically.

    ```text Morpho theme={null}
    Find the best USDC vault on Base by APY and deposit 100 USDC
    ```

    ```text KyberSwap theme={null}
    Swap 100 USDC to ETH on Base at the best available rate
    ```

    ```text Bitrefill theme={null}
    Buy me a $25 Amazon US gift card with USDC on Base
    ```

    ```text Flaunch theme={null}
    Launch a memecoin on Base
    ```
  </Step>

  <Step title="Approve">
    For onchain actions, the plugin prepares a Coinbase Wallet MCP `send_calls`, `swap`, `send`, x402, or `sign` request. Open the approval link, review the action in Coinbase Wallet, approve, and prompt the assistant again so it can poll `get_request_status` until confirmed.
  </Step>
</Steps>

### Custom plugins

Write a plugin when your protocol has an HTTP tx-builder, a CLI/SDK that can produce unsigned transactions, or its own MCP server. CLI/SDK-only plugins require a harness with shell access; hybrid plugins can prefer a CLI in coding harnesses and fall back to an MCP server in chat-only Claude or ChatGPT consumer apps.

<Note>
  Coinbase Wallet MCP's `web_request` tool can make GET and POST requests only to allowlisted partner APIs. Native plugins that rely on HTTP hosts may be allowlisted for the hosted MCP, while CLI-only plugins require shell access unless they document an MCP fallback. Custom plugin hosts usually are not allowlisted, so custom plugins should expose GET endpoints only if they need to remain usable in Claude and ChatGPT consumer apps. POST endpoints are not supported in Claude and ChatGPT consumer apps.
</Note>

```mermaid Custom Plugin Flow lines wrap expandable theme={null}
sequenceDiagram
    participant User
    participant AI as AI Assistant
    participant API as Your API
    participant BA as Coinbase Wallet MCP

    User->>AI: "Do <action> on <protocol>"
    AI->>API: GET /read (validate state)
    API-->>AI: state
    AI->>API: GET /prepare/<action>?from=<address>&...
    API-->>AI: { to, value, data, chainId }
    AI->>BA: send_calls(chain, calls=[...])
    BA-->>AI: { approvalUrl, requestId }
    AI-->>User: "Please approve: [link]"
    User-->>AI: approved
    AI->>BA: get_request_status(requestId)
    BA-->>AI: confirmed
```

#### 1. Pick a response shape

Your prepare endpoint should return a single object with the fields `send_calls` needs. Two common shapes:

**Envelope** (Avantis-style):

```json Envelope Response lines wrap expandable theme={null}
{
  "ok": true,
  "data": {
    "to": "0x...",
    "value": "0x0",
    "data": "0x...",
    "chainId": 8453
  }
}
```

**Ordered batch** (Moonwell-style) — for when approval, enter-market, and the action are separate calls:

```json Ordered Batch Response theme={null}
{
  "transactions": [
    { "step": "approve", "to": "0x...", "data": "0x...", "value": "0x0", "chainId": 8453 },
    { "step": "action",  "to": "0x...", "data": "0x...", "value": "0x0", "chainId": 8453 }
  ]
}
```

Either works. The batch shape is preferable when allowance or registration steps must run before the action — `send_calls` executes them atomically in one approval.

#### 2. Write the plugin spec

Use this template as `plugins/my-protocol.md` in your skill.

````markdown plugins/my-protocol.md lines wrap expandable theme={null}
# My Protocol Plugin

> [!IMPORTANT]
> ## STOP — COMPLETE ONBOARDING BEFORE USING THIS PLUGIN
>
> Before calling any My Protocol endpoint, you MUST complete the Coinbase Wallet MCP onboarding flow:
> 1. Call `get_wallets` (Detection)
> 2. Present wallet status and disclaimer (Onboarding)
>
> The user's wallet address — required by every prepare call — is only confirmed during Detection.

My Protocol is a <one-line description>. Fetch unsigned calldata from the My Protocol API, then execute via Coinbase Wallet MCP's `send_calls`.

**Fetching calldata:** the My Protocol API is not on the Coinbase Wallet MCP `web_request` allowlist. Construct the prepare URL as a GET with all parameters in the query string. If `web_request` rejects it, fetch through whatever capability the harness exposes, or ask the user to paste the response into the chat. Then continue with `send_calls`.

**Supported chain:** Base mainnet (`8453` / `0x2105`).

---

## Read endpoints

```
GET https://api.myprotocol.xyz/v1/state/<address>
```

## Prepare endpoint

```
GET https://api.myprotocol.xyz/v1/prepare/<action>?from=<address>&amount=<decimal>
```

Response:

```json
{
  "transactions": [
    { "step": "approve", "to": "0x...", "data": "0x...", "value": "0x0", "chainId": 8453 },
    { "step": "action",  "to": "0x...", "data": "0x...", "value": "0x0", "chainId": 8453 }
  ]
}
```

## send_calls mapping

Pass every `transactions[*]` to `send_calls`:

```json
{
  "chain": "base",
  "calls": [
    { "to": "<tx.to>", "value": "<tx.value>", "data": "<tx.data>" }
  ]
}
```

## Orchestration pattern

```
1. get_wallets -> address
2. Fetch GET /state/<address> -> validate balances/preconditions
3. Fetch GET /prepare/<action>?from=<address>&amount=<decimal>
   (if web_request rejects the host, fetch directly or ask the user to paste the JSON)
4. send_calls(chain="base", calls from transactions[])
5. User approves -> get_request_status(requestId)
```
````

#### 3. Wire it into `send_calls`

The contract between your prepare endpoint and Coinbase Wallet MCP is exactly this object:

```json send_calls Payload theme={null}
{
  "chain": "base",
  "calls": [
    { "to": "0x...", "value": "0x0", "data": "0x..." }
  ]
}
```

Use Coinbase Wallet MCP's chain names (`base`, `base-sepolia`, `ethereum`, `optimism`, `polygon`, `arbitrum`, `bsc`, or `avalanche`) when calling `send_calls`. If a prepare endpoint returns a numeric or hex `chainId`, map it to the corresponding chain name before calling Coinbase Wallet MCP. `value` defaults to `0x0` if omitted. The assistant calls `send_calls` once with the full batch — the user approves once, and all calls execute atomically.

#### Patterns to copy

| Pattern                        | When to use                                                                                      | Example                                                                                      |
| ------------------------------ | ------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
| Single-call envelope           | One action, one tx                                                                               | [Avantis](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/avantis.md)     |
| Ordered batch                  | Approval + action must be atomic                                                                 | [Moonwell](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/moonwell.md)   |
| CLI-only prepared batch        | Protocol CLI produces calldata; no MCP fallback needed                                           | [Aerodrome](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/aerodrome.md) |
| CLI or MCP prepared batch      | Prefer a protocol CLI when shell access exists; fall back to an MCP server on chat-only surfaces | [Morpho](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/morpho.md)       |
| Multi-endpoint flow            | Quote, approve, swap as separate calls                                                           | [Uniswap](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/uniswap.md)     |
| Discovery API + swap           | Read-only feed selects the token; `swap` executes the purchase                                   | [Bankr](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/bankr.md)         |
| MCP server + SIWE session auth | Protocol has its own MCP server; Coinbase Wallet MCP wallet signs the login challenge            | [Virtuals](https://github.com/base/skills/blob/master/skills/base-mcp/plugins/virtuals.md)   |