No keys needed. Pay per call — or one key, one flat fee.
Every signal on this site is an HTTP GET. The free tier needs nothing — no signup, no key. Paid endpoints return HTTP 402 with payment requirements; settle USDC on Base over the x402 protocol and retry. Agents with a funded wallet do this automatically.
Try it right now — free, from your terminal
curl https://api.robinx.io/caller/gleobets
# full report for the real $CASHCAT (free, 25/day)
curl "https://api.robinx.io/report/0x020bfc650a365f8bb26819deaabf3e21291018b4?tier=free"
# who is this wallet? deployer record + insider history (free)
curl https://api.robinx.io/wallet/0xcdfc08a1c1fbafb355645e5ddc32122e5716ca90
# resolve a ticker — collision warnings included (free)
curl "https://api.robinx.io/search?q=cashcat"
What RobinX measures
Measured caller accuracy and labeled holder-structure history — built from watching every block and every mention since chain genesis. The idea is copyable; the elapsed time isn't.
| Endpoint | What it answers | Price |
|---|---|---|
| GET /agent/features?token= | The agent feature row. The token-level measurements for one token in a single call — launch facts, current activity (plus the exact is_real crossing block, recovered back to chain genesis), deployer record, price/FDV with its true observation time, and social measurements (exact mention counts, distinct accounts, 24h velocity, how many are measured callers, coordinated cluster share). Split by epistemic status so you can't accidentally join current state to a past timestamp. Inputs for your model — no score, no recommendation. | $0.03 |
| GET /social/follows | Pollable tape of follow/unfollow transitions by the chain's principal X accounts — X exposes only current state, so this history can't be rebuilt later. Each followed handle crossed with its measured caller record | $0.02 |
| GET /follows/{handle} | Which watched principals follow this handle, and since when — baseline edges marked, never dated as follows | free |
| GET /mentions/{token} | The social tape for one token: latest mentions with each caller's measured record, true totals, 24h velocity, cluster-vs-independent voices (never tweet text) | $0.02 |
| GET /caller/{handle}/calls | The receipts behind the free card — each call with its post id, capture time, pool, the three prices its grade is made of, the grade or why there is none, token outcome, cross-chain records | $0.02 |
| GET /social/momentum | Tokens ranked by measured caller-accuracy weight, then voices, then mentions (clusters count once) | $0.02 |
| POST /identify | Paste a chart screenshot — vision extracts ticker/price/date/chain and resolves which token it is, with a confidence meter | free 5/day then $0.02 |
| GET /callers | Measured X caller leaderboard ordered by rank score (the 95% lower confidence bound on the early rate): early rate, median 1h price move, graded calls, evidence label, cluster flags. The rules · human UI: robinx.io/callers | $0.01 |
| GET /caller/{handle} | One handle's measured track record — early rate, rank score and evidence, median 1-hour price move, cluster status, the rules | free · rate-capped |
| GET /signals/calls | Pollable stream of fresh calls by measured early-callers — the call, the token, the caller's track record | $0.02 |
| GET /omega/signals | The Omega signal: tokens where X and Telegram converged (an X call and three or more Telegram rooms within 60 minutes), with the X receipts, our checks when it was recorded and the measured outcome at +1 h, +6 h and +24 h. Rooms counted, never named; times rounded to 5 minutes. The rule | Omega $49/mo · $0.05 |
| GET /genesis/crowds | Genesis wallet crowds: the tokens several distinct wallets each bought in the last hour (a buy of at least 0.05 WETH by default), from our wallet tape — wallets, buys, WETH, a launch-template flag. Counts only, wallets never identified | $0.02 |
| GET /feed/new?tier=alpha | Launches + caller_signal in one pollable stream | $0.02 |
| GET·POST /structure/{token} | Labeled holder-structure diff: who froze / added / trimmed / exited over ~24h, wallets stamped with insider + deployer + ENS/Farcaster identity — rotation vs distribution vs accumulation | POST queue free results $0.03 |
| GET /structure/{token}/smart-holders | Holders with measured extraction history — a signal with ambiguous direction, not a buy call | $0.05 |
| GET /entity/{address} | One entity's appearances across tokens, multi-wallet identities collapsed | $0.05 |
| GET /pulse/{token} | X synthesis: narrative, sentiment, proven-caller activity | $0.04 |
| GET /structure/{token}/history | Longitudinal holder-snapshot history — the archive nobody can rebuild later | Omega $49/mo |
| GET·POST·DEL /watchlist/{token} | Watch up to 10 tokens — automatic daily structure scans, results included | Omega $49/mo |
| GET·POST·DEL /alerts/webhook | Signed webhook push: fresh caller-calls + watched-token structure flips + proven-deployer launches (POST /alerts/test to try it) | Omega $49/mo |
The pre-trade check in one call
GET /check/{token} answers the question a bot asks before a buy, flat enough for an if: clear is true when none of the named rules fired, otherwise blockers says which did (verdict avoid or serial spammer, a Robinhood stock look-alike, liquidity withdrawn on custody plans, no live market) and warnings names the rules that fired without blocking (a mixed verdict, a first launch, a wallet-held pool, no price yet or a stale one, concentrated holders, thin activity, no measured caller or only a coordinated cluster). Every reading behind them travels in checks. Free under a daily per-IP cap of 100, $0.02 over x402 past it, every plan key covers it. Rule-based observations from public data, never a recommendation.
curl -s https://api.robinx.io/check/0x020bfc650a365f8bb26819deaabf3e21291018b4 | jq '.data | {clear, blockers, warnings}'
# Node 18+, no dependencies: fetch the file once (Deno and browsers can import the URL directly)
curl -O https://robinx.io/clients/robinx.mjs
import { check } from './robinx.mjs';
const r = await check(token, { key: process.env.ROBINX_KEY });
if (r.paywall) { /* 402: r.price_usd, r.key_offer */ } else if (!r.clear) skip(r.blockers); else log(r.warnings);
# Python 3.8+, standard library: https://robinx.io/clients/robinx.py
from robinx import check
r = check(token)
if not r["clear"]: skip(r["blockers"])
Verifying a webhook delivery
Every delivery carries X-RobinX-Signature: t=<unix seconds>,v1=<hex>, where v1 is HMAC-SHA256 of the string <t>.<raw body> keyed with the secret shown once when the hook is created (POST /alerts/webhook). Compute it over the raw bytes you received, compare in constant time, and reject a t older than a few minutes.
Every event carries event_id in its signed body; the X-RobinX-Event-Id and X-RobinX-Retry headers repeat it for convenience and are not covered by the signature. The first attempt is repeated once after 5 seconds if it gets no answer within 8 seconds or a 5xx. An alert that is still not accepted is sent again about 2, 10, 30 and 60 minutes after the first attempt (a structure_flip also at about 3 and 12 hours), with the same event_id and delivery{retries, first_attempt_at, delayed_seconds}, when the failure can pass by itself (no answer, a 408, 425, 429 or a 5xx) and the endpoint is not failing. So the same event_id can arrive more than once: verify the signature, process each event_id once, and read delivery.delayed_seconds before acting on a late event.
Any other answer outside 2xx (a redirect, 401, 404, 410 and the like) is not retried. GET /alerts/webhook returns health for your endpoint, and POST /alerts/test sends a signed test event.
The standard toolkit
| Endpoint | What it answers | Price |
|---|---|---|
| GET /check/{token} | The pre-trade check in one call: clear or the named blockers and warnings, with the readings behind them (drop-in clients below) | free, 100/day per IP · $0.02 |
| GET /report/{token} | The full report: verdict + deployer track record + measured X callers + forensics status. Add ?tier=free for the free tier | free 25/day with ?tier=free $0.05 x402 |
| GET /wallet/{address} | Wallet reputation: deployer record + insider-flow history | free |
| GET /search?q= | Token lookup by $symbol / name / address, with fake-ticker collision warnings | free |
| GET·POST /forensics/{token} | Deep supply-flow scan: mint pattern, deployer flows, off-market recipients, price history | free |
| GET /verdict/{token} | Composite buy-risk verdict — works on a token seconds old | $0.02 |
| GET /deployer/{address} | Deployer track record + 0–100 score | $0.01 |
| GET /token/{address} | Token stats + linked deployer score | $0.01 |
| GET /feed/new | Pollable live launch feed, each launch scored on the deployer’s other launches (?min_score=70 for the strongest records; ?tier=free for the 10-min-delayed window) | $0.01 delayed free |
| GET /leaderboard | Top trusted deployers | $0.01 |
| GET /stats · /basket · /proof.json | Coverage stats · live forward paper-basket · calibration proof | free |
Machine-readable: openapi.json · x402 catalog · llms.txt
Agents · x402
const r = await pay(
"https://api.robinx.io/verdict/" + token
);
Requirements ride in the PAYMENT-REQUIRED header (base64 JSON). Settles USDC on Base (eip155:8453).
Claude / Cursor · MCP
# or hosted: https://api.robinx.io/mcp
23 tools — including robinx_agent_features (the feature row), robinx_follows (the principal follow tape), robinx_identify (chart screenshot → token), plus report, verdict, structure, wallet, search, pulse, feed, callers, leaderboard, basket, stats, deployer and token. Fund ROBINX_WALLET_KEY for auto-pay. Listed in the Official MCP Registry.