MCP Overview

What is OpenSea MCP?

OpenSea MCP is a hosted server that gives AI tools secure access to blockchain data across NFTs, tokens, and wallets. Query real-time prices, swap tokens, analyze portfolios, and mint NFTs, all through natural language. It works with popular AI assistants like ChatGPT, Cursor, Claude, and Chorus.

Why use OpenSea MCP?

• Easy setup: Connect through a simple URL configuration
• Real-time data: Access live prices for NFTs, tokens, and cryptocurrencies
• Broad blockchain coverage: Support for Ethereum, Polygon, Base, Solana and other major chains
• Built for AI: Efficient data formatting and natural language search designed for AI agents

What can you do with OpenSea MCP?

• Analyze tokens and cryptocurrencies: Look up ERC-20 tokens, meme coins, and get real-time price data
• Swap tokens: Get quotes and transaction data for token swaps across supported chains
• Research NFT collections: Get floor prices, volume data, and trending collections
• Check wallet portfolios: View complete holdings including NFTs, tokens, and balances for any address
• Track market trends: Identify trending tokens, NFT collections, and monitor trading activity
• Mint NFTs from drops: Get drop details, check eligibility, and generate mint transactions
• Deploy NFT contracts: Deploy new SeaDrop NFT contracts and track deployment status
• Discover AI agent tools: Search the onchain Tool Registry (ERC-8257) for registered tools, check access requirements, and verify wallet eligibility

Getting Started

Connect through your AI tool

To connect OpenSea MCP to your AI assistant, use one of these connection methods.

Streamable HTTP (Recommended)

• URL: https://mcp.opensea.io/mcp
• JSON config:

{
    "mcpServers": {
      "OpenSea": {
        "url": "https://mcp.opensea.io/mcp",
         "headers": {
           "X-API-KEY": "YOUR_API_KEY"
         }
      }
    }
}

SSE (Server-Sent Events)

• URL: https://mcp.opensea.io/sse
• JSON config:

{
    "mcpServers": {
      "OpenSea": {
        "url": "https://mcp.opensea.io/sse",
        "headers": {
          "X-API-KEY": "YOUR_API_KEY"
        }
      }
    }
}

Providing your API key

You can present your OpenSea API key in whichever way your client supports:

