Solana API Playground: test pump.fun streams and REST in your browser

The Anaxer API Playground is a page in the Anaxer console where you can try real-time Solana and pump.fun data in your browser, without writing code. Subscribe to a live WebSocket stream of token launches, graduations, trades, prices or wallet transfers, or send any REST request, and you see the exact JSON payload your app would receive alongside the code that produced it. It launched on 19 October 2026 and is free on every plan.

Evaluating a Solana data API used to mean writing a WebSocket client, handling the handshake and the subscribe message, and only then finding out whether the data was what you needed. The Playground moves that question to the start: press Connect, watch real pump.fun events arrive, then copy working code.

What is the Anaxer API Playground?

It is an interactive API explorer for Anaxer's Solana data API, built into the console. It has two modes that share one API key:

• Streams - subscribe to a real-time WebSocket channel with filters, and watch events arrive in a live feed.
• REST API - pick an endpoint, fill in its parameters, and send the request.

In both modes, the screen shows three things side by side: what you asked for, exactly what came back, and the code that would do the same thing in your own app. Switching between Streams and REST does not drop a live stream, so you can, for example, catch a graduation on the stream and then look up that token's trades over REST.

If you have used a GraphQL IDE or a "Try it" button in API docs, the idea is similar. The difference is that Solana data is mostly real-time, and a request/response widget cannot hold a WebSocket open. The Playground was built streaming-first because that is where evaluating a Solana data API is hardest.

What can you test in the Playground?

Real-time streams

Filters re-subscribe automatically when you pause typing, so you can tighten a filter - say, raise minVolumeUsd from 100 to 1,000 - and watch the feed change without reconnecting by hand. On trades, turning on solOnly labels each swap as a buy or sell, because with SOL on one leg the direction is unambiguous.

REST endpoints

Each response shows the HTTP status, how long the request took, and its cost from the X-Request-Cost header - batch calls cost one per unique mint, which is easy to miss until you see it. Paginated endpoints have a Use next cursor button that drops the next value from the response straight into the form, so you can walk pages of trade history without copying opaque strings around.

Why use an API playground instead of writing a test script?

Because it answers the questions you actually have when choosing a data provider, faster than a script would:

