Give Cursor live Solana data with the Anaxer MCP server

To give Cursor live Solana data, add the Anaxer MCP server to .cursor/mcp.json - five lines that run npx -y @anaxer/mcp with your API key. Cursor's agent then has nine typed tools for pump.fun launches, graduations, trades, and prices, and can answer market questions with real on-chain events.

Why give Cursor live Solana data?

Cursor's agent is already where you write your trading bot, dashboard, or alerting code. With the MCP server attached, the same agent that writes the code can check the market: verify what a real created event looks like before writing the parser, pull actual prices to sanity-check a calculation, or tail live trades to confirm a filter behaves the way you expect. It turns "let me check the docs and paste an example" into a tool call the agent makes itself.

This guide covers setup and first prompts. For where MCP fits in a full agent design - data in, reasoning, execution out - see how to build a Solana trading agent with Claude and Cursor.

How do I add the Anaxer MCP server to Cursor?

Create .cursor/mcp.json in your project root (or add the same block through Cursor Settings → MCP). You need Node.js 20 or newer and an API key from the console.

{
  "mcpServers": {
    "anaxer": {
      "command": "npx",
      "args": ["-y", "@anaxer/mcp"],
      "env": {
        "ANAXER_API_KEY": "YOUR_KEY"
      }
    }
  }
}

Cursor detects the file and offers to enable the server. Once enabled, open the MCP settings panel and confirm anaxer shows a green status with its tools listed - get_token_price, list_creations, tail_stream, and the rest. The full tool reference lives in the MCP server docs.

What should I ask first?

Start with prompts that map to a single tool call, so you can see the round-trip working:

• "List the last 20 pump.fun launches and show me name, symbol, and mint." - one list_creations call.
• "What is the current price and market cap of <mint>?" - one get_token_price call.
• "Show me the most recent graduations and how much liquidity each moved." - one list_graduations call.

Then let the agent combine tools:

• "Pull the last 50 launches, then batch-check prices for any that already have a price. Which are up since launch?"
• "Get launchpad stats for the past 24 hours and tell me if launch volume is above or below yesterday."

List tools return one page of 20 by default with a next cursor, so the agent pages through history only when the question needs it - which keeps responses fast and the context small.

How does tail_stream work in Cursor?

MCP tools are request/response, so the live feed is exposed as a bounded collect: tail_stream subscribes, gathers events, unsubscribes, and returns the batch. It stops at maxEvents (default 20, cap 100) or timeoutMs (default 10 seconds, cap 30), whichever hits first.

Ask something like:

"Tail the trades stream for 15 seconds, filtered to trades over $500, and summarize the flow by mint."

The agent fills in the filters - minVolumeUsd, mints, wallets, and sources are all available on the trades channel - and reasons over the events that came back. Per-channel filter keys are listed in the MCP docs. If you want the agent to watch launches instead, the creations channel supports the same enriched and excludeMayhem filters as the raw stream described in the pump.fun launch tracking guide.

Troubleshooting: why isn't it working?

• Server shows red / failed to start. Check node --version - the server requires Node.js ≥ 20. Then confirm ANAXER_API_KEY is present in the env block; without it the process exits with a stderr message before speaking MCP.
• unauthorized on a REST tool. The key is wrong or revoked. Fix the env value and call again - REST tools pick up the fix without a restart.
• unauthorized on tail_stream. A bad key is terminal for the shared WebSocket. Fix the key, then restart the MCP server (disable and re-enable it in Cursor's MCP settings).
• subscription_limit on tail_stream. Each open tail holds one plan subscription until it returns. The free plan allows one concurrent stream, so overlapping tails - usually from parallel agents - hit the cap. Let the first tail finish, or upgrade for more concurrent streams.
• Tools missing from the agent. Confirm the server is enabled for the current project and reload the window. Cursor only exposes tools from servers with a green status.

What can you build from here?

With the data layer attached, the natural next step is strategy work: encode your screening rules in Cursor project rules so the agent applies them every session, and use the agent to prototype the logic your production bot will run. The trading agent architecture guide covers that full picture, including the execution layer that stays deliberately outside MCP. When a strategy graduates to always-on, move the hot path to @anaxer/sdk and keep Cursor for research - and if you mostly work in Claude, the Claude setup walkthrough mirrors this one.