• X-API-KEY header (shown above): recommended.
• Authorization: Bearer YOUR_API_KEY header: use this if your client only supports bearer-token auth (for example, Perplexity's connector). The same OpenSea API key is accepted here.

The same OpenSea API key works for both the REST API and MCP. There is no separate MCP token.

Quick Start Examples

Once connected, try these prompts to explore OpenSea MCP capabilities:

1. "What's the price of PEPE token on Ethereum?"
2. "Show me trending tokens on Base"
3. "Quote a swap of 1 ETH to USDC"
4. "Check the complete portfolio for wallet 0x123..."
5. "What's the floor price of Pudgy Penguins?"
6. "Find the top meme coins by trading volume"

Sample Project

Prefer a working app? Try the Next.js + Vercel AI SDK starter preconfigured with OpenSea MCP:
https://github.com/ProjectOpenSea/opensea-mcp-next-sample

Supported Tools

Now that you have installed the OpenSea MCP, let's explore how AI assistants can use OpenSea MCP tools to search, analyze, and interact with blockchain and marketplace data.

These tools work together through prompts, and they are most useful in combination. With a single prompt, you can search for collections, check token prices, analyze wallet holdings, and get swap quotes across multiple blockchains.

Common Use Cases

Token Trading:

"Get a quote to swap 0.5 ETH for USDC on Base, then show me the transaction data"

Token Discovery:

"Find trending meme coins on Solana and show their 24-hour price changes"

Portfolio Analysis:

"Show me all tokens and NFTs owned by vitalik.eth with current USD values"

Market Research:

"What are the top tokens by trading volume on Ethereum today?"

NFT Research:

"Find NFT collections trending in the last 24 hours with floor price under 1 ETH"

NFT Minting:

"Check if I'm eligible for the upcoming drop and prepare the mint transaction for 2 NFTs"

Tool Discovery (ERC-8257):

"Search for NFT-gated AI tools on Base and check which ones my wallet can access"

Chain Support

OpenSea MCP supports all of the blockchains supported on the OpenSea web front-end.

When using tools, you can specify the chain parameter to filter results to a specific blockchain.

Best Practices

1. Use natural language - The AI-powered search understands context, so describe what you're looking for naturally
2. Combine tools - Get comprehensive insights by using multiple tools together
3. Specify chains - When looking for specific blockchain data, include the chain name
4. Check balances first - Before requesting swap quotes, verify wallet has sufficient tokens
5. Use collection slugs - For specific collections, use their OpenSea slug (e.g., 'boredapeyachtclub')
6. Leverage includes parameters - Many tools support optional 'includes' arrays for additional data (activity, analytics, offers, etc.)
7. Specify amounts correctly - For swaps, use native units (ETH/SOL) not smallest units (wei/lamports)

Rate Limits and Performance

• Most queries return results within 1-3 seconds
• Rate limits apply per API key
• Use pagination for large result sets
• Cursor-based pagination available for trending and top collections/tokens

Error Handling

The MCP server provides clear error messages:

• Invalid addresses or contract addresses
• Unsupported chains
• Rate limit exceeded
• Insufficient token balance for swaps

For questions, feedback or support, contact [email protected].

Client Setup

Claude Desktop

Claude Desktop supports MCP servers natively.

1. Open your configuration file:
   • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
   • Windows: %APPDATA%\Claude\claude_desktop_config.json
2. Add the OpenSea MCP server (see JSON config above)
3. Restart Claude Desktop. You should see a hammer icon in the chat input, indicating MCP tools are available.

Cursor

Go to Cursor Settings > MCP > Add new global MCP server, or edit the file directly:

• Project-level: .cursor/mcp.json in your project root
• Global: ~/.cursor/mcp.json

Add the JSON config above. The OpenSea server should show a green status indicator in Cursor Settings > MCP.

VS Code (GitHub Copilot)

Open VS Code Settings (Cmd+, / Ctrl+,) and search for mcp. Ensure Chat > MCP: Enabled is checked. Then add to your settings.json:

{
  "mcp": {
    "servers": {
      "OpenSea": {
        "type": "http",
        "url": "https://mcp.opensea.io/mcp",
        "headers": {
          "X-API-KEY": "YOUR_API_KEY"
        }
      }
    }
  }
}

Open Copilot Chat, switch to Agent mode, and click the tools icon to confirm the OpenSea tools are available.

Windsurf

Go to Windsurf Settings > Cascade > MCP, or edit ~/.codeium/windsurf/mcp_config.json. Note: Windsurf uses serverUrl instead of url:

{
  "mcpServers": {
    "OpenSea": {
      "serverUrl": "https://mcp.opensea.io/mcp",
      "headers": {
        "X-API-KEY": "YOUR_API_KEY"
      }
    }
  }
}

ChatGPT

In ChatGPT, go to Settings > Connectors and add a new connector with the URL https://mcp.opensea.io/mcp. Connector support may require a ChatGPT plan and settings that allow custom connectors.

Custom Applications

Integrate OpenSea MCP into your own applications using any MCP-compatible SDK:

Vercel AI SDK: See the full starter project at opensea-mcp-next-sample.

import { experimental_createMCPClient as createMCPClient } from "ai";

const mcpClient = await createMCPClient({
  transport: {
    type: "sse",
    url: "https://mcp.opensea.io/sse",
    headers: { "X-API-KEY": process.env.OPENSEA_API_KEY },
  },
});
const tools = await mcpClient.tools();

Python

from mcp import ClientSession
from mcp.client.streamable_http import streamablehttp_client

async with streamablehttp_client(
    "https://mcp.opensea.io/mcp",
    headers={"X-API-KEY": "YOUR_API_KEY"},
) as (read, write, _):
    async with ClientSession(read, write) as session:
        await session.initialize()
        tools = await session.list_tools()

TypeScript

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";

const transport = new StreamableHTTPClientTransport(
  new URL("https://mcp.opensea.io/mcp"),
  { requestInit: { headers: { "X-API-KEY": "YOUR_API_KEY" } } }
);
const client = new Client({ name: "my-app", version: "1.0.0" });
await client.connect(transport);
const { tools } = await client.listTools();