1. Is the data what I need? You see real events in seconds - real mints, real liquidity, real swap sizes - instead of the cleaned-up examples in docs.
2. What does the payload look like, exactly? The event inspector shows the full { v, channel, type, sub, ts, data } envelope, and the frame log shows every protocol frame: connected (with your plan's real limits), subscribed, pong and any errors.
3. What will trip me up in production? Field notes sit next to every channel and endpoint and call out the details that cause bugs: volumeUsd can be null, socials are usually null in fast mode, older graduations have no liquiditySol, unknown mints return an empty trades page rather than a 404.
4. How do I write this in my language? The Code tab generates the same request as raw WebSocket, the TypeScript SDK or the Python SDK for streams, and curl, TypeScript or Python for REST. All three languages always express the identical request, and the snippets are tested against the live gateway.
5. What does my plan allow? Channels outside your plan are marked "not on your plan", and errors such as subscription_limit or plan_restricted explain what happened and what would fix it, instead of leaving you with a bare error code.

For teams building AI agents, there is one more reason: you can see the exact payload your agent will reason over before wiring up the Anaxer MCP server to Claude or Cursor.

Example: watch pump.fun graduations with real liquidity

Suppose you only care about pump.fun tokens that graduate with a meaningful pool, and want to skip thin Mayhem-mode graduations. In the Playground:

1. Choose the graduations channel.
2. Turn on excludeMayhem and set minLiquiditySol to 50.
3. Press Connect.

Each graduation that clears the bar appears in the feed with its symbol and the SOL seeded into the pool. Switch to Code and the WebSocket tab gives you this, ready to paste:

const ws = new WebSocket(
  "wss://api.anaxer.com/v1/stream?apiKey=YOUR_KEY"
);

ws.onopen = () => {
  ws.send(JSON.stringify({
    type: "subscribe",
    id: "my-feed",
    channel: "graduations",
    filters: {
      excludeMayhem: true,
      minLiquiditySol: 50,
    },
  }));
};

ws.onmessage = (e) => {
  const msg = JSON.parse(e.data);
  if (msg.type === "connected") console.log("plan limits", msg.limits);
  else if (msg.type === "subscribed") console.log("live on", msg.channel);
  else if (msg.type === "error") console.error(msg.code, msg.message);
  else if (msg.data) console.log(msg.data); // the event payload
};

// Optional keepalive - the server replies with { type: "pong" }
setInterval(() => ws.send(JSON.stringify({ type: "ping" })), 15_000);

The TypeScript tab expresses the same subscription with the SDK:

import { connect } from "@anaxer/sdk";

const client = connect({ apiKey: process.env.ANAXER_API_KEY! });

const sub = client.stream("graduations", {
  excludeMayhem: true,
  minLiquiditySol: 50,
});

sub.on("subscribed", (filters) => console.log("live", filters));
sub.on("data", (event) => console.log(event));
sub.on("error", (err) => console.error(err.code, err.message));

For what the graduation fields mean and how to act on them, see how to detect pump.fun graduations.

Example: check a token's recent trades over REST

Switch to REST API, choose Token Trades, and paste a mint address. The form starts with solOnly on and limit at 3, so the first response fits on screen. Send it, and the curl tab shows the request you just made:

curl "https://api.anaxer.com/v1/tokens/EKpQGSJtjMFqKZ9KQanSqYXRcF8fBopzLHYxdM65zcjm/trades?solOnly=true&limit=3" \
  -H "Authorization: Bearer YOUR_KEY"

The response includes a window showing the time range actually covered (trade history is retained for 7 days) and a next cursor. Press Use next cursor to fetch the following page. This is the same call you would use to backfill a gap after a WebSocket reconnect - the pattern covered in the Solana WebSocket streams guide.

Who is the Playground for?

• Developers comparing Solana data APIs. See the real payload and latency before you commit to a provider or write an integration. If you are still shortlisting, our comparison of nine pump.fun APIs prices three real workloads on each.
• Trading bot builders. Tune filters like minVolumeUsd, wallets or minLiquiditySol against live traffic to see how much flow they actually let through, then copy the subscription into your bot.
• AI agent builders. Check what your Claude or Cursor agent will receive from the MCP server - see building a Solana trading agent with Claude or Cursor.
• Anyone debugging an integration. If your production code gets an unexpected error or no events, reproduce the same subscription in the Playground and compare the frames.
• Analysts and non-coders. Watch pump.fun launches and graduations happen, or pull launchpad stats, without installing anything.

The layout works on phones too, so you can check a live feed away from your desk.

What should you know before using it?

• Usage counts toward your plan. Playground streams and requests hit the real API, so they use the same quota and concurrent-subscription slots as your own code. See rate limits.
• Streams stop after 10 minutes. Each playground session has a visible countdown. The cap stops a forgotten tab from holding a subscription slot; streams from your own code have no time limit. You can pause and resume within a session.
• Your key stays in the tab. A pasted or generated key is kept in the tab's session storage and cleared when you close it. Generated keys are named with the date (for example "Playground - 19 Oct") so you can find and revoke them on the API Keys page.
• Generated code contains your key. The WebSocket and curl snippets include the key you entered, so you can run them as-is. Treat them like any secret: move the key to an environment variable before committing code.
• Trades, prices and transfers need a paid plan. The free plan covers creations and graduations. Starter ($39/mo) adds prices, trades for up to 25 tokens at once, and transfers for up to 100 wallets or 25 tokens at once; Pro ($99/mo) streams every trade and every transfer. See pricing.

From playground to production

The Playground is the fastest way to confirm a subscription is right. Once it is, take it into your app:

• Copy the generated code, or install the TypeScript or Python SDK, which handle auth and reconnects for you.
• Read the streams reference and the REST reference for every field and filter.
• Plan for disconnects with the reconnect and backfill pattern in the WebSocket streams guide.
• Building an agent? Connect the Anaxer MCP server and describe what to watch in plain English.

Open the Playground, or create a free account if you do not have one yet.