Building a bot that trades Robinhood Chain memecoins and want a measured social signal to feed its own rules? RobinX grades the X accounts that call Robinhood Chain tokens against the price that followed each call, counts the Telegram rooms that carried the token, and streams the result to your bot by REST, signed webhook, MCP or x402, with a pre-trade check your bot can run on every token it names.
Everything here is a rule-based observation: X posts and chain data are public and every X grade has a receipt; Telegram rooms are counted, never named or quoted. Your bot decides; RobinX never holds your funds or keys, never takes orders, never trades for you and never recommends.
One item per fresh call from an account with a measured record. Each carries:
Measured on 28 October 2026 from the live index. The counts move daily; the current ones are on the board and at GET /stats.
Most accounts that post Robinhood Chain tokens are echo. Of the 3,604 measured, 146 were early on half their calls or more, and 216 are flagged as part of a coordinated cluster (one shared text across many accounts counts as one voice). The stream is narrower still: by default it carries only the accounts at grade B or better (a rank score of 0.30 or more, coordinated accounts left out), and you can tighten or loosen that floor per request. Every grade has a receipt (the post id, the capture time, the pool and the three prices it was graded on): the latest calls are on the account's free report card, the newest 100 at GET /caller/{handle}/calls. The rules are on the methodology page.
Timing: the accounts the stream carries are watched directly, so their calls usually reach the API within minutes of the post. Telegram messages are usually captured within seconds of being posted and counted in the signal inside its 5-minute window.
A loop that polls the stream with its cursor, runs the pre-trade check on each token, and hands the rest to your own rules. Node 18+, no dependencies. The check client is a single file: curl -O https://robinx.io/clients/robinx.mjs (Python: robinx.py, standard library only).
// bot.mjs — poll the measured-caller stream, check each token, decide with your own rules
import { check } from './robinx.mjs'; // https://robinx.io/clients/robinx.mjs
const API = 'https://api.robinx.io';
const KEY = process.env.ROBINX_KEY; // an Alpha or Omega key; without one the stream answers 402 with an x402 offer ($0.02 a call) this loop does not pay
const headers = { accept: 'application/json', ...(KEY ? { 'x-robinx-key': KEY } : {}) };
let cursor = null;
for (;;) {
const q = new URLSearchParams({ min_rank_score: '0.3', limit: '25' }); // 0.3 = grade B or better
if (cursor) q.set('since', cursor); // the exact cursor string the API returned
const r = await fetch(`${API}/signals/calls?${q}`, { headers }).then((x) => x.json());
if (!r.data) console.error(r.error || 'no data: a key or an x402 client is needed');
for (const call of r.data?.calls || []) {
const c = await check(call.token, { key: KEY }); // blockers, warnings, the readings behind them
if (!c.clear) continue; // a rule fired: this bot skips the token (your rule, not advice)
// call.caller.early_rate, call.caller.rank_score, call.tg_led (Omega keys), c.checks.callers.best are inputs; your sizing, your execution, your wallet.
}
cursor = r.data?.cursor || cursor;
await new Promise((s) => setTimeout(s, 30_000));
}The same stream from a shell, to see the shape first:
curl -s "https://api.robinx.io/signals/calls?min_rank_score=0.3&limit=25" -H "x-robinx-key: $ROBINX_KEY"Python, the pre-trade check alone:
from robinx import check # copy robinx.py next to your bot
r = check("0x020bfc650a365f8bb26819deaabf3e21291018b4")
if r.get("paywall"):
print("402:", r["price_usd"], r["key_offer"]) # past the free 100 a day: the x402 offer and the key offer, not an exception
elif not r["clear"]:
print("blocked:", r["blockers"]) # rule-based blockers: never a recommendation
else:
print("warnings:", r["warnings"], "best caller:", r["checks"]["callers"]["best"])The check is free for 100 calls a day per IP; past that the API answers 402 with an x402 offer ($0.02 USDC on Base) and the key offer, and both clients return that answer instead of throwing, so a bot can decide what to do.
| Delivery | How | Who it fits |
|---|---|---|
| Poll | GET /signals/calls with the cursor; GET /feed/new?tier=alpha for launches with the caller signal; GET /genesis/crowds for the tokens several wallets just bought. Unlimited fair-use polling on a plan key. | A bot with its own loop. |
| Push | Signed webhooks on the Omega plan: fresh calls from grade-B-or-better accounts, the Omega signal, watched-token structure flips. Each delivery carries X-RobinX-Signature (HMAC-SHA256, with a timestamp) and an event_id; a failed delivery is retried for up to an hour with the same event id, so your bot can drop repeats and process each event once. The signing scheme. | A bot that must not poll. |
| MCP | https://api.robinx.io/mcp for Claude, ChatGPT, Cursor, the xAI API or any MCP client: the same calls, report cards and token checks as tools; the free tools need no key, the streams take the key of their plan. A Grok Bot reads the same API through the RobinX skill. The MCP server page. | An agent that reasons before it acts. |
| x402 | No account, no key: the request carries a USDC payment on Base. /signals/calls and /check $0.02 a call, /omega/signals $0.05. Every 402 answer names the price and the key offer. | An agent with a wallet and no signup. |
What one key opens, in 35 seconds: the same film as the homepage. It loads only when it scrolls into view.
/agent/features row; 2,000 token reports a day; five times the rate limits. Founders rate, kept while you stay subscribed; new Alpha subscriptions are $39 after 31 December 2026.Plans and keys Endpoint reference
RobinX. It captures the X posts that name a Robinhood Chain token, grades each caller against the on-chain price that followed, counts the Telegram rooms that carried the token, and streams the calls of measured callers to your bot over REST (GET /signals/calls), signed webhooks, MCP (api.robinx.io/mcp) or x402. Observations with receipts, not advice.
On the Omega plan, set a webhook at POST /alerts/webhook and try it with POST /alerts/test. When a grade-B-or-better caller posts a token's contract address, the call is pushed (one per account and token a day; daily caps apply) with the caller's record, the deployer record, LP custody and whether Telegram carried the token first; the Omega signal event adds the Telegram room count when X and three or more rooms converge. Every delivery is HMAC-SHA256 signed and carries an event id; a failed delivery is retried for up to an hour with the same id.
Yes: https://api.robinx.io/mcp, for Claude, ChatGPT, Cursor, the xAI API or any MCP client, with the same calls, report cards and token checks as tools. Claude.ai and ChatGPT connect through api.robinx.io/mcp/account with the key of a plan; the free tools need no key.
Every graded call carries its receipt: the post id, the capture time, the pool it was graded on and the three prices (before the post, at the post, an hour after). Deleted posts stay graded. The grades are computed by one published rulebook, the same for every account, on the methodology page; the board at robinx.io/callers shows the record before the follower count.
No. It publishes measurements. Your bot reads them, applies its own rules, and signs its own transactions.
Calls, checks and signals are rule-based observations from public on-chain and X data and counted Telegram rooms: inputs for your own model or bot, not predictions, recommendations or financial advice. Paper results are never a track record. RobinX never holds your funds or keys, never takes orders and never trades for you. RobinX is independent and not affiliated with, endorsed by or sponsored by Robinhood Markets, Inc. Terms.
robinx.io Signals API KOL tracker Rug checker MCP server Integrations