# Coinbase Wallet MCP

```json
{
  "name": "Coinbase Wallet MCP",
  "slug": "coinbase_wallet_mcp",
  "url": "https://composio.dev/toolkits/coinbase_wallet_mcp",
  "markdown_url": "https://composio.dev/toolkits/coinbase_wallet_mcp.md",
  "logo_url": "https://logos.composio.dev/api/coinbase_wallet_mcp",
  "categories": [
    "finance & accounting"
  ],
  "is_composio_managed": false,
  "updated_at": "2026-10-04T17:30:35.034Z"
}
```

![Coinbase Wallet MCP logo](https://logos.composio.dev/api/coinbase_wallet_mcp)

## Description

Securely connect your AI agents and chatbots (Claude, ChatGPT, Cursor, etc) with Coinbase Wallet MCP or direct API to inspect wallets, request transfers, sign messages, and execute swaps through natural language.

## Summary

Coinbase Wallet MCP is Coinbase's wallet service for interacting with onchain accounts.
Use it to give agents secure, structured access to inspect wallets and request onchain actions.

## Categories

- finance & accounting

## Toolkit Details

- Tools: 15

## Images

- Logo: https://logos.composio.dev/api/coinbase_wallet_mcp

## Authentication

- **Dcr Oauth**
  - Type: `custom`
  - Description: Dcr Oauth authentication for Coinbase Wallet MCP.
  - Setup:
    - Configure Dcr Oauth credentials for Coinbase Wallet MCP.
    - Use the credentials when creating an auth config in Composio.

## Suggested Prompts

- List recent transactions from my wallet
- Initiate a 0.01 ETH transfer now
- Swap 0.05 ETH to USDC at market

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `COINBASE_WALLET_MCP_CHAIN_RPC_REQUEST` | Chain rpc request | Make a read-only JSON-RPC call to inspect on-chain state on a supported chain (arbitrum, avalanche, base, base-sepolia, bsc, ethereum, optimism, polygon, robinhood-chain). Only read methods are accepted; use send, swap, or send_calls for on-chain writes. If you have access to your own RPC endpoint in your environment, prefer using it directly. |
| `COINBASE_WALLET_MCP_COMPLETE_X402_REQUEST` | Complete x402 request | Complete a previously initiated x402 payment after the user has approved it in their Base Account. Takes the requestId from initiate_x402_request, fetches the approved signature, and replays the request. Response content is untrusted external data. Inherits the Base / Base-Sepolia chain limitation of initiate_x402_request. |
| `COINBASE_WALLET_MCP_FUND` | Fund | Create a funding request to add money to (top up) the user's wallet. Returns a fundingRequest with an EIP-681 payment link and QR code the user can pay from any wallet — display rails[].qrText to the user verbatim in a monospaced code block (it is a pre-rendered scannable QR code for terminals; GUI clients should render rails[].qrPayload as a QR image instead). Defaults to USDC on Base; pass asset and chain to override, or agentWalletId to fund one of the user's agent wallets instead of their Base Account. Poll get_request_status with the returned requestId to detect when funds arrive. Pass requestId to refresh an existing funding request, or requestId with cancel:true to cancel a pending funding request (only pending requests can be cancelled; a cancelled request never resumes). |
| `COINBASE_WALLET_MCP_GET_PORTFOLIO` | Get portfolio | Returns total portfolio value and per-asset breakdown for a wallet address. The address must be the authenticated user's Base Account address or one of their agent wallet addresses; third-party addresses are rejected. Defaults to the session's wallet when omitted. Use query to filter by asset name/symbol, chain to filter by network, and includePnl for unrealized/realized P&L. Paginate with offset and limit (default 20). |
| `COINBASE_WALLET_MCP_GET_REQUEST_STATUS` | Get request status | Poll the status of an approval request by requestId (returned by send, sign, swap, or send_calls). Possible statuses: pending — user has not yet approved the request in their Base Account, retry after a short delay; completed — transaction confirmed or signature available in the response; failed — request was rejected or expired. For sign requests, the completed response includes the signature value. |
| `COINBASE_WALLET_MCP_GET_TRANSACTION_HISTORY` | Get transaction history | Returns paginated transaction history in reverse chronological order for a single chain. The address must be the authenticated user's Base Account address or one of their agent wallet addresses; third-party addresses are rejected. Defaults to the session's wallet when omitted. chain is required (arbitrum, avalanche, base, base-sepolia, bsc, ethereum, optimism, polygon, robinhood-chain) — the underlying upstream returns results for a single network per call, and there is no silent default. To cover multiple chains, call this tool once per chain. Optionally filter by asset symbol. No date range filter — paginate with cursor while hasMore is true. |
| `COINBASE_WALLET_MCP_GET_WALLETS` | Get wallets | Returns the user's Base Account and all agent wallets with delegation status, spend policy, and session authorization. Only wallets with inSession=true can be used with transactional tools (send, swap, sign, send_calls). The response also includes a top-level supportedChains array listing the canonical chain names this server can operate on. |
| `COINBASE_WALLET_MCP_HELP` | Help | Returns guidance for helping the user with protocol-specific tasks that aren't directly supported by this MCP. |
| `COINBASE_WALLET_MCP_INITIATE_X402_REQUEST` | Initiate x402 request | Initiate an HTTPS request to an x402-enabled endpoint. Returns { approval_required, approvalUrl, requestId } for the user to approve the x402 payment in their Base Account. When telling the user where to approve, refer to the destination as "Base Account". After approval, call complete_x402_request with the requestId. Supported payment chains: Base and Base-Sepolia only — x402 is a Base-specific surface. 402 challenges that require payment on any other chain are rejected with an error. |
| `COINBASE_WALLET_MCP_SEARCH_TOKENS` | Search tokens | Search for tokens by symbol or name on a single chain. Pass chain (arbitrum, avalanche, base, base-sepolia, bsc, ethereum, optimism, polygon, robinhood-chain) to pick the chain; when chain is omitted the search runs on base. Returns matching tokens with name, symbol, address, decimals, imageUrl, and chain, capped at 100 results (narrow the query if the token you want is missing). Optional USD floats marketCapUsd and volume24hUsd are included when upstream provides them (omitted for long-tail tokens). Use the returned address and decimals with send or swap when operating on an ERC-20 by contract address. |
| `COINBASE_WALLET_MCP_SEND` | Send | Send native tokens or any ERC-20. Recipient can be a 0x address, ENS name (name.eth), basename (name.base.eth), or cb.id. Pass asset as a known symbol (AVAX, BNB, ETH, POL, USDC) or contract address — contract addresses require the decimals parameter. Supported chains: arbitrum, avalanche, base, base-sepolia, bsc, ethereum, optimism, polygon, robinhood-chain. Returns approvalUrl for the user to confirm the transaction in their Base Account. When telling the user where to approve, refer to the destination as "Base Account". Poll get_request_status(requestId) to verify completion before reporting success. |
| `COINBASE_WALLET_MCP_SEND_CALLS` | Send calls | Submit a batch of raw contract calls for user approval. Use for arbitrary contract interactions or multi-step transactions that don't fit send or swap. Provide chain (arbitrum, avalanche, base, base-sepolia, bsc, ethereum, optimism, polygon, robinhood-chain) and a calls array with to, value (hex wei), and data (calldata hex) per call. Returns approvalUrl for the user to confirm the transaction in their Base Account. When telling the user where to approve, refer to the destination as "Base Account". Poll get_request_status(requestId) to verify completion. |
| `COINBASE_WALLET_MCP_SIGN` | Sign | Request a user-approved signature. Set type to personal_sign and pass data as {"message": "..."}, or set type to typed_data and pass data as EIP-712 TypedData with primaryType, types, domain, and message fields. Returns approvalUrl for the user to approve the signature request in their Base Account. When telling the user where to approve, refer to the destination as "Base Account". Poll get_request_status(requestId) to retrieve the signature. |
| `COINBASE_WALLET_MCP_SWAP` | Swap | Swap between tokens on a mainnet chain (testnets not supported). Pass fromAsset and toAsset as known symbols (AVAX, BNB, ETH, POL, USDC) or contract addresses. Use search_tokens to discover an address for a token referenced by name. Amount is a decimal string (e.g. "0.5"). Returns approvalUrl for the user to confirm the swap in their Base Account. When telling the user where to approve, refer to the destination as "Base Account". Poll get_request_status(requestId) to verify completion before reporting success. |
| `COINBASE_WALLET_MCP_WEB_REQUEST` | Web request | Make an HTTP GET or POST request to a whitelisted partner API. Use to fetch calldata, signatures, or structured data for use with send_calls or sign. HTTPS required; hostname must be in the server's allowlist. Authorization, Cookie, Host, and X-Forwarded-* headers are prohibited. Returns status code, headers, and response body. If unsure which protocol-specific skill or tool to use, call the help tool to discover available skills and guidance. |

## Supported Triggers

None listed.

## Installation and MCP Setup

### Path 1: SDK Installation

#### Path 1, Step 1: Install Composio

Install the Composio SDK, the OpenAI provider, and the OpenAI SDK
```python
pip install composio composio_openai openai
```

```typescript
npm install @composio/core @composio/openai openai
```

#### Path 1, Step 2: Create a Composio session

Initialize Composio with the OpenAI Responses provider and create a session scoped to Coinbase Wallet MCP
```python
import json
from openai import OpenAI
from composio import Composio
from composio_openai import OpenAIResponsesProvider

composio = Composio(provider=OpenAIResponsesProvider())
client = OpenAI()

session = composio.create(user_id="your-user-id", toolkits=["coinbase_wallet_mcp"])
tools = session.tools()
```

```typescript
import OpenAI from "openai";
import { Composio } from "@composio/core";
import { OpenAIResponsesProvider } from "@composio/openai";

const composio = new Composio({ provider: new OpenAIResponsesProvider() });
const client = new OpenAI();

const session = await composio.create("your-user-id", { toolkits: ["coinbase_wallet_mcp"] });
const tools = await session.tools();
```

#### Path 1, Step 3: Run Coinbase Wallet MCP tools with your agent

Send a request, execute the Coinbase Wallet MCP tool calls through the session, and print the final answer
```python
response = client.responses.create(
    model="gpt-5.6-sol",
    tools=tools,
    input=[{"role": "user", "content": "List recent transactions from my wallet in the last 24 hours"}],
)

while True:
    tool_calls = [o for o in response.output if o.type == "function_call"]
    if not tool_calls:
        break
    results = composio.provider.handle_tool_calls(response=response, session=session)
    response = client.responses.create(
        model="gpt-5.6-sol",
        tools=tools,
        previous_response_id=response.id,
        input=[
            {"type": "function_call_output", "call_id": call.call_id, "output": json.dumps(results[i])}
            for i, call in enumerate(tool_calls)
        ],
    )

print(response.output_text)
```

```typescript
let response = await client.responses.create({
  model: "gpt-5.6-sol",
  tools,
  input: [{ role: "user", content: "List recent transactions from my wallet in the last 24 hours" }],
});

while (response.output.some((o) => o.type === "function_call")) {
  const outputs = await composio.provider.handleToolCalls(session, response.output);
  response = await client.responses.create({
    model: "gpt-5.6-sol",
    tools,
    previous_response_id: response.id,
    input: outputs,
  });
}

console.log(response.output_text);
```

### Path 2: MCP Server Setup

#### Path 2, Step 1: Install Composio

Install the Composio SDK and your agent framework
```python
pip install composio claude-agent-sdk
```

```typescript
npm install @composio/core ai @ai-sdk/mcp @ai-sdk/openai
```

#### Path 2, Step 2: Create a session with MCP enabled

Create a session scoped to Coinbase Wallet MCP and read its MCP URL and headers
```python
from composio import Composio

composio = Composio()
session = composio.create(user_id="your-user-id", toolkits=["coinbase_wallet_mcp"], mcp=True)
```

```typescript
import { Composio } from "@composio/core";

const composio = new Composio();
const { mcp } = await composio.create("your-user-id", {
  toolkits: ["coinbase_wallet_mcp"],
  mcp: true,
});
```

#### Path 2, Step 3: Connect your agent to the MCP server

Pass the session's MCP URL and headers to your agent and run a Coinbase Wallet MCP request
```python
import asyncio
from claude_agent_sdk import ClaudeSDKClient, ClaudeAgentOptions, AssistantMessage, TextBlock

options = ClaudeAgentOptions(
    mcp_servers={
        "composio": {
            "type": "http",
            "url": session.mcp.url,
            "headers": session.mcp.headers,
        }
    },
    system_prompt="You are a helpful assistant with access to Coinbase Wallet MCP tools.",
    tools=[],
    allowed_tools=["mcp__composio__*"],
)

async def main():
    async with ClaudeSDKClient(options=options) as client:
        await client.query("List recent transactions from my wallet in the last 24 hours")
        async for message in client.receive_response():
            if isinstance(message, AssistantMessage):
                for block in message.content:
                    if isinstance(block, TextBlock):
                        print(block.text)

asyncio.run(main())
```

```typescript
import { createMCPClient } from "@ai-sdk/mcp";
import { openai } from "@ai-sdk/openai";
import { generateText, stepCountIs } from "ai";

const client = await createMCPClient({
  transport: { type: "http", url: mcp.url, headers: mcp.headers },
});

const { text } = await generateText({
  model: openai("gpt-5.6-sol"),
  tools: await client.tools(),
  prompt: "List recent transactions from my wallet in the last 24 hours",
  stopWhen: stepCountIs(10),
});

console.log(text);
await client.close();
```

## Why Use Composio?

### 1. AI Native Coinbase Wallet MCP Integration

- Supports both Coinbase Wallet MCP and direct API based integrations
- Structured, LLM-friendly schemas for reliable tool execution
- Rich coverage for reading, writing, and querying your Coinbase Wallet MCP data

### 2. Managed Auth

- Built-in OAuth handling with automatic token refresh and rotation
- Central place to manage, scope, and revoke Coinbase Wallet MCP access
- Per user and per environment credentials instead of hard-coded keys

### 3. Agent Optimized Design

- Tools are tuned using real error and success rates to improve reliability over time
- Comprehensive execution logs so you always know what ran, when, and on whose behalf

### 4. Enterprise Grade Security

- Fine-grained RBAC so you control which agents and users can access Coinbase Wallet MCP
- Scoped, least privilege access to Coinbase Wallet MCP resources
- Full audit trail of agent actions to support review and compliance

## Use Coinbase Wallet MCP with any AI Agent Framework

Choose a framework you want to connect Coinbase Wallet MCP with:

- [ChatGPT](https://composio.dev/toolkits/coinbase_wallet_mcp/framework/chatgpt)
- [Claude Cowork](https://composio.dev/toolkits/coinbase_wallet_mcp/framework/claude-cowork)
- [Hermes](https://composio.dev/toolkits/coinbase_wallet_mcp/framework/hermes-agent)
- [Atomic Agent](https://composio.dev/toolkits/coinbase_wallet_mcp/framework/atomic-agent)

## Related Toolkits

- [Stripe](https://composio.dev/toolkits/stripe) - Stripe is a global online payments platform offering APIs for managing payments, customers, and subscriptions. Trusted by businesses for secure, efficient, and scalable payment processing worldwide.
- [44API](https://composio.dev/toolkits/44api) - 44API is an API service for validating VAT and tax identifiers and returning company details. Use it to verify business tax data and manage account IP whitelists quickly.
- [Airwallex](https://composio.dev/toolkits/airwallex) - Airwallex is a global financial platform providing business accounts, payments, payouts, FX, and cards. Built to simplify cross-border payments and streamline financial operations for businesses.
- [Aiwyn Tax MCP](https://composio.dev/toolkits/aiwyn_tax_mcp) - Aiwyn Tax MCP is a tax estimation service powered by Aiwyn's federal and state tax engine. It helps teams estimate tax outcomes without building tax calculation logic from scratch.
- [Alpaca](https://composio.dev/toolkits/alpaca) - Alpaca is a stock and crypto trading platform for commission-free trading, real-time market data, and algorithmic strategies. Use it to build brokerage apps, trading bots, and portfolio workflows with market connectivity.
- [Alpha vantage](https://composio.dev/toolkits/alpha_vantage) - Alpha Vantage is a financial data platform offering real-time and historical stock market APIs. Get instant, reliable access to equities, forex, and technical analysis data for smarter trading decisions.
- [Altoviz](https://composio.dev/toolkits/altoviz) - Altoviz is a cloud-based billing and invoicing platform for businesses. It streamlines online payments, expense tracking, and customizable invoice management.
- [Benzinga](https://composio.dev/toolkits/benzinga) - Benzinga provides real-time financial news and data APIs for market coverage. It helps you track breaking news and actionable market insights instantly.
- [Bigdata.com MCP](https://composio.dev/toolkits/bigdata_com_mcp) - Bigdata.com MCP provides grounded access to financial news, transcripts, filings, and entity intelligence. Ideal for building research workflows and generating timely market insights.
- [Billsby](https://composio.dev/toolkits/billsby) - Billsby is a subscription billing platform for managing customers, subscriptions, invoices, products, plans, usage counters, add-ons, and allowances. It helps SaaS and subscription teams automate billing operations without building complex billing logic from scratch.
- [Brex](https://composio.dev/toolkits/brex) - Brex provides corporate credit cards and spend management tailored for startups and tech businesses. It helps optimize company cash flow, streamline accounting, and accelerate business growth.
- [Cashfree Payments MCP](https://composio.dev/toolkits/cashfree_payments_mcp) - Cashfree Payments MCP is a merchant payments platform that handles collection, payouts, subscriptions, settlements, refunds, and identity verification. Simplifies merchant money lifecycle management with unified, API-driven workflows.
- [Chaser](https://composio.dev/toolkits/chaser) - Chaser is accounts receivable automation software that sends invoice reminders and helps businesses get paid faster. It streamlines the collections process to save time and improve cash flow.
- [Clarity AI MCP](https://composio.dev/toolkits/clarity_ai_mcp) - Clarity AI MCP is an MCP toolkit for simulating SFDR 2.0 fund classifications from a fund name, ISIN, or CUSIP. Use it to tap Clarity AI disclosure data and modeling without building custom sustainability-data workflows.
- [Clientary](https://composio.dev/toolkits/clientary) - Clientary is a platform for managing clients, invoices, projects, proposals, and more. It streamlines client work and saves you serious admin time.
- [Coinbase](https://composio.dev/toolkits/coinbase) - Coinbase is a platform for buying, selling, and storing cryptocurrency. It makes exchanging and managing crypto simple and secure for everyone.
- [Coinbase Agents MCP](https://composio.dev/toolkits/coinbase_agents_mcp) - Coinbase Agents MCP is Coinbase's managed toolkit exposing accounts, portfolios, orders, fills, and market data. Use it to let authorized agents inspect holdings, execute trades, perform transfers, and handle payments.
- [Coinranking](https://composio.dev/toolkits/coinranking) - Coinranking is a comprehensive cryptocurrency market data platform offering access to real-time coin prices, market caps, and historical data. Get accurate, up-to-date stats for thousands of digital assets in one place.
- [Coupa](https://composio.dev/toolkits/coupa) - Coupa is a business spend management platform for procurement, invoicing, and expenses. It helps organizations streamline purchasing, control costs, and gain complete visibility over financial operations.
- [CurrencyScoop](https://composio.dev/toolkits/currencyscoop) - CurrencyScoop is a developer-friendly API for real-time and historical currency exchange rates. Easily access fiat and crypto data for smart, up-to-date financial applications.

## Frequently Asked Questions

### Do I need my own developer credentials to use Coinbase Wallet MCP with Composio?

Yes, Coinbase Wallet MCP requires you to configure your own Dcr Oauth credentials. Once set up, Composio handles secure credential storage and management for you.

### Can I use multiple toolkits together?

Yes! Composio's Tool Router enables agents to use multiple toolkits. [Learn more](https://docs.composio.dev/tool-router/overview).

### Is Composio secure?

Composio is SOC 2 and ISO 27001 compliant with all data encrypted in transit and at rest. [Learn more](https://trust.composio.dev).

### What if the API changes?

Composio maintains and updates all toolkit integrations automatically, so your agents always work with the latest API versions.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)