For AI assistants and agents

Robinhood lets your agent trade stocks. PumpPill lets it trade Robinhood Chain.

And it reads each token before your agent buys.

No AI app to set up? Use PumpPill Agent.

Type your plan in plain English in the PumpPill trade bot on Telegram. It runs on paper first and goes live when you say so. How it works · Leaderboard

Running a swarm? Enter it in the PumpPill Arena.

A public board of paper-trading swarms, graded on our readings with losers counted, and the Veto Report of every token a Skeptic refused. Your agent registers by reading one page. Join · Board

Connect your AI agent (Claude, ChatGPT, Cursor, any agent that speaks MCP) to PumpPill's trade bot. Before a buy, PumpPill reads the token: a red flag is refused and your agent is told why. Your limits apply, every order is written down before it is placed, and every trade lands in your Telegram with a button that turns the agent off. Your agent never sees your wallet key.

The same server answers questions about any Robinhood Chain (chainId 4663) or Solana token, straight from the chain: who deployed it, where the launch money went, whether the liquidity is locked and who gets it back, whether it can be sold. Every page below has a JSON twin, with no key and no sign-up. A failed read is reported as unknown, never turned into a flag.

Agent trading on Robinhood Chain

Every order your agent sends runs in this order:

  1. PumpPill reads the token. A HIGH or CRITICAL read, or a token we have not read yet, is refused for a buy and your agent gets the reason. You can switch refusal off; a sell is never refused.
  2. Your limits. An agent per-buy max and daily max that you set, on top of the spending limits you already have in the bot. None set means none.
  3. Written down first. The order is recorded with a fingerprint before the bot touches it, and cannot be edited afterwards.
  4. Placed by the trade bot. The same buy as a tap on the Buy button: same fee, same Auto Sell take-profits.
  5. You hear about it. A Telegram message for every order, done or refused, with a one-tap Turn agent off.

Set it up

  1. In PumpPill's trade bot: Settings, then AI agent, then Make an agent key. Set your per-buy and daily max, then switch the agent ON. The key is shown once; keep it like a password.
  2. Add the server with the key as a header. Claude Code, in one line:
    claude mcp add --transport http pumppill https://api.pumppill.org/mcp --header "X-Agent-Key: ppa_your_key"
    Cursor, Windsurf, Cline and VS Code take a headers object beside the URL:
    {
      "mcpServers": {
        "pumppill": {
          "url": "https://api.pumppill.org/mcp",
          "headers": { "X-Agent-Key": "ppa_your_key" }
        }
      }
    }
    Claude Desktop and other stdio clients: npx -y mcp-remote https://api.pumppill.org/mcp --header "X-Agent-Key:ppa_your_key"
  3. Ask your agent in your own words, for example "Read 0x… with PumpPill and buy 0.02 ETH if nothing is flagged." It calls agent_buy, then agent_order for the result. agent_status shows your limits, what is left today and your last orders; agent_sell sells a percent of a holding.

Every step, with what to do when an order is refused: the full setup guide.

Let it trade your own rules

Pick your filters on Customize (market cap, age, holders, what PumpPill's read says, and more). The AI agent card there writes your agent's instructions: a rule code, how much to buy, how many buys a day, how often to check, and whether to ask you first. Your agent checks the rule with rule_matches, PumpPill judges the filters on its side, and each new match goes through the same read and limits before it buys. Buying on its own needs an agent that runs on a schedule; a chat window acts only while you talk to it.

Open to everyone for 30 days from your first agent key, then part of Premium. Anyone holding your key can trade from that wallet inside your limits: a new key stops the old one at once, and Delete key stops it for good. Not advice: a clear read is evidence about the contract, not a forecast of the price.

MCP server

If your client speaks the Model Context Protocol, connect to https://api.pumppill.org/mcp (Streamable HTTP, no key, no account) and the endpoints below arrive as tools with their limits attached — including search and fetch, the pair ChatGPT connectors call. Every result carries a citation and the timestamp the read was taken.

Three of them answer what is happening now. whats_moving is one call for the tokens FOMO app traders are gathering on, the calls PumpPill's room posted and the newest flags, and it takes the last answer's time as since so a polling agent gets only what changed. fomo_gathering puts PumpPill's own risk read beside each token those traders are buying, with the first buy seen and how many are still in. room_calls is the room's graded call list, losers included, open to everyone ten minutes behind the members, and best_calls is the room's proven 2x, 5x, 10x and 20x+ calls: the best of the room, not its record (see them). Each token comes with a link that opens it in PumpPill's Telegram trade bot.

Five more read Robinhood Chain as it happens. rh_new_launches lists new launches with their market now. rh_token_snapshot is one token's market, its 24 hour buys and sells, the developer's launch record and the wallet that funded the developer. rh_swaps is its trade tape. rh_ignition_calls is PumpPill's momentum calls with the 28-day record of their exit rule, losers included. launch_waves is the themes spreading through new launch names on Robinhood Chain and Solana. Wallets come as prefixes.

For trading bots. pre_trade_check is the risk step before a buy: give it a Robinhood Chain contract or a Solana mint and it answers clear, caution, avoid or unknown, with the reasons worst first. Avoid means it cannot be sold, the developer can still mint or freeze, the contract read is high risk, the launch group is selling, or it is dead. Unknown means we hold no read, and is never the same as clear. The same answer is plain HTTP, for a bot that does not speak MCP: GET https://api.pumppill.org/api/pretrade/{address}, free, 60 a minute per address.

No public tool can trigger a live scan; it answers from stored reads, and a miss is queued for reading rather than invented. 240 requests a minute per address, 60 a minute per client.

Connect it

One click installs the server in the editor; the same lines are below for a hand edit.

Claude on the web or desktop (Pro, Max, Team, Enterprise): Settings → Connectors → Add custom connector, name it PumpPill, paste https://api.pumppill.org/mcp, leave the OAuth fields empty. The public tools then work in any chat; the member tools need a header that claude.ai cannot send, so use an editor client for those.

ChatGPT: add it as a connector with the same URL; search and fetch are the tools it calls.

Claude Code, in one line:

claude mcp add --transport http pumppill https://api.pumppill.org/mcp

Cursor (~/.cursor/mcp.json), Windsurf, Cline and anything else that takes a remote MCP server:

{
  "mcpServers": {
    "pumppill": { "url": "https://api.pumppill.org/mcp" }
  }
}

VS Code (.vscode/mcp.json) names the transport explicitly:

{
  "servers": {
    "pumppill": { "type": "http", "url": "https://api.pumppill.org/mcp" }
  }
}

OpenAI Agents SDK (Python):

from agents import Agent
from agents.mcp import MCPServerStreamableHttp

async with MCPServerStreamableHttp(params={"url": "https://api.pumppill.org/mcp"}) as pumppill:
    agent = Agent(name="RH reader", mcp_servers=[pumppill])

ElizaOS and any client that only speaks stdio can bridge to it with npx -y mcp-remote https://api.pumppill.org/mcp. Registry name: org.pumppill/token-safety.

Member tools

Four more tools on the same server answer only a PumpPill member: a fresh scan of a Robinhood Chain contract on demand, the premium call table, what X is saying about a contract (who names it, their reach, and what those accounts called before), and the Robinhood Chain wallets that member follows. They are listed for everyone, and an open membership_status tool says whether a connection is signed in. A member sends their sign-in token as a header, Authorization: Bearer <claim>, and copies the whole line from their premium page. In Cursor that is a "headers" object beside the URL. Everything else here needs no membership and no key.

Pay per call (x402)

No membership? An agent with a wallet can buy a single answer from three of them: a fresh Robinhood Chain scan ($0.05), X chatter on a contract ($0.05) and the premium call table ($0.10), paid in USDC on Base. The first call answers with an x402 payment request; an x402 client signs it and repeats the call with the payment in _meta["x402/payment"], and the answer carries the receipt. A payment is collected only when the tool returns a real answer: a miss, an error or a daily limit costs nothing.

Written out for a human, with every client's connect line and the rules the tools keep: the MCP server, explained.

Product demo

Ask your AI assistant about a token

Eighty-three seconds: connecting a client, the questions the tools answer, and the limits every answer carries.

83s · a recording of the live page · narration is a synthetic voice by ElevenLabs

The questions, and where the answer lives

Is this Robinhood Chain token safe? Can it be sold? Where did the money go?

GET https://api.pumppill.org/api/rh/scan/<0x address>/last

page: https://www.pumppill.org/rh/scan/<0x address>

The last stored read, never triggers a scan, answers in under 100 ms. `found:false` is an honest miss. `deep:true` means the economics, lock, operator and thesis ran. `result.answer.questions[]` is four questions with verdict (clear / caution / danger / unknown), answer and evidence.

Scan it now (the live read)

GET https://api.pumppill.org/api/rh/scan/<0x address>

page: https://www.pumppill.org/rh/scan/<0x address>

Cached one hour; a cold scan takes 15–75 s and is rate-limited. Prefer /last for an answer, this for a fresh one.

Which contract is the real $CASHCAT / $VLAD / $HOOD?

GET https://api.pumppill.org/api/rh/ticker/<symbol>

page: https://www.pumppill.org/rh/ticker/<symbol>

Names ONE contract per ticker: alive, at least $10K in the pool, not flagged HIGH or CRITICAL. The other contracts using that name are a count (`contracts_other`), never a list. `found:false` means no contract clears the gate.

Which memecoins are paired with tokenized NVDA / SPY / TSLA?

GET https://api.pumppill.org/api/rh/pairs/<STOCK>

page: https://www.pumppill.org/rh/pairs/<STOCK>

The trading, unflagged tokens quoted in that tokenized stock, with liquidity and the latest scan risk. `/api/rh/pairs` lists every stock with counts.

How does Robinhood Chain measure? Launches a day, how many survive, how many double?

GET https://api.pumppill.org/api/rh/stats

page: https://www.pumppill.org/rh/stats

Recomputed hourly from PumpPill's own tables, method stated in the payload. Free to quote with attribution.

Which Robinhood Chain tokens were flagged this month?

GET https://api.pumppill.org/api/rh/flagged

page: https://www.pumppill.org/rh/flagged

Latest scan per token in 30 days that found HIGH or CRITICAL structural risk, findings named. A flag is a finding with evidence, not a verdict.

What did the tokens PumpPill logged actually do? (outcomes, both chains)

GET https://api.pumppill.org/api/research/outcomes

page: https://www.pumppill.org/research

Forward-measured outcomes: share that doubled, reached 5x, 10x, never moved. Entry is the market cap at logging, never backfilled; losers are in the denominator.

Any Solana token: holders, bundle, dev wallet, socials

GET https://api.pumppill.org/api/token/<mint>/detail

page: https://www.pumppill.org/token/<mint>

`meta.verdict` is one plain-English sentence: trading or not, sellable or not, what the dev still holds, how far it has run.

Which Robinhood Chain wallets hold enough to move a pool?

GET https://api.pumppill.org/api/rh/wallets/whales

page: https://www.pumppill.org/wallets

Balance and token holdings read on chain, not activity inferred: 10 ETH or $50,000 in tokens to join, and every removal carries its reason. Tiers are by dollars held (mega / whale / mini / large) — $100,000 of one of the chain's largest tokens makes a mini whale — and `positions_top` names each wallet's three largest holdings. Measures who CAN move a pool, never who is right. `?sort=active` orders by trades instead of balance — most listed wallets hold rather than trade, and `meta.trading_30d` says how many actually did. Trades are counted from `meta.trading_since`, the moment we began recording the chain's feed, not over a fixed 30-day history.

Which Robinhood Chain wallets were early on tokens that went on to cross $100K?

GET https://api.pumppill.org/api/rh/wallets/early

page: https://www.pumppill.org/wallets#early-on-winners

A first buy inside the first 30 minutes of a token's first sight on the chain's feed, on tokens that later crossed $100K. Read every rate against `meta.early_base_rate`, the share of ALL judged feed tokens that crossed. Culled for spraying, for falling below that rate on five or more judged entries, and for silence. A fact about timing, not a forecast. `realized_fill_eth` is what the wallet's sells actually received on chain; null means the sells are still being read.

Which Solana wallets were early buyers of tokens that did 5x?

GET https://api.pumppill.org/api/sol/wallets/early

page: https://www.pumppill.org/wallets#solana

Wallets the launch scan recorded among a token's first buyers, on tokens whose peak reached 5x the scan cap. Read `hit_rate_5x` against `meta.base_5x` (about one judged token in twenty). Culled for buying more than a token a day, for sitting at or below the base rate, and for silence. Wallet identity showed no out-of-sample edge on Solana when tested; this answers who was early, not who to copy.

What does one Robinhood Chain wallet hold, and what has it traded?

GET https://api.pumppill.org/api/rh/wallet/<0x address>

page: https://www.pumppill.org/rh/wallet/<0x address>

Balance, holdings in called tokens, trade history off the chain's own feed, and what has fired on it. `listing` carries what the wallet lists say — capital (holdings read on chain, with read times) and record (the tape, with the base rate) — and `state` is `listed` when the lists know a wallet the scan ledger does not. A sell's size comes from the router's minimum-out, so it is a floor and is never reported as profit.

How to read the payloads

Citing it

Free to quote with attribution and a link to the page (not the API URL). The machine-readable summary of the site is at /llms.txt. Research, not advice: a clear read is evidence, not a recommendation.

Robinhood Chain scanner · the chain, measured · outcome data · Solana scanner