# Crius Docs (full text) > Every page of https://docs.crius.sh in one Markdown file. Index: https://docs.crius.sh/llms.txt # Authentication & API keys > How to authenticate Crius API requests with the x-api-key header, key scopes, IP allow-lists, browser origins, expiry, rotation with a grace period, and dashboard sessions. Source: https://docs.crius.sh/authentication/ · Updated 2026-10-28 Send your API key in the **`x-api-key`** header on every request: Terminal window ```bash curl "https://api.crius.sh/v1/robinhood/stats" -H "x-api-key: $CRIUS_API_KEY" ``` WebSocket clients that can’t set headers may pass it as a query parameter instead: `wss://api.crius.sh/v1/robinhood/stream?api_key=…`. Requests **without a key** are allowed for the core endpoints (prices, tokens, pools, trades, candles, search, stats) under the anonymous plan: 2 requests per second per client IP, read-only. Everything else needs a key. ## Key format Keys look like `crs_live_AbCd1234_`: - `crs` identifies a Crius key (handy for secret scanners); - `live` or `test` is the key’s environment label; - `AbCd1234` is the public **prefix** shown in your dashboard and in emails; - the rest is the secret. It is shown **once** when the key is created. We store only a salted SHA-256 hash, so a lost key can’t be recovered: rotate it. An account can have up to **20 active keys**. Credits and plan limits belong to the account and are shared by all its keys. ## Scopes | Scope | Allows | | --- | --- | | `read` | All REST data endpoints your plan includes | | `stream` | The WebSocket stream (also implies `read`) | | `simulate` | Fresh on-demand security simulations (`/security?fresh=1`) | | `export` | Bulk exports (reserved) | The key issued when you sign up has `read`, `stream` and `simulate`; keys you create get `read` and `stream` unless you choose otherwise. Account management (keys, wallets, billing) is never possible with an API key: it needs a signed-in dashboard session, so a leaked key can read data but can’t take over your account. ## Restricting a key Every key can be narrowed in the dashboard or through the [Account API](https://docs.crius.sh/reference/account/): - **IP allow-list**: one or more IPs or CIDR ranges (`203.0.113.7`, `10.0.0.0/8`, IPv6 too). Requests from anywhere else get `403 ip_not_allowed`. - **Allowed origins**: browser origins such as `https://app.example.com`. A key with origins becomes **read-only** and only works from those pages (`403 origin_not_allowed` otherwise). Use this for keys that must live in front-end code. - **Rate limit**: a per-key requests-per-second cap below your plan’s limit, so one service can’t starve another. - **Expiry**: the key stops working after a number of days (`401 key_expired`). ## Rotating a key Rotation issues a new secret and keeps the old one working for a **grace period** (1 hour by default, up to 7 days) so you can deploy the new key without downtime. After the grace period the old key returns `401 key_rotated`. Revoking a key stops it immediately (`401 key_revoked`), on every region within seconds. ## Dashboard sessions Signing in at [dashboard.crius.sh](https://dashboard.crius.sh) (email code or a linked wallet) creates a **session key** that lasts 7 days. Session keys can only call the Account API; using one on a data endpoint returns `403 session_not_api_key`. API keys calling account-management endpoints get `403 session_required`. ## Failed authentication Invalid keys get `401 invalid_key`. After 20 failed attempts in a minute from one IP, that IP is blocked for 60 seconds (`429 auth_banned`). Treat keys like passwords. Don’t put an unrestricted key in browser code, mobile apps or public repositories. If a key leaks, revoke or rotate it in the dashboard; we also email you whenever a key is created, rotated or revoked. --- # Responses & conventions > The Crius API response envelope, meta block, number and amount formats, timestamps, addresses, pagination, finality levels and liquidity and market-cap definitions. Source: https://docs.crius.sh/conventions/ · Updated 2026-10-28 ## The envelope Every successful response is a JSON object with `data` and `meta`: ```json { "data": { "symbol": "WETH", "usd": 2381.97 }, "meta": { "chain": "robinhood", "block": 95503718, "block_ts": 1792712926000, "block_age_ms": 1050, "lag_ms": 37, "safe_block": 95497061, "finalized_block": 95493649 } } ``` | `meta` field | Meaning | | --- | --- | | `block` | The latest L2 block the data reflects | | `block_ts` | That block’s timestamp (unix ms) | | `block_age_ms` | How old that block is | | `lag_ms` | How long ago our index applied it | | `safe_block` | Latest block whose batch is posted to Ethereum | | `finalized_block` | Latest block finalized on Ethereum | | `next_cursor` | On paginated lists: pass it as `?cursor=` for the next page | Errors use `{"error": {"code": "…", "message": "…"}}` with a matching HTTP status. See [Errors](https://docs.crius.sh/errors/). ## Numbers and amounts - **USD values, prices and ratios** are JSON numbers, always in **plain decimal notation** (`0.00000576413`, never `5.76e-6`), rounded to 6 significant digits. - **Token amounts** are in human units (already divided by the token’s decimals). - **Percentages** are 0–100 (`12.5` means 12.5%). - `liquidity_usd` is **2 × the quote side** of a pool (the convention DEX screeners use). `quote_liquidity_usd` is the real quote amount sellers could withdraw. For bonding curves only the real quote raised counts. - `market_cap_usd` = price × (total supply − tokens burned at `0x0` or `0x…dEaD`), with unsold bonding-curve tokens included. `fdv_usd` = price × total supply. ## Time - Every `*_ts` field is **unix milliseconds** (UTC). - Stats windows: `1s`, `30s`, `1m`, `5m`, `1h`, `4h`, `6h`, `24h`, plus `all_time` totals. - Candle intervals: `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h`, `1d`. - Robinhood Chain produces a block roughly every 100 ms. Inside contracts, `block.number` is the **Ethereum L1** block (about 12 s), which is why per-block contract rules (anti-snipe, sell throttles) act on L1 blocks; responses expose both `block` and `l1_block` where it matters. ## Addresses Addresses are accepted in any case and always returned **lowercase**. Native ETH is `0x0000000000000000000000000000000000000000` with symbol `ETH`. Uniswap v4 pools are identified by their 32-byte pool id. ## Token logo and links A token’s logo and links have one shape on every endpoint. They come from the token’s own metadata first (its launch, its on-chain metadata URI, its verified source), with its DexScreener profile filling any gaps. - **The token profile** (`/token/{address}`) has the full object in `metadata`: ```json "metadata": { "logo": "https://…/logo.png", "banner": "https://…/header.png", "description": "…", "links": { "website": "https://…", "twitter": "https://x.com/…", "telegram": null, "discord": null, "farcaster": null, "github": null }, "sources": { "logo": "metadata_uri", "links": "launch" } } ``` - **Lists and search** (`/tokens`, `/search`) carry the same `logo` and `links` on each row. - **Any token inside another object** (pool sides, trades, wallet holdings, launch pairs, liquidity events, prices, WebSocket trades) carries the same `logo` next to its `address` and `symbol`. `links` always has all six keys, `null` when unknown, so you can read `links.twitter` without checking the shape. `metadata.socials` (one `{url, source}` object per platform) and `dexscreener.profile` remain for existing integrations; new code should read `metadata.logo` and `metadata.links`. ## Pagination Lists take `limit` (each endpoint documents its maximum, usually 500) and return `meta.next_cursor` when there is more. Pass it back as `cursor`; cursors are opaque and stable. ## Finality Every event (trade, transfer, liquidity change) carries a `finality` level: | Level | Meaning | | --- | --- | | `latest` | Confirmed by the Robinhood Chain sequencer (sub-second) | | `safe` | Its batch has been posted to Ethereum | | `finalized` | Finalized on Ethereum | Most apps can use `latest`. If you need settled data only, filter by finality where an endpoint supports it, or subscribe to the stream with `"finality": "safe"`. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/). ## History Fields marked `history: "partial"` or `since_index_start` cover data from when our index started for that item; they become complete once the history backfill reaches it. Profiles show `history: "complete"` once everything is indexed. --- # Errors > Crius API error format, HTTP status codes and every error code with its meaning and what to do about it. Source: https://docs.crius.sh/errors/ · Updated 2026-10-28 Errors return a non-2xx HTTP status and a JSON body: ```json { "error": { "code": "plan_required", "message": "This endpoint needs an API key (Free plan or higher); you called it without one. To use it, get a free API key at https://dashboard.crius.sh.", "plan": "anon", "required_plan": "free", "upgrade_url": "https://dashboard.crius.sh", "docs_url": "https://docs.crius.sh/plans-and-limits/" } } ``` Match on `error.code` (stable, machine-readable); `message` is for humans and may change. Plan and limit errors also carry the fields shown here (see [Plans & limits](https://docs.crius.sh/plans-and-limits/#rate-limit-headers)). ## Authentication and access | Status | Code | Meaning | What to do | | --- | --- | --- | --- | | 401 | `key_required` | This endpoint needs a key and none was sent | Send `x-api-key` | | 401 | `invalid_key` | The key doesn’t exist or the secret is wrong | Check for typos or a truncated key | | 401 | `key_rotated` | The key was rotated and its grace period ended | Use the new key | | 401 | `key_revoked` | The key was revoked | Create a new key | | 401 | `key_expired` | The key passed its expiry date | Create a new key | | 403 | `account_suspended` | The account is suspended | Contact [support@crius.sh](mailto:support@crius.sh) | | 403 | `plan_required` | Your plan doesn’t include this endpoint (`required_plan` says which does) | Get a key or upgrade at `upgrade_url`, see [plans](https://docs.crius.sh/plans-and-limits/) | | 403 | `scope_required` | The key lacks the scope (`stream`, `simulate`) | Edit the key’s scopes | | 403 | `ip_not_allowed` | The client IP isn’t in the key’s allow-list | Update the allow-list | | 403 | `origin_not_allowed` | The browser origin isn’t allowed for this key | Add the origin to the key | | 403 | `session_required` | Account management needs a dashboard session | Use the dashboard | | 403 | `session_not_api_key` | A dashboard session was used on a data endpoint | Use an API key | ## Limits | Status | Code | Meaning | What to do | | --- | --- | --- | --- | | 429 | `rate_limited` | Over your requests-per-second limit (the body has `limit_rps`, `burst`, `retry_after_ms`) | Wait `retry-after` seconds, then retry; or use a key / bigger plan (`upgrade_url`) | | 429 | `quota_exceeded` | Monthly credits used up (the body has `monthly_credits` and `resets`) | Upgrade (`upgrade_url`) or wait for the reset date | | 429 | `auth_banned` | Too many failed authentications from this IP | Wait 60 s and fix the key | | 503 | `busy` | Too many heavy analytics requests in flight | Retry shortly with backoff | ## Requests | Status | Code | Meaning | | --- | --- | --- | | 400 | `invalid_address` | Not a valid `0x` address | | 400 | `invalid_pool` | Not a valid pool address or v4 pool id | | 400 | `invalid_interval` | Unsupported candle interval | | 400 | `invalid_window` | Unsupported stats window | | 400 | `invalid_cursor` | The cursor is malformed or from another list | | 400 | `invalid_at` | The point in time (`at`, `from`, `to`) couldn’t be parsed | | 400 | `invalid_list`, `invalid_sort`, `invalid_tz` | An unsupported option | | 400 | `too_many_tokens` | More than 100 tokens in a batch | | 400 | `window_too_large` | The requested time window is too large for this endpoint | | 400 | `token_too_active` | The token has too much history for this query (holder history) | | 400 | `invalid_request` | Malformed query string or body | | 413 | `payload_too_large` | Request body over 256 KB | ## Not found | Status | Code | Meaning | | --- | --- | --- | | 404 | `chain_not_found` | Unknown chain slug or id | | 404 | `token_not_found` | We have no token at this address | | 404 | `pool_not_found` | No such pool | | 404 | `wallet_not_found`, `dev_not_found` | No activity for this address | | 404 | `hook_not_found`, `launch_not_found`, `launchpad_not_found` | No such hook, launch or launchpad | | 404 | `point_not_found` | The point in time (`mcap:`, `graduation`…) never happened for this token | | 404 | `not_ready` | The data is still being indexed; retry shortly | | 404 | `stream_unavailable` | The stream isn’t enabled on this node | ## Server | Status | Code | Meaning | | --- | --- | --- | | 500 | `internal` | Something broke on our side; it is logged. Retry, and contact support if it persists | | 504 | `timeout` | The request took longer than 10 seconds | Check [status.crius.sh](https://status.crius.sh) for ongoing incidents. --- # Chart example > Draw a live candlestick and volume chart for any Robinhood Chain token with the Crius candles endpoint and TradingView Lightweight Charts, with full source code. Source: https://docs.crius.sh/examples/chart/ · Updated 2026-10-28 A live candlestick chart with volume for any Robinhood Chain token (here Tesla’s tokenized stock, TSLA), built on [`/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) and [TradingView Lightweight Charts](https://github.com/tradingview/lightweight-charts). Paste any token address or pick an interval; it refreshes every 15 seconds. - **TSLA** Tokenized stock - **NVDA** Tokenized stock - **CHARGE** Pons token - **WETH** Wrapped ETH Token address **TSLA** Loading… ## The code The candles endpoint returns **columnar** arrays (`t`, `o`, `h`, `l`, `c`, `v`), which map straight onto chart series: ```html
``` ## Make it real-time Polling works, but the [WebSocket stream](https://docs.crius.sh/reference/stream/) pushes the live candle as trades happen. Subscribe to `candles::` and update the last bar: ```js // Run this where your key is safe (your backend, a desktop app), never in a public page. const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); ws.onopen = () => ws.send(JSON.stringify({ op: "subscribe", channels: [`candles:${token}:15m`] })); ws.onmessage = (e) => { const m = JSON.parse(e.data); if (!m.ch.startsWith("candles:")) return; const c = m.data; candles.update({ time: c.t / 1000, open: c.o, high: c.h, low: c.l, close: c.c }); volume.update({ time: c.t / 1000, value: c.v }); }; ``` Meme tokens trade at tiny prices. Set the series’ `priceFormat.precision` from the last close (for example 10 decimals for $0.0000057) so the axis stays readable. Use `currency=quote` to chart in the pool’s quote token (ETH) instead of USD. --- # Real-time stream example > A complete reconnecting WebSocket client for the Crius stream in Node.js - subscribe to new launches, trades and prices on Robinhood Chain, resume after disconnects and handle reorgs. Source: https://docs.crius.sh/examples/stream/ · Updated 2026-10-28 This client subscribes to every new launch and graduation plus the trades of one token, reconnects with backoff, resumes the messages it missed, and undoes reorged events. It runs on Node.js 22+ (built-in `WebSocket`) with a key that has the `stream` scope. ```js // stream.mjs: node stream.mjs const KEY = process.env.CRIUS_API_KEY; const TOKEN = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const CHANNELS = ["launches:all", "graduations:all", `trades:${TOKEN}`, `price:${TOKEN}`]; const lastSeq = {}; // channel -> last seq seen, for resuming let backoff = 1000; function connect() { const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); // heartbeats come every 15 s }; ws.onopen = () => { backoff = 1000; touch(); ws.send(JSON.stringify({ op: "subscribe", channels: CHANNELS })); if (Object.keys(lastSeq).length) ws.send(JSON.stringify({ op: "resume", seqs: lastSeq })); }; ws.onmessage = (e) => { touch(); const m = JSON.parse(e.data); if (m.seq) lastSeq[m.ch] = m.seq; switch (true) { case m.ch === "reorg": console.warn(`reorg: blocks ${m.data.removed_blocks.join(", ")} replaced`); break; case m.data?.removed: console.warn(`undo ${m.ch} ${m.data.id}`); // reverse whatever you did for this event id break; case m.ch.startsWith("launches:"): console.log(`new ${m.data.launchpad} token ${m.data.address} by ${m.data.creator}`); break; case m.ch.startsWith("graduations:"): console.log(`graduated ${m.data.token} → pool ${m.data.pool}`); break; case m.ch.startsWith("trades:"): console.log(`${m.data.type} $${m.data.value_usd} by ${m.data.trader}`); break; case m.ch.startsWith("price:"): console.log(`price $${m.data.usd}`); break; case m.ch === "error": console.error(m.data); break; } }; ws.onclose = () => { clearTimeout(idle); setTimeout(connect, backoff + Math.random() * 500); backoff = Math.min(backoff * 2, 30_000); }; ws.onerror = () => ws.close(); } connect(); ``` The replay buffer holds 60 seconds of messages. After a longer outage, re-sync from REST (for example [`/trades`](https://docs.crius.sh/reference/trades/trade-tape/) since your last `ts`) before relying on the stream again. ## Browser version Browsers can’t set headers on WebSockets, so the key would have to go in the URL (`?api_key=`), where anyone can read it from your page. Connect from your backend instead and forward the events to your page (for example over Server-Sent Events). Keys restricted to browser origins are read-only and can’t open the stream. --- # Plans, limits & credits > Crius API plans (Free, Starter, Pro, Business, Enterprise), monthly credits, requests per second, WebSocket limits, credit cost per endpoint and the rate-limit response headers. Source: https://docs.crius.sh/plans-and-limits/ · Updated 2026-10-28 Every plan has a **rate limit** (requests per second, with a burst of twice that), a **monthly credit quota**, WebSocket limits and a set of endpoints. Each request costs a number of **credits** depending on the endpoint; cheap calls such as prices cost 1. **How the rate limit works:** each key (or, without a key, each IP address) has a bucket that holds up to twice its per-second limit and refills at that limit. A Free key (10 requests/s) can send 20 requests at once, then 10 every second. The Account API has its own limit and is never counted. **Getting a key or a bigger plan:** a Free key takes a minute at [dashboard.crius.sh](https://dashboard.crius.sh) (email or wallet, no card). Upgrades are on the dashboard’s [Billing page](https://dashboard.crius.sh/billing); for more than Business, write to [support@crius.sh](mailto:support@crius.sh). ## Plans | Plan | Price | Credits / month | Requests / s | WebSockets | Subscriptions | | --- | --- | --- | --- | --- | --- | | Anonymous (no key) | free | n/a, per IP | 2 | none | none | | **Free** | $0 | 1,000,000 | 10 | 1 | 10 | | **Starter** | $19 / month | 10,000,000 | 25 | 3 | 100 | | **Pro** | $79 / month | 50,000,000 | 75 | 10 | 1,000 | | **Business** | $249 / month | 200,000,000 | 200 | 50 | 10,000 | | **Enterprise** | custom | custom | custom | custom | custom | Paying for 6 months gives 10% off, and 12 months 20% off. Plans are paid on-chain on Robinhood Chain in USDG, ETH or WETH; see [Billing & payments](https://docs.crius.sh/reference/billing/). Credits reset at the start of each UTC month and are shared by all of an account’s keys. ## Endpoints by plan | Plan needed | Endpoints | Credits per call | | --- | --- | --- | | Anonymous | token profile, price, batch prices, batch profiles, pools, pool, token lists, search, stats, volume, launchpads, security (cached) | 1 | | Anonymous | trades, candles, launchpad detail | 2 | | Public | status, chains | 0 (not counted against any limit) | | Free | holders, launch, activity feed, hooks, hook detail | 2 | | Free | holder snapshot, top traders, liquidity & locks, developer profile | 5 | | Free | WebSocket stream (per connection) | 1 | | Starter | wallet profile, wallet trades, fees & claims | 5 | | Starter | holder cohort, holder history, bundles, bubble map, wallet connections | 10 | | Starter | fresh security simulation (`/security?fresh=1`) | 20 | | Enterprise | `firehose:trades` stream channel (every trade on chain) | | Each endpoint page in the [API reference](https://docs.crius.sh/reference/tokens/) shows its plan and cost. Calls to the Account API (`/v1/account/*`) are **free** and don’t count against your credits. ## Rate-limit headers Every data response carries: | Header | Meaning | | --- | --- | | `x-ratelimit-limit` | Your requests-per-second limit for this key | | `x-ratelimit-remaining` | Requests left in the current burst | | `x-ratelimit-reset` | Milliseconds until the bucket refills (1000) | | `x-credits-cost` | Credits this request cost | | `x-quota-remaining` | Credits left this month (after this request) | When you go over the rate limit you get **`429 rate_limited`** with a `retry-after` header (seconds). When the month’s credits run out you get **`429 quota_exceeded`** until the next month, or until you upgrade. Both say what your limit is and how to raise it: ```json { "error": { "code": "rate_limited", "message": "Rate limit reached: requests without an API key are limited to 2 per second per IP (bursts of up to 4). Retry in 1 s, or get a free API key (10 requests/s, 1,000,000 credits a month) at https://dashboard.crius.sh.", "plan": "anon", "limit_rps": 2, "burst": 4, "retry_after_ms": 412, "upgrade_url": "https://dashboard.crius.sh", "docs_url": "https://docs.crius.sh/plans-and-limits/" } } ``` | Field | Meaning | | --- | --- | | `plan` | The plan the request was checked against (`anon` without a key) | | `limit_rps`, `burst` | Your requests per second and the most you can send at once | | `retry_after_ms` | When the next request will be accepted | | `monthly_credits`, `resets` | (`quota_exceeded`) Your monthly credits and the UTC date they reset | | `required_plan` | (`403 plan_required`) The lowest plan that includes the endpoint | | `upgrade_url` | Where to get a key or a bigger plan | ## Handling 429 well ```js async function crius(path, tries = 4) { for (let i = 0; i < tries; i++) { const res = await fetch(`https://api.crius.sh${path}`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); if (res.status !== 429) return res.json(); const body = await res.json(); if (body.error?.code === "quota_exceeded") throw new Error("monthly credits used up"); const wait = Number(res.headers.get("retry-after") ?? 1) * 1000; await new Promise((r) => setTimeout(r, wait + Math.random() * 250)); } throw new Error("still rate limited"); } ``` Save credits Use batch endpoints (`/prices` and `/tokens/batch` take up to 100 tokens per call), use the WebSocket stream instead of polling, and cache responses for the time you can tolerate: `meta.block` tells you whether anything changed. ## Usage and alerts The dashboard shows usage per day and per endpoint, and `GET /v1/account/usage` returns the same data. We email you when you reach 50%, 80%, 90% and 100% of your monthly credits. --- # API playground > Try every Crius API endpoint from your browser: pick an endpoint, fill in parameters, send a live request to api.crius.sh and copy ready-made cURL, JavaScript and Python code. Source: https://docs.crius.sh/playground/ · Updated 2026-10-28 Pick an endpoint, adjust its parameters and press **Send request**. Requests go straight from your browser to `https://api.crius.sh`. Endpoints marked “No key needed” work anonymously (2 requests per second per IP); for the rest, paste an API key from your [dashboard](https://dashboard.crius.sh/signup?ref=docs-playground). Your key stays in this tab and is only sent to the API. Endpoints Filter endpoints Service - - - - Wallets - - - - Pools - - - Launchpads - - - - Tokens - - - - - - Discovery - - Wallet graph - - Trades - - - Holders - - - - - Security - - No endpoint matches. GET `/v1/{chain}/token/{address}/price` Parameters JSON body Authentication API key *optional for anonymous endpoints* Remember in this tab ``` Pick an endpoint and press “Send request”. Anonymous requests are limited to 2 per second. ``` ``` Send a request to see the response headers. ``` Every request shows its status, timing, credit cost and remaining rate limit, and the **cURL**, **JavaScript** and **Python** tabs give you the same call as code. --- # Quickstart > Create a free Crius account, get an API key and make your first Robinhood Chain API request with cURL, JavaScript or Python in under five minutes. Source: https://docs.crius.sh/quickstart/ · Updated 2026-10-28 1. **Create an account.** Go to [dashboard.crius.sh](https://dashboard.crius.sh/signup), enter your email and the one-time code we send you. The free plan needs no card and includes 1,000,000 credits a month. 2. **Create an API key.** In the dashboard, open **API keys** and create a key. Copy the secret straight away: it is shown once, and only a hash of it is stored. Keys look like `crs_live_AbCd1234_…`. 3. **Store the key in an environment variable.** Never put it in front-end code or commit it to git. Terminal window ```bash export CRIUS_API_KEY="crs_live_…" ``` 4. **Make your first request.** Get the price of Charge AI (CHARGE), a token that launched on Pons and graduated to a Uniswap v4 pool: **cURL** Terminal window ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", { headers: { "x-api-key": process.env.CRIUS_API_KEY } }, ); const { data, meta } = await res.json(); console.log(`${data.symbol} = $${data.usd} (block ${meta.block})`); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]["symbol"], body["data"]["usd"], "at block", body["meta"]["block"]) ``` 5. **Read the response.** Data is in `data`; `meta` tells you the block it was read at and how fresh it is. ```json { "data": { "symbol": "CHARGE", "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "usd": 0.00000576413, "eth": 0.0000000024199, "dex": "uniswap_v4", "liquidity_usd": 6861.07, "confidence": "medium", "thin_liquidity": false }, "meta": { "chain": "robinhood", "block": 95503718, "block_age_ms": 1050, "lag_ms": 37 } } ``` The response headers tell you your limits: `x-ratelimit-remaining`, `x-credits-cost` and `x-quota-remaining`. ## Next steps - Browse the [API reference](https://docs.crius.sh/reference/tokens/), or try endpoints live in the [playground](https://docs.crius.sh/playground/). - Draw a live chart with the [chart example](https://docs.crius.sh/examples/chart/). - Stream trades and new launches with the [WebSocket stream](https://docs.crius.sh/reference/stream/). - Learn how [credits and rate limits](https://docs.crius.sh/plans-and-limits/) work. Keep keys server-side An API key in a web page can be copied by anyone. For browser use, create a key restricted to your site’s origin (it becomes read-only) or proxy requests through your own backend. See [Authentication](https://docs.crius.sh/authentication/). --- # Add safety checks to a Robinhood Chain trading bot > Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts. Source: https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/ · Updated 2026-10-28 Short answer Before each buy, call `GET /v1/robinhood/token/{address}/security` (skip `risk: "critical"`, honeypots and taxes above your limit; read `flags` for unlocked or single-wallet liquidity) and `GET /v1/robinhood/token/{address}/price` (skip `thin_liquidity` and trades large against `quote_liquidity_usd`). That's 2 credits per check, anonymous plan. While you hold, subscribe to `tax:` and `lp:` for the token on the WebSocket stream. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) [GET `/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) [GET `/token/{address}/bundles`](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) A trading bot on Robinhood Chain needs to answer four questions before it buys: can it sell again, what will the round trip cost in taxes, can the liquidity disappear while it holds, and is the price real enough for the size it wants to trade. Crius answers the first three in one [security](https://docs.crius.sh/reference/security/security-checks/) call and the fourth in one [price](https://docs.crius.sh/reference/tokens/token-price/) call, both on the anonymous plan. While the bot holds a position, the WebSocket stream tells it when the token’s tax changes or liquidity is removed. ## Check 1: can the bot sell, and at what tax? Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A honeypot with 0% realized tax Let's End AI (0xc882f10529a5518ee3393af5a80e9ff00d38d44b) shows no tax on past trades. Should the bot buy? GET/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 140 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x0000000000000000000000000000000000000000", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": true, "upgradeable": false, "verified": "none" }, "flags": [ "honeypot", "unverified", "uniform_holders" ], "honeypot": { "is_honeypot": true, "reason": "simulated sell failed", "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "uniform_holders" ], "lp_top_wallet": { "address": "0xabe3a51937eb4c76ab6449e9823dbffd4409776f", "liquidity_usd": 8.58651, "pct": 0.0253312 }, "sniper_supply_pct": 0.000299049, "sniper_top_wallet_pct": 0.000299049, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": { "balance_pct": 0.112731, "holders": 51, "of_top": 100 }, "wallet_farm": null }, "limits": { "max_tx": "1000000000", "max_tx_getter": "maxTxAmount()", "max_tx_pct": 100, "max_wallet": "1000000000", "max_wallet_getter": "maxWalletSize()", "max_wallet_pct": 100 }, "liquidity": { "status": "burned", "summary": { "burned_pct": 99.9715, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0284848, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v2", "risk": "critical", "score": 0, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793224820000, "max_sell_pct_seen": 0, "samples": { "buys": 27197, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": { "amount_eth": 0.042454083286938696, "buy_gas": 159144, "buy_pct": 0, "can_buy": true, "can_sell": false, "can_transfer": true, "from": "eoa", "revert_reason": { "code": 3, "data": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000245472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c454400000000000000000000000000000000000000000000000000000000", "message": "execution reverted: TransferHelper: TRANSFER_FROM_FAILED" }, "router": "0x89e5db8b5aa49aa85ac63f691524311aeb649eba", "sell_gas": 229228, "sell_pct": null, "transfer_pct": 0 }, "source": "realized", "transfer_pct": 0 }, "tax_history": [ { "from_block": 62239227, "pct": 0, "side": "buy" }, { "from_block": 62240181, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b" }, "meta": { "block": 100406838, "block_age_ms": 1257, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 14, "safe_block": 100401329, "simulation": "eth_simulateV1 via Uniswap V2 router at head" } } ``` What this tells you - `risk: "critical"`, `score: 0`, `honeypot.is_honeypot: true` with `reason: "simulated sell failed"`. The bot must not buy. - The trap is invisible in the tax numbers: `tax.buy_pct` and `tax.sell_pct` are 0 and `tax.realized.samples` counts 27,197 buys and 3,423 sells. A bot that only checks realized tax would buy this token. - `tax.simulated` shows what happened at the head block: `can_buy: true`, `can_transfer: true`, `can_sell: false`, and the revert message `"execution reverted: TransferHelper: TRANSFER_FROM_FAILED"`. - `meta.simulation` names the method: `"eth_simulateV1 via Uniswap V2 router at head"`. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20honeypot%20with%200%25%20realized%20tax&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fadd-safety-checks-to-a-trading-bot%2F%23honeypot%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xc882f10529a5518ee3393af5a80e9ff00d38d44b%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Check 2: can the liquidity disappear? Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A $1 billion market cap backed by $3,795 in one wallet's hands MJDQ (0x124597e2d8bbe472825c4918a36de246ed0c92f7) ranks near the top by market cap. Is it safe to hold? GET/v1/robinhood/token/0x124597e2d8bbe472825c4918a36de246ed0c92f7/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x124597e2d8bbe472825c4918a36de246ed0c92f7/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x124597e2d8bbe472825c4918a36de246ed0c92f7/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x124597e2d8bbe472825c4918a36de246ed0c92f7/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 111 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "match" }, "flags": [ "lp_unlocked", "lp_single_wallet" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "lp_single_wallet" ], "lp_top_wallet": { "address": "0xe591376415858cae27c81c0813bbaef3a0a46d6a", "liquidity_usd": 3795.38, "pct": 100 }, "sniper_supply_pct": 0.000000291623, "sniper_top_wallet_pct": 0.000000291623, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "unlocked", "summary": { "burned_pct": 0, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 55, "tax": { "buy_pct": 0, "confidence": "medium", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1792087347000, "max_sell_pct_seen": 0, "samples": { "buys": 6, "sells": 4 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 89408576, "pct": 0, "side": "buy" }, { "from_block": 89421448, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x124597e2d8bbe472825c4918a36de246ed0c92f7" }, "meta": { "block": 100409718, "block_age_ms": 765, "block_ts": 1793225377000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 48, "safe_block": 100405028, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 55`, `risk: "medium"`, `flags`: `lp_unlocked` and `lp_single_wallet`. No honeypot, no tax, and the source is verified (`contract.verified: "match"`). - `launch.lp_top_wallet` is `0xe591376415858cae27c81c0813bbaef3a0a46d6a` with `pct: 100` and `liquidity_usd: 3795.38`: one wallet owns the whole pool and can withdraw it at any time (`liquidity.summary.unlocked_in_wallets_pct: 100`). - The tax is measured from only 6 buys and 4 sells (`tax.realized.samples`), so `tax.confidence` is `medium`, and `tax.simulated` is `null` (`meta.simulation`: `"no V2 WETH pair: realized tax only"`). - The token list shows this token with a market cap of about $1 billion and 4 holders. Size trades by liquidity, never by market cap. The [Telegram scanner guide](https://docs.crius.sh/guides/build-a-telegram-token-scanner/#after-pull) shows a token with the same two flags whose pool was emptied a minute after its check. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20%241%20billion%20market%20cap%20backed%20by%20%243%2C795%20in%20one%20wallet's%20hands&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fadd-safety-checks-to-a-trading-bot%2F%23single-wallet-lp%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x124597e2d8bbe472825c4918a36de246ed0c92f7%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The rules | Check | Field | Suggested rule | | --- | --- | --- | | Sellable | `honeypot.is_honeypot`, `risk` | Never buy `critical` or a honeypot; treat `honeypot.selective` (only some wallets can sell) the same | | Taxes | `tax.buy_pct`, `tax.sell_pct`, `tax.confidence` | Skip above your round-trip budget; require `high` confidence or a fresh simulation for size | | Launch | `flags`: `insider_launch`, `wallet_farm` | Skip: insiders sniped most of the supply, or the holders are a farm of wallets funded together | | Liquidity | `flags`: `lp_unlocked`, `lp_single_wallet`; `liquidity.summary` | Skip or cut size when one wallet can pull the pool | | Hook | `flags`: `hook_critical_risk`, `hook_high_risk` | Skip: the pool's v4 hook can block swaps, has no code, or its code family has a record of rugs or honeypots | | Price | `thin_liquidity`, `confidence`, `quote_liquidity_usd` | Skip thin or low-confidence prices; keep the trade a small share of the quote side | The thresholds are yours to choose. The fields are the same for every token, so the rules stay a few lines of code. ## Use it in your bot 1. **Check before every buy.** Call security and price in parallel (2 credits). Cache the result for a minute or two per token: a bot that fires several orders into the same token doesn’t need a new check for each. 2. **Re-simulate before large trades.** On Starter and above, `?fresh=1&amount_usd=` runs a new buy, transfer and sell simulation at your trade size (20 credits, `simulate` scope). 3. **Watch what you hold.** Subscribe to `tax:` and `lp:` on the stream for each open position. A tax change arrives as `side`, `from`, `to`; a liquidity removal as `type: "remove_liquidity"` with the pool, `provider` and amounts. 4. **Go deeper when it matters.** [Liquidity & locks](https://docs.crius.sh/reference/security/liquidity-locks/) (5 credits, Free) shows each LP position and unlock date; [snipers & bundles](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) (10 credits, Starter) shows who bought the launch. ```js // safety.mjs: pre-trade checks and position watch for a Robinhood Chain bot (Node.js 22+) const API = "https://api.crius.sh/v1/robinhood"; const KEY = process.env.CRIUS_API_KEY; const HEADERS = KEY ? { "x-api-key": KEY } : {}; const MAX_TAX_PCT = 5; const MAX_SHARE_OF_QUOTE = 0.01; // trade at most 1% of the pool's quote side const BLOCK_FLAGS = ["insider_launch", "wallet_farm", "hook_critical_risk", "hook_high_risk", "lp_single_wallet"]; const get = async (path) => (await (await fetch(`${API}${path}`, { headers: HEADERS })).json()).data; export async function preTradeCheck(token, sizeUsd) { const [s, p] = await Promise.all([get(`/token/${token}/security`), get(`/token/${token}/price`)]); const no = []; if (!s || !p) return { ok: false, reasons: ["no data for this token"] }; if (s.risk === "critical" || s.honeypot?.is_honeypot || s.honeypot?.selective) no.push(`can't sell: ${s.honeypot?.reason ?? s.risk}`); if ((s.tax?.buy_pct ?? 0) + (s.tax?.sell_pct ?? 0) > MAX_TAX_PCT) no.push(`round-trip tax ${s.tax.buy_pct}% + ${s.tax.sell_pct}%`); for (const f of s.flags ?? []) if (BLOCK_FLAGS.includes(f)) no.push(`flag ${f}`); if (p.thin_liquidity || p.confidence === "low") no.push(`unreliable price (${p.confidence})`); if (sizeUsd > (p.quote_liquidity_usd ?? 0) * MAX_SHARE_OF_QUOTE) no.push(`$${sizeUsd} is too large for $${p.quote_liquidity_usd} of quote liquidity`); return { ok: no.length === 0, reasons: no, score: s.score, priceUsd: p.usd }; } // Live alerts for open positions: tax changes and liquidity removals. export function watchPositions(tokens, onAlert) { const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); }; ws.onopen = () => { touch(); ws.send(JSON.stringify({ op: "subscribe", channels: tokens.flatMap((t) => [`tax:${t}`, `lp:${t}`]) })); }; ws.onmessage = (e) => { touch(); const m = JSON.parse(e.data); if (m.data?.removed) return; if (m.ch.startsWith("tax:")) onAlert({ token: m.data.token, kind: "tax", text: `${m.data.side} tax ${m.data.from}% → ${m.data.to}%` }); if (m.ch.startsWith("lp:") && m.data.type === "remove_liquidity") { onAlert({ token: m.ch.slice(3), kind: "lp", text: `liquidity removed from ${m.data.pool} by ${m.data.provider}` }); } }; ws.onclose = () => { clearTimeout(idle); setTimeout(() => watchPositions(tokens, onAlert), 2000 + Math.random() * 1000); }; ws.onerror = () => ws.close(); } // Example: check before buying $200 of a token, then watch it. const token = "0x124597e2d8bbe472825c4918a36de246ed0c92f7"; const verdict = await preTradeCheck(token, 200); console.log(verdict.ok ? "OK to buy" : `skip: ${verdict.reasons.join("; ")}`); if (verdict.ok && KEY) watchPositions([token], (a) => console.log("ALERT", a)); ``` Run against the MJDQ token above, it prints `skip: flag lp_single_wallet; $200 is too large for $1897.69 of quote liquidity` (the quote side is half of the $3,795.38 pool). Either rule alone keeps the bot out; against the honeypot it stops at `can't sell: simulated sell failed`. What a check can't see These checks cover what is on chain: the contract, the taxes paid, the liquidity and who bought the launch. A token can pass every one and still fall because its holders sell. Treat a pass as “no trap found”, and size positions accordingly. ## Frequently asked questions **Is the realized tax enough to know a token can be sold?** No. Realized tax describes trades that already happened. A contract can stop sells later, and the honeypot sample below shows 0% realized tax on a token whose sell simulation now reverts. Gate on `honeypot.is_honeypot` and `risk` as well as on `tax`. **How fresh is the security check my bot reads?** Realized taxes update with every block; contract checks and the sell simulation are cached per token. `meta.block` tells you the block the answer reflects. On Starter and above, `?fresh=1` re-runs the simulation on demand (20 credits, key with the `simulate` scope) and `amount_usd` sets its size. **What does a pre-trade check cost?** Security and price are 1 credit each, so 2 credits per token checked; without a key both work at 2 requests per second. Optional deeper checks: liquidity and locks 5 credits (Free plan), bundles and snipers 10 (Starter), a fresh simulation 20 (Starter). **How do I know when a token I hold changes its tax?** Subscribe to `tax:` on the [WebSocket stream](https://docs.crius.sh/reference/stream/). When the realized buy or sell tax moves by a whole percent, you get `side`, `from` and `to` (percent) and can exit before the next trade pays it. ## Related [Use case **Trading bots** What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs. Read](https://docs.crius.sh/use-cases/trading-bots/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Concept **Token taxes** How Crius measures buy, sell and transfer taxes on Robinhood Chain tokens from real trades and from a simulated buy and sell, how the two are combined, and how tax changes are tracked. Read](https://docs.crius.sh/concepts/taxes/) --- # Build a Robinhood Chain stats dashboard > Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Source: https://docs.crius.sh/guides/build-a-chain-stats-dashboard/ · Updated 2026-10-28 Short answer Use `GET /v1/robinhood/stats?window=24h` (or `1h`, `7d`) for headline numbers (DEX volume per DEX, trades, traders, TVL, locked liquidity, launches per launchpad, gas, block time), `GET /v1/robinhood/volume?days=30&tz=...` for daily and hourly series and weekday / hour patterns, and `/launchpads` and `/v1/status` for the rest. All work without a key; with one, each data call costs 1 credit. Cache them for a minute. [GET `/stats`](https://docs.crius.sh/reference/chain/chain-stats/) [GET `/volume`](https://docs.crius.sh/reference/chain/volume-history/) [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/v1/status`](https://docs.crius.sh/reference/chain/service-status/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) A Robinhood Chain stats dashboard shows the state of the whole chain at a glance: DEX volume and trades, active traders, total value locked, new tokens and graduations per launchpad, gas costs and block times, with history charts behind them. The Crius API serves each panel from one call: [chain stats](https://docs.crius.sh/reference/chain/chain-stats/) for the headline numbers, [volume history](https://docs.crius.sh/reference/chain/volume-history/) for the charts and patterns, [launchpads](https://docs.crius.sh/reference/launchpads/launchpads/) for the launchpad table and [service status](https://docs.crius.sh/reference/chain/service-status/) for index health. All of them are on the anonymous plan. ## Architecture 1. **One backend cache.** A small server calls each endpoint on its own schedule and keeps the last response. Visitors read the cache, so a dashboard with thousands of views a day makes a few thousand calls, not millions. 2. **Panels.** Tiles from `/stats` (1h and 24h), a daily volume bar chart and an hourly line from `/volume`, a weekday × hour heatmap from `/volume`’s patterns, a launchpad table from `/launchpads`, a trending list from `/tokens?list=trending`, and an index-health badge from `/v1/status`. 3. **Freshness.** Show `meta.block` and `meta.lag_ms` from the responses you display, so readers know which block the numbers reflect. Endpoints used: [GET`/stats`](https://docs.crius.sh/reference/chain/chain-stats/) [GET`/volume`](https://docs.crius.sh/reference/chain/volume-history/) [GET`/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET`/v1/status`](https://docs.crius.sh/reference/chain/service-status/) [GET`/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) ## Headline numbers: the last hour Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/chain-stats/) ### Robinhood Chain in the last hour How much traded on Robinhood Chain in the last hour, where, and what did a swap cost? GET/v1/robinhood/stats?window=1h **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=1h" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=1h"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=1h", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 100 lines (arrays trimmed)** ```json { "data": { "blocks": { "active_wallets": 20075, "avg_block_time_ms": 98, "tps_1m": 36.7, "txs": 133816 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 61192.3, "pons_curve": 1062218, "uniswap_v2": 275858, "uniswap_v3": 11880413, "uniswap_v4": 14793757 }, "traders": 21078, "trades": 153255, "volume_usd": 28073439, "wash_volume_usd": 2621.56 }, "eth_usd": 2355.49, "finalized_block": 100401329, "gas": { "avg_swap_cost_eth": 0.00000827998, "avg_swap_cost_usd": 0.0195034, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021874 }, "head_block": 100409861, "l1_block": 26294128, "launchpads": [ { "graduated": 4, "launches": 158, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 2519361 }, { "graduated": 0, "launches": 29, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 386815 }, { "graduated": 1, "launches": 55, "launchpad": "flap", "launchpad_name": "Flap.sh", "volume_usd": 58185.2 } ], "liquidity": { "locked_lp_usd": 44720881, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322374159 }, "pools": { "by_dex": { "launch_curve": 55, "pons_curve": 158, "uniswap_v2": 61, "uniswap_v3": 5, "uniswap_v4": 412 }, "new": 691 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100405028, "tokens": { "by_attribution": { "known_launchpad": 243, "other": 163 }, "new": 406, "new_1h": 406 }, "window": "1h" }, "meta": { "block": 100409861, "block_age_ms": 1204, "block_ts": 1793225391000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100401329, "lag_ms": 74, "safe_block": 100405028 } } ``` What this tells you - `dex.volume_usd` 28,073,439 across 153,255 `trades` by 21,078 `traders`. `dex.by_dex` splits it: Uniswap v4 14,793,757, v3 11,880,413, the Pons curve 1,062,218, v2 275,858 and other launch curves 61,192.3. - `tokens.new` 406 in the hour: 243 from known launchpads, 163 other (`tokens.by_attribution`). `launchpads` has Pons at 158 launches and 4 graduations, Long.xyz at 29 and Flap.sh at 55 launches with 1 graduation. - `liquidity.tvl_usd` 322,374,159 with 44,720,881 in locked LP (`locked_lp_usd`); `liquidity.method` says how TVL is counted (2 × the quote side of every pool, in-range for v3 and v4). - `gas.avg_swap_cost_usd` is about 2 cents (0.0195034), `blocks.avg_block_time_ms` 98 and `blocks.tps_1m` 36.7. `reorgs.count` is 0. - `meta.coverage.since_block: 0`: the aggregates cover the chain from its first block. [Chain stats reference](https://docs.crius.sh/reference/chain/chain-stats/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Robinhood%20Chain%20in%20the%20last%20hour&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-chain-stats-dashboard%2F%23stats-1h%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fstats%3Fwindow%3D1h%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Charts: volume history in your time zone Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/volume-history/) ### Daily and hourly volume, New York time What were the last three days of volume in New York time, and when is the chain busiest? GET/v1/robinhood/volume?days=3&hours=3&tz=America/New\_York **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/volume?days=3&hours=3&tz=America/New_York" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/volume?days=3&hours=3&tz=America/New_York"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/volume?days=3&hours=3&tz=America/New_York", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 334 lines (arrays trimmed)** ```json { "data": { "as_of_ts": 1793225400000, "by_hour": { "lookback_days": 90, "peak_hour": 10, "quietest_hour": 0, "rows": [ { "avg_trades": 141478, "avg_volume_usd": 30431396, "days_counted": 89, "hour": 0, "share_pct": 2.96526 }, { "avg_trades": 143248, "avg_volume_usd": 31741345, "days_counted": 89, "hour": 1, "share_pct": 3.0929 }, { "avg_trades": 137989, "avg_volume_usd": 30467983, "days_counted": 89, "hour": 2, "share_pct": 2.96882 } ] }, "by_weekday": { "lookback_days": 90, "peak_day": "wednesday", "quietest_day": "saturday", "rows": [ { "avg_trades": 4188231, "avg_volume_usd": 1007469201, "day": "monday", "days_counted": 13, "share_pct": 14.3392, "total_volume_usd": 13097099608 }, { "avg_trades": 4146036, "avg_volume_usd": 985164052, "day": "tuesday", "days_counted": 13, "share_pct": 14.0218, "total_volume_usd": 12807132672 }, { "avg_trades": 4322566, "avg_volume_usd": 1438855279, "day": "wednesday", "days_counted": 12, "share_pct": 18.9038, "total_volume_usd": 17266263345 } ] }, "chain": "robinhood", "daily": { "busiest_day": { "ts": 1792900800000, "volume_usd": 530086557 }, "days": 3, "rows": [ { "buy_volume_usd": 276848199, "sell_volume_usd": 253238359, "trades": 1497541, "ts": 1792900800000, "volume_usd": 530086557, "wash_volume_usd": 50353764 }, { "buy_volume_usd": 263678297, "sell_volume_usd": 249859608, "trades": 1579804, "ts": 1792987200000, "volume_usd": 513537905, "wash_volume_usd": 50665065 }, { "buy_volume_usd": 237376106, "sell_volume_usd": 198604557, "trades": 1536041, "ts": 1793073600000, "volume_usd": 435980663, "wash_volume_usd": 50477350 } ] }, "hourly": { "busiest_hour": { "ts": 1793217600000, "volume_usd": 41214488 }, "hours": 3, "rows": [ { "buy_volume_usd": 20462975, "sell_volume_usd": 15801392, "trades": 117048, "ts": 1793214000000, "volume_usd": 36264366, "wash_volume_usd": 38390.2 }, { "buy_volume_usd": 19621873, "sell_volume_usd": 21592616, "trades": 115601, "ts": 1793217600000, "volume_usd": 41214488, "wash_volume_usd": 111979 }, { "buy_volume_usd": 13778367, "sell_volume_usd": 12101340, "trades": 140966, "ts": 1793221200000, "volume_usd": 25879707, "wash_volume_usd": 2621.56 } ] }, "method": { "caught_up": true, "data_since_ts": 1779484440000, "live": "windows up to 1h from the live trade flow (chain time); longer windows from complete minutes plus the live flow", "outliers": "excluded: single trades valued above $25000000 (mispriced quotes), counted in outlier_trades", "table_through_ts": 1793224860000, "volume": "organic DEX volume in USD at trade time (Uniswap V2/V3/V4, launchpad curves)", "wash": "excluded: same-tx round trips — buys and sells of one token in one pool inside one tx that cancel within 2%" }, "tz": "America/New_York", "windows": { "180d": { "buy_volume_usd": 54359954506, "buys": 253835268, "change_pct": null, "complete": false, "outlier_trades": 762, "prev_volume_usd": null, "sell_volume_usd": 52437080014, "sells": 204582929, "tokens": 1738934, "traders": 8246046, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 458418197, "volume_usd": 106797034520, "wash_trades": 1140815, "wash_volume_usd": 43228252019 }, "1h": { "buy_volume_usd": 14265111, "buys": 75723, "change_pct": -0.550523, "complete": true, "outlier_trades": 0, "prev_volume_usd": 28270704, "sell_volume_usd": 13849957, "sells": 77740, "tokens": 1727, "traders": 21102, "trades": 153463, "volume_usd": 28115068, "wash_trades": 27, "wash_volume_usd": 2621.56 }, "1m": { "buy_volume_usd": 215981, "buys": 1243, "change_pct": -15.5255, "complete": true, "outlier_trades": 0, "prev_volume_usd": 462782, "sell_volume_usd": 174952, "sells": 1029, "tokens": 177, "traders": 1107, "trades": 2272, "volume_usd": 390933, "wash_trades": 0, "wash_volume_usd": 0 }, "1s": { "buy_volume_usd": 7395.66, "buys": 36, "change_pct": 249.657, "complete": true, "outlier_trades": 0, "prev_volume_usd": 3890.85, "sell_volume_usd": 6208.99, "sells": 37, "tokens": 25, "traders": 51, "trades": 73, "volume_usd": 13604.7, "wash_trades": 0, "wash_volume_usd": 0 }, "24h": { "buy_volume_usd": 287374377, "buys": 908075, "change_pct": 20.5728, "complete": true, "outlier_trades": 0, "prev_volume_usd": 445470035, "sell_volume_usd": 249741535, "sells": 874783, "tokens": 13023, "traders": 153999, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 1782858, "volume_usd": 537115913, "wash_trades": 17597, "wash_volume_usd": 100833841 }, "30d": { "buy_volume_usd": 12246515202, "buys": 34847713, "change_pct": -51.5447, "complete": true, "outlier_trades": 69, "prev_volume_usd": 48876260264, "sell_volume_usd": 11436620583, "sells": 31076104, "tokens": 291323, "traders": 2263899, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 65923817, "volume_usd": 23683135785, "wash_trades": 296156, "wash_volume_usd": 5483273587 }, "30s": { "buy_volume_usd": 101246, "buys": 648, "change_pct": -35.5977, "complete": true, "outlier_trades": 0, "prev_volume_usd": 237790, "sell_volume_usd": 51896, "sells": 456, "tokens": 133, "traders": 597, "trades": 1104, "volume_usd": 153142, "wash_trades": 0, "wash_volume_usd": 0 }, "5m": { "buy_volume_usd": 1221510, "buys": 7565, "change_pct": -33.8303, "complete": true, "outlier_trades": 0, "prev_volume_usd": 3930121, "sell_volume_usd": 1379039, "sells": 8041, "tokens": 417, "traders": 4438, "trades": 15606, "volume_usd": 2600549, "wash_trades": 0, "wash_volume_usd": 0 }, "6h": { "buy_volume_usd": 106140026, "buys": 325797, "change_pct": 58.3393, "complete": true, "outlier_trades": 0, "prev_volume_usd": 129388468, "sell_volume_usd": 98732768, "sells": 334428, "tokens": 5453, "traders": 64490, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 660225, "volume_usd": 204872794, "wash_trades": 541, "wash_volume_usd": 359759 }, "7d": { "buy_volume_usd": 1909534740, "buys": 5757353, "change_pct": -31.3756, "complete": true, "outlier_trades": 0, "prev_volume_usd": 5322163628, "sell_volume_usd": 1742769364, "sells": 5565930, "tokens": 58656, "traders": 501350, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 11323283, "volume_usd": 3652304104, "wash_trades": 66125, "wash_volume_usd": 453119545 }, "90d": { "buy_volume_usd": 46760664123, "buys": 208521629, "change_pct": null, "complete": true, "outlier_trades": 343, "prev_volume_usd": null, "sell_volume_usd": 45144542946, "sells": 166894584, "tokens": 1441104, "traders": 7052878, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 375416213, "volume_usd": 91905207070, "wash_trades": 953623, "wash_volume_usd": 41341982607 } } }, "meta": { "block": 100409945, "block_age_ms": 674, "block_ts": 1793225400000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 9, "safe_block": 100405028 } } ``` What this tells you - `daily.rows` start at New York midnight: the first `ts`, 1792900800000, is 04:00 UTC. Each row has `volume_usd`, `buy_volume_usd`, `sell_volume_usd`, `trades` and `wash_volume_usd`, ready for a stacked bar chart. - `by_hour.peak_hour` is 10 (10:00 New York) over a 90-day lookback. The same call in UTC (the reference sample) says 14: the same hour, four hours apart. `by_weekday` puts the peak on `wednesday` and the quietest day on `saturday`. - `windows` gives tiles from `1s` to `180d`. The `24h` window: `volume_usd` 537,115,913 from 1,782,858 trades, `change_pct` +20.57% against the previous 24 hours (`prev_volume_usd` 445,470,035). - `traders` and `tokens` in windows are approximate counts (`traders_note`: HyperLogLog), and `method` spells out what is excluded: wash round trips and trades above $25,000,000. [Volume history reference](https://docs.crius.sh/reference/chain/volume-history/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Daily%20and%20hourly%20volume%2C%20New%20York%20time&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-chain-stats-dashboard%2F%23volume-tz%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fvolume%3Fdays%3D3%26hours%3D3%26tz%3DAmerica%2FNew_York%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Use it in your app ```js // dashboard.mjs: node dashboard.mjs, then GET http://localhost:8080/api/dashboard (Node.js 22+) import { createServer } from "node:http"; const BASE = "https://api.crius.sh"; const HEADERS = process.env.CRIUS_API_KEY ? { "x-api-key": process.env.CRIUS_API_KEY } : {}; const TZ = "America/New_York"; // panel -> [path, refresh interval in seconds] const PANELS = { hour: ["/v1/robinhood/stats?window=1h", 60], day: ["/v1/robinhood/stats?window=24h", 60], volume: [`/v1/robinhood/volume?days=30&hours=48&tz=${encodeURIComponent(TZ)}`, 300], launchpads: ["/v1/robinhood/launchpads", 300], trending: ["/v1/robinhood/tokens?list=trending&window=24h&limit=10", 60], status: ["/v1/status", 30], }; const cache = {}; async function refresh(name) { const [path, every] = PANELS[name]; try { const res = await fetch(BASE + path, { headers: HEADERS }); if (res.ok) cache[name] = await res.json(); // keep the last good answer on errors } catch (e) { console.error(name, e.message); } setTimeout(() => refresh(name), every * 1000); } for (const [i, name] of Object.keys(PANELS).entries()) setTimeout(() => refresh(name), i * 600); // stagger: stay under 2 req/s without a key createServer((req, res) => { if (req.url !== "/api/dashboard") return res.writeHead(404).end(); const d = (k) => cache[k]?.data; const body = { tiles: { volume_24h: d("day")?.dex.volume_usd, trades_24h: d("day")?.dex.trades, traders_24h: d("day")?.dex.traders, tvl: d("day")?.liquidity.tvl_usd, new_tokens_1h: d("hour")?.tokens.new, swap_cost_usd: d("hour")?.gas.avg_swap_cost_usd, }, daily: d("volume")?.daily.rows, hourly: d("volume")?.hourly.rows, heatmap: { weekday: d("volume")?.by_weekday, hour: d("volume")?.by_hour }, launchpads: d("launchpads")?.map((l) => ({ name: l.name, ...l.stats })), trending: d("trending")?.map((t) => ({ address: t.address, symbol: t.symbol, change: t.change_pct?.["24h"], volume: t.volume_usd?.["24h"] })), index: d("status")?.chains?.robinhood, block: cache.day?.meta?.block, }; res.writeHead(200, { "content-type": "application/json", "cache-control": "public, max-age=15" }); res.end(JSON.stringify(body)); }).listen(8080); ``` ## What it costs | Panel | Endpoint | Refresh | Credits per month | | --- | --- | --- | --- | | Hour and day tiles | `/stats` × 2 | 60 s | 86,400 | | Volume charts and heatmap | `/volume` | 5 min | 8,640 | | Launchpad table | `/launchpads` | 5 min | 8,640 | | Trending tokens | `/tokens` | 60 s | 43,200 | | Index health | `/v1/status` | 30 s | 0 (public, not metered) | Each metered call costs 1 credit with a key: about 147,000 credits a month in total, under 15% of the Free plan. Without a key the same schedule runs on the anonymous plan (about 0.1 requests per second on average), which is enough for a public dashboard. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). Live tiles without polling faster `/volume`’s short windows (`1s`, `30s`, `1m`, `5m`) come from the live trade flow, so a “volume in the last minute” tile only needs `/volume` every 15–30 seconds. A stream of every trade on the chain (`firehose:trades`) exists on the Enterprise plan. ## Frequently asked questions **How is Robinhood Chain DEX volume counted?** Organic DEX volume in USD at trade time across Uniswap v2, v3, v4 and launchpad curves. Same-transaction round trips (a buy and a sell of one token in one pool and one transaction that cancel within 2%) are excluded and reported as `wash_volume_usd`, and single trades valued above $25,000,000 are excluded as mispriced (`outlier_trades`). `/volume` returns these rules in `method`. **Can I show the volume chart in my users' time zone?** Yes: pass an IANA time zone in `tz` (for example `tz=America/New_York` or `tz=Asia/Dubai`). Daily rows then start at local midnight and the hour-of-day pattern uses local hours. **Do I need an API key for a public dashboard?** No. `/stats`, `/volume`, `/launchpads`, `/tokens`, `/v1/status` and `/v1/chains` are on the anonymous plan. Call them from your server, not from every visitor's browser: the anonymous limit is 2 requests per second per IP, and a Free key raises it to 10. **How live are the numbers?** `/volume` windows up to 1 hour come from the live trade flow; longer windows combine complete minutes with the live flow. Every response carries `meta.block` and `meta.lag_ms`, which you can show as "updated at block …". ## Related [Use case **Analytics dashboards** Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts. Read](https://docs.crius.sh/use-cases/analytics-dashboards/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [API reference **Chain stats API** DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (1h, 24h, 7d). Read](https://docs.crius.sh/reference/chain/chain-stats/) [API reference **Volume history API** On-chain volume per hour or per day, in your time zone (tz), plus a weekday × hour pattern over pattern\_days. Read](https://docs.crius.sh/reference/chain/volume-history/) [Guide **DEX data** Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades. Read](https://docs.crius.sh/guides/robinhood-chain-dex-data/) --- # Build a Telegram token scanner bot for Robinhood Chain > Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples. Source: https://docs.crius.sh/guides/build-a-telegram-token-scanner/ · Updated 2026-10-28 Short answer When a message contains a token address, call `GET /v1/robinhood/token/{address}` (price, market cap, liquidity, holders, launchpad) and `GET /v1/robinhood/token/{address}/security` (score, risk, flags, taxes, honeypot) in parallel and reply with a summary; for a name, call `/search` first and let the user pick. Two credits per scan, and both calls work without a key. [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/search`](https://docs.crius.sh/reference/discovery/search/) A Telegram token scanner is a bot that answers “is this token OK?” in a chat: someone pastes a Robinhood Chain token address, and the bot replies with its price, market cap, liquidity, holders, launchpad, taxes and a security verdict. With the Crius API that’s two calls per scan, the [token profile](https://docs.crius.sh/reference/tokens/token-profile/) and [security checks](https://docs.crius.sh/reference/security/security-checks/), plus [search](https://docs.crius.sh/reference/discovery/search/) when someone types a name instead of an address. All three are on the anonymous plan, so the bot runs without a key until it gets busy. ## Architecture 1. **Telegram side.** Long-poll `getUpdates` from the Telegram Bot API (no webhook or server needed) and reply with `sendMessage`. Create the bot with @BotFather to get its token. 2. **Parse the message.** An address (`0x` and 40 hex characters) is scanned directly. A word after `/scan` is a name: search for it and reply with the matches. 3. **Scan.** Call the token profile and security in parallel, then format one message. Cache results for a minute so ten people pasting the same token in a group cost one scan. 4. **Optional feed.** A second process listens to `launches:all` on the stream and posts new tokens that pass the scan to a channel. Endpoints used: [GET`/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET`/search`](https://docs.crius.sh/reference/discovery/search/) ## Names are not unique: search, then pick Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### Three tokens called Housecoin A user types /scan housecoin. Which token do they mean? GET/v1/robinhood/search?q=housecoin&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=housecoin&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=housecoin&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=housecoin&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 73 lines (arrays trimmed)** ```json { "data": [ { "address": "0x578dfaf61257ea702b8834bb037740a6368947bd", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 22978.7, "logo": null, "name": "Housecoin", "price_usd": 0.0000846805, "symbol": "HOUSECOIN", "type": "token" }, { "address": "0x34c21f10ea7ec052ed878d157f40fb4160730b24", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/aryonserwin/status/2093942789784637480", "website": "https://fs.blog/knowledge-project-podcast/vlad-tenev/?utm_source=chatgpt.com" }, "liquidity_usd": 4978.47, "logo": "https://api.crius.sh/v1/robinhood/logo/0x34c21f10ea7ec052ed878d157f40fb4160730b24.png?size=128", "name": "Housecoin", "price_usd": 0.00000374137, "symbol": "housecoin", "type": "token" }, { "address": "0xc19b982b971642aa6cc5346f5a15cd0ccf4626cc", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/coinbase/status/2093710406695125093", "website": "https://www.ponsfamily.com/launchpad/0x992f10d2c751ec875d6a2834a70f730d030a25f9" }, "liquidity_usd": 3876.33, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc19b982b971642aa6cc5346f5a15cd0ccf4626cc.png?size=128", "name": "Housecoin", "price_usd": 0.00000218996, "symbol": "Housecoin", "type": "token" } ], "meta": { "block": 100410183, "block_age_ms": 555, "block_ts": 1793225424000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 9, "safe_block": 100405028 } } ``` What this tells you - Three different tokens share the name: `0x578dfaf61257ea702b8834bb037740a6368947bd` (no launchpad, `liquidity_usd` 22,978.7), and two Pons tokens, `0x34c21f10ea7ec052ed878d157f40fb4160730b24` (4,978.47) and `0xc19b982b971642aa6cc5346f5a15cd0ccf4626cc` (3,876.33). - Their `symbol`s differ only in case (`HOUSECOIN`, `housecoin`, `Housecoin`), and their links point to unrelated pages. A bot that scans “the first result” would be wrong as often as right. - Reply with every match: name, `launchpad_name`, liquidity and the full address, and let the user choose. `type=token` restricts search to tokens; `limit` goes up to 20. [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20tokens%20called%20Housecoin&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-telegram-token-scanner%2F%23search-names%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3Dhousecoin%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The scan: profile plus security Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Housecoin's security: unlocked liquidity in one wallet The user picks 0x578dfaf61257ea702b8834bb037740a6368947bd. What should the bot warn about? GET/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 119 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "lp_unlocked", "unverified", "lp_single_wallet" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "lp_single_wallet" ], "lp_top_wallet": { "address": "0x52c6e90a0928df4d6e4a6164ee0c7851144b1454", "liquidity_usd": 23239.6, "pct": 100 }, "sniper_supply_pct": 0.0000145583, "sniper_top_wallet_pct": 0.0000145583, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": { "max_tx": "1000000000", "max_tx_getter": "maxTxAmount()", "max_tx_pct": 100, "max_wallet": "1000000000", "max_wallet_getter": "maxWalletAmount()", "max_wallet_pct": 100 }, "liquidity": { "status": "unlocked", "summary": { "burned_pct": 0, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 50, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793225424000, "max_sell_pct_seen": 0, "samples": { "buys": 53, "sells": 48 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100408848, "pct": 0, "side": "buy" }, { "from_block": 100408910, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x578dfaf61257ea702b8834bb037740a6368947bd" }, "meta": { "block": 100410199, "block_age_ms": 1166, "block_ts": 1793225425000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 97, "safe_block": 100405028, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 50`, `risk: "medium"`, `flags`: `lp_unlocked`, `unverified`, `lp_single_wallet`. - `launch.lp_top_wallet` is `0x52c6e90a0928df4d6e4a6164ee0c7851144b1454` with `pct: 100` of the liquidity (`liquidity_usd` 23,239.6), and `liquidity.status` is `unlocked`: one wallet can pull the whole pool. That’s the line to put first in the reply. - No tax: `tax.buy_pct` and `tax.sell_pct` are 0 over 53 buys and 48 sells (`tax.realized.samples`, `confidence: "high"`), and `honeypot.is_honeypot` is false. - `meta.simulation` says `"no V2 WETH pair: realized tax only"`: the taxes come from real trades, not a simulation. - `contract.ownership: "none"`, with no mint, pause or blacklist: the contract itself isn’t the risk here. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Housecoin's%20security%3A%20unlocked%20liquidity%20in%20one%20wallet&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-telegram-token-scanner%2F%23scan-security%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x578dfaf61257ea702b8834bb037740a6368947bd%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Minutes later: the pool is empty The same token, scanned again twelve minutes after the security check above. This is what the `lp_single_wallet` warning was about. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### Housecoin after its liquidity was pulled Someone pastes 0x578dfaf61257ea702b8834bb037740a6368947bd again. What does the profile show now? GET/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 267 lines (arrays trimmed)** ```json { "data": { "address": "0x578dfaf61257ea702b8834bb037740a6368947bd", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/bundles" }, "burned": 771605584, "chain_id": 4663, "circulating_supply": 228394416, "creation": { "attribution": "unattributed_factory", "block": 100408825, "deployed_via": "factory", "deployer": "0x52c6e90a0928df4d6e4a6164ee0c7851144b1454", "factory": "0x1cbaf24d53fe930fce8eff149fa797d2611da149", "source": "trace", "tx": "0xba98b7479b2bf5896021262176c4c92f149df0750f93a75b2fcc83869d10d51a" }, "decimals": 18, "dexscreener": { "status": "checking" }, "first_seen_block": 100408825, "history": "complete", "holders": { "burned_pct": 77.1606, "count": 166, "dev_holding": null, "dev_pct": null, "locked_pct": 0, "top10_pct": 16.4376 }, "launch": null, "liquidity": { "see": "/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/liquidity", "status": "no_liquidity", "summary": { "burned_pct": null, "locked_pct": null, "next_unlock_ts": null, "protocol_fee_pct": null, "unlocked_in_wallets_pct": null, "weighting": "by pool liquidity_usd" } }, "locked": 0, "market": { "fdv_usd": null, "liquidity_usd": 0, "market_cap_usd": null, "pools_count": 1, "quote_liquidity_usd": 0 }, "metadata": { "banner": null, "description": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "logo": null, "logo_original": null, "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "source": null, "sources": { "links": null, "logo": null } }, "name": "Housecoin", "price": { "ath_market_cap_usd": 21314.9, "ath_scope": "all_time", "ath_ts": 1793225465000, "ath_usd": 0.0000933247, "change_pct": { "1h": 271.103, "1m": 0, "1s": 0, "24h": 271.103, "30s": 0, "4h": 271.103, "5m": 0, "6h": 271.103 }, "confidence": null, "dex": null, "eth": null, "liquidity_usd": null, "quote": null, "quote_liquidity_usd": null, "source_pool": null, "thin_liquidity": null, "usd": null }, "security": { "see": "/v1/robinhood/token/0x578dfaf61257ea702b8834bb037740a6368947bd/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 17761, "buys": 70, "first_trade_ts": 1793225291000, "sell_volume_usd": 11036.9, "sells": 62, "since": "chain_start", "trades": 132, "volume_usd": 28797.9 }, "avg_trade_usd": { "1h": 218.166, "1m": null, "1s": null, "24h": 218.166, "30s": null, "4h": 218.166, "5m": null, "6h": 218.166 }, "buy_volume_usd": { "1h": 17761, "1m": 0, "1s": 0, "24h": 17761, "30s": 0, "4h": 17761, "5m": 0, "6h": 17761 }, "buyers": { "1h": 52, "1m": 0, "1s": 0, "24h": 52, "30s": 0, "4h": 52, "5m": 0, "6h": 52 }, "buys": { "1h": 70, "1m": 0, "1s": 0, "24h": 70, "30s": 0, "4h": 70, "5m": 0, "6h": 70 }, "last_trade_ts": 1793225465000, "sell_volume_usd": { "1h": 11036.9, "1m": 0, "1s": 0, "24h": 11036.9, "30s": 0, "4h": 11036.9, "5m": 0, "6h": 11036.9 }, "sellers": { "1h": 31, "1m": 0, "1s": 0, "24h": 31, "30s": 0, "4h": 31, "5m": 0, "6h": 31 }, "sells": { "1h": 62, "1m": 0, "1s": 0, "24h": 62, "30s": 0, "4h": 62, "5m": 0, "6h": 62 }, "traders": { "1h": 52, "1m": 0, "1s": 0, "24h": 52, "30s": 0, "4h": 52, "5m": 0, "6h": 52 }, "trades": { "1h": 132, "1m": 0, "1s": 0, "24h": 132, "30s": 0, "4h": 132, "5m": 0, "6h": 132 }, "txns": { "1h": 132, "1m": 0, "1s": 0, "24h": 132, "30s": 0, "4h": 132, "5m": 0, "6h": 132 }, "volume_eth": { "1h": 12.2259, "1m": 0, "1s": 0, "24h": 12.2259, "30s": 0, "4h": 12.2259, "5m": 0, "6h": 12.2259 }, "volume_usd": { "1h": 28797.9, "1m": 0, "1s": 0, "24h": 28797.9, "30s": 0, "4h": 28797.9, "5m": 0, "6h": 28797.9 } }, "symbol": "HOUSECOIN", "total_supply": 1000000000, "type": "generic", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": false, "sourcify": "none" } }, "meta": { "block": 100417059, "block_age_ms": 1310, "block_ts": 1793226138000, "chain": "robinhood", "finalized_block": 100408671, "lag_ms": 100, "pending": [], "safe_block": 100412483 } } ``` What this tells you - `market.liquidity_usd` is 0, `price.usd` is `null` and `liquidity.status` is `no_liquidity`: the token’s one pool (`market.pools_count: 1`) has nothing left to trade against. - No trade happened after the all-time high: `price.ath_ts` and `stats.last_trade_ts` are both 1793225465000 (22:11:05 UTC), less than a minute after the security check. - `creation.deployer` is `0x52c6e90a0928df4d6e4a6164ee0c7851144b1454`, the same wallet the security check reported as holding 100% of the liquidity (`launch.lp_top_wallet`). - `holders.count` is still 166: the holders keep their tokens, but there’s no market to sell them in. `creation.attribution: "unattributed_factory"` and `launch: null`: no launchpad, so no launch locker either. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Housecoin%20after%20its%20liquidity%20was%20pulled&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-telegram-token-scanner%2F%23after-pull%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x578dfaf61257ea702b8834bb037740a6368947bd%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The bot Node.js 22+, no dependencies. Set `TELEGRAM_TOKEN` from @BotFather; `CRIUS_API_KEY` is optional. ```js // scanner-bot.mjs: TELEGRAM_TOKEN=... node scanner-bot.mjs const TG = `https://api.telegram.org/bot${process.env.TELEGRAM_TOKEN}`; const API = "https://api.crius.sh/v1/robinhood"; const HEADERS = process.env.CRIUS_API_KEY ? { "x-api-key": process.env.CRIUS_API_KEY } : {}; const cache = new Map(); // address -> { at, text } const esc = (s) => String(s ?? "").replace(/[&<>]/g, (c) => ({ "&": "&", "<": "<", ">": ">" })[c]); // names are user-made const usd = (n) => (n == null ? "?" : n >= 1000 ? `$${Math.round(n).toLocaleString("en-US")}` : `$${Number(n).toPrecision(4)}`); async function get(path, tries = 3) { const res = await fetch(`${API}${path}`, { headers: HEADERS }); if (res.status === 429 && tries > 1) { await new Promise((r) => setTimeout(r, Number(res.headers.get("retry-after") ?? 1) * 1000)); // rate limited: wait, retry return get(path, tries - 1); } return (await res.json()).data; } async function scan(address) { const hit = cache.get(address); if (hit && Date.now() - hit.at < 60_000) return hit.text; const [t, s] = await Promise.all([get(`/token/${address}`), get(`/token/${address}/security`)]); if (!t) return "Token not found on Robinhood Chain."; const warn = { critical: "DANGER: honeypot or scam", high: "HIGH RISK", medium: "Medium risk", low: "Low risk" }[s?.risk] ?? "Risk unknown"; const lines = [ `${esc(t.name)} (${esc(t.symbol)})`, `${address}`, `Price ${usd(t.price?.usd)} · 24h ${t.price?.change_pct?.["24h"]?.toFixed(1) ?? "?"}%`, `Market cap ${usd(t.market?.market_cap_usd)} · Liquidity ${usd(t.market?.liquidity_usd)}`, `Holders ${t.holders?.count ?? "?"} · Top 10 hold ${t.holders?.top10_pct?.toFixed(1) ?? "?"}%`, t.launch ? `Launchpad ${esc(t.launch.launchpad_name)} · ${t.launch.status}` : "No launchpad", "", `${warn} · score ${s?.score ?? "?"}/100`, s?.flags?.includes("lp_single_wallet") ? "One wallet holds the unlocked liquidity and can pull it at any time." : null, `Tax buy ${s?.tax?.buy_pct ?? "?"}% · sell ${s?.tax?.sell_pct ?? "?"}% · LP ${s?.liquidity?.status ?? "?"}`, s?.flags?.length ? `Flags: ${s.flags.join(", ")}` : "No flags", ]; const text = lines.filter((l) => l != null).join("\n"); cache.set(address, { at: Date.now(), text }); return text; } async function search(q) { const hits = (await get(`/search?q=${encodeURIComponent(q)}&type=token&limit=5`)) ?? []; if (!hits.length) return "No token with that name."; return ["Which one? Send the address:", ...hits.map((h) => `${esc(h.name)} (${esc(h.symbol)}) · ${esc(h.launchpad_name ?? "no launchpad")} · liq ${usd(h.liquidity_usd)}\n${h.address}`)].join("\n\n"); } async function reply(chatId, text) { await fetch(`${TG}/sendMessage`, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ chat_id: chatId, text, parse_mode: "HTML", link_preview_options: { is_disabled: true } }), }); } let offset = 0; for (;;) { try { const { result = [] } = await (await fetch(`${TG}/getUpdates?timeout=30&offset=${offset}`)).json(); for (const u of result) { offset = u.update_id + 1; const text = u.message?.text ?? ""; const addr = text.match(/0x[0-9a-fA-F]{40}/)?.[0]?.toLowerCase(); const name = text.match(/^\/scan(?:@\w+)?\s+(.+)/)?.[1]; if (addr) await reply(u.message.chat.id, await scan(addr)); else if (name) await reply(u.message.chat.id, await search(name.trim())); } } catch (e) { console.error(e); await new Promise((r) => setTimeout(r, 3000)); } } ``` ## What it costs | Operation | Calls | Credits | | --- | --- | --- | | Scan an address | `/token/{address}` + `/token/{address}/security` | 2 | | Look up a name | `/search` | 1 | | Repeat scan within a minute | cached | 0 | | New-launch feed | 1 stream connection + 2 per posted token | 1 + 2 each | Without a key, scans are limited to 2 requests per second per IP, which a small group won’t reach. With a Free key, 1,000,000 credits cover about 500,000 scans a month. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). Escape token names Token names and symbols are written by whoever deployed the contract. Escape them before sending with `parse_mode: "HTML"`, as `esc()` does, or a name containing `<` breaks the message. ## Frequently asked questions **Do I need a Crius API key for a Telegram scanner?** Not to start. Token profile, security and search are on the anonymous plan at 2 requests per second per IP. A busy group needs more: a Free key gives 10 requests per second and 1,000,000 credits a month, about 500,000 scans. **How do I stop users scanning the wrong token with the same name?** Treat names as a search, never as an identity. `/search` returns every token with that name or symbol; show each one's address, launchpad and `liquidity_usd`, and scan only after the user sends or taps an address. **Can the bot post new launches to a channel automatically?** Yes. Subscribe to `launches:all` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) (Free key with the `stream` scope), wait a minute, run the same scan and post tokens that pass. The [new tokens guide](https://docs.crius.sh/guides/stream-new-tokens/) has the stream client. **Does this work for Discord too?** The Crius part is the same: two calls per scan. Only the chat side changes: replace `getUpdates` and `sendMessage` with your Discord library's message events and replies. ## Related [Use case **Telegram & Discord bots** Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs. Read](https://docs.crius.sh/use-cases/telegram-and-discord-bots/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Search tokens** Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included. Read](https://docs.crius.sh/guides/search-tokens/) [Guide **Get token data** Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Read](https://docs.crius.sh/guides/get-token-data/) [Guide **Stream new tokens** Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token. Read](https://docs.crius.sh/guides/stream-new-tokens/) --- # Build a Robinhood Chain token screener > Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code. Source: https://docs.crius.sh/guides/build-a-token-screener/ · Updated 2026-10-28 Short answer Poll `GET /v1/robinhood/tokens` for the lists you show (`top_volume`, `new`, `graduating`, `trending`…) with filters such as `clean=true` and `min_liquidity_usd`, add holder and lock data with `POST /v1/robinhood/tokens/batch` (100 tokens per call), and check each new token once with `/security`. Every call costs 1 credit and works without a key at 2 requests per second. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [POST `/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) A token screener is a table of Robinhood Chain tokens that users filter and sort: by volume, price change, liquidity, market cap, launchpad or risk. With the Crius API it is three calls: [token lists](https://docs.crius.sh/reference/discovery/token-lists/) for the rows and their trading stats, [batch profiles](https://docs.crius.sh/reference/tokens/batch-token-profiles/) for fields the list doesn’t carry (holder concentration, liquidity locks), and [security](https://docs.crius.sh/reference/security/security-checks/) once per token for a risk badge. All three are on the anonymous plan and cost 1 credit per call with a key. ## Architecture 1. **Poller.** A server job calls `/tokens` every 30 seconds for each list you show, with your base filters (`clean=true`, `min_liquidity_usd`, `launchpad`, `window`). Each call returns up to 100 rows with price, market cap, liquidity, holders and per-window stats. 2. **Enricher.** For the tokens in those lists, one `POST /tokens/batch` per 100 tokens adds `holders.top10_pct`, `holders.dev_pct`, `liquidity.status` and `liquidity.locked_pct`. 3. **Risk cache.** Tokens you haven’t seen in the last hour get a `/security` call; store `risk`, `score` and `flags`. 4. **API for your UI.** Users’ filters and sorts run on that in-memory table, so a page view costs no credits. Optionally, a stream subscription to `launches:all` adds new tokens the moment they launch. Endpoints used: [GET`/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [POST`/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET`/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) ## The rows: a token list with filters Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Top 24h volume, clean tokens with $10k+ liquidity Which Robinhood Chain tokens traded the most in the last 24 hours, leaving out rugs, wash trading and thin markets? GET/v1/robinhood/tokens?list=top\_volume&window=24h&clean=true&min\_liquidity\_usd=10000&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=top_volume&window=24h&clean=true&min_liquidity_usd=10000&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_volume&window=24h&clean=true&min_liquidity_usd=10000&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=top_volume&window=24h&clean=true&min_liquidity_usd=10000&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "buy_volume_usd": { "1h": 284727, "24h": 5466713, "5m": 4788.48, "6h": 2762630 }, "buyers": { "1h": 237, "24h": 1993, "5m": 25, "6h": 786 }, "buys": { "1h": 837, "24h": 16502, "5m": 48, "6h": 6856 }, "change_pct": { "1h": 0.222526, "24h": -1.4982, "5m": -0.129097, "6h": -1.39644 }, "created_block": 153563, "created_ts": 1782222069300, "decimals": 18, "fdv_usd": 18950323, "holders": 192282, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5692665, "logo": null, "market_cap_usd": 18950201, "name": "NVIDIA • Robinhood Token", "price_eth": 0.0909845, "price_usd": 214.313, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 203391, "24h": 6094025, "5m": 54662.2, "6h": 3389490 }, "sellers": { "1h": 230, "24h": 2643, "5m": 31, "6h": 1098 }, "sells": { "1h": 724, "24h": 18645, "5m": 107, "6h": 8674 }, "status": null, "symbol": "NVDA", "traders": { "1h": 329, "24h": 3513, "5m": 45, "6h": 1417 }, "txns": { "1h": 1453, "24h": 33049, "5m": 145, "6h": 14479 }, "volume_usd": { "1h": 488118, "24h": 11560738, "5m": 59450.7, "6h": 6152120 } }, { "address": "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", "buy_volume_usd": { "1h": 280776, "24h": 5360063, "5m": 8943.58, "6h": 3449730 }, "buyers": { "1h": 173, "24h": 1786, "5m": 24, "6h": 920 }, "buys": { "1h": 596, "24h": 10514, "5m": 26, "6h": 5156 }, "change_pct": { "1h": 0.329135, "24h": 0.110872, "5m": 0.350832, "6h": 0.71074 }, "created_block": 153733, "created_ts": 1782222864140, "decimals": 18, "fdv_usd": 20226775, "holders": 70703, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 16569917, "logo": null, "market_cap_usd": 20226751, "name": "SPDR S&P 500 ETF Trust • Robinhood Token", "price_eth": 0.328203, "price_usd": 773.079, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 342684, "24h": 4970409, "5m": 74111.8, "6h": 3375154 }, "sellers": { "1h": 218, "24h": 1924, "5m": 39, "6h": 971 }, "sells": { "1h": 881, "24h": 11039, "5m": 85, "6h": 5766 }, "status": null, "symbol": "SPY", "traders": { "1h": 329, "24h": 2757, "5m": 54, "6h": 1416 }, "txns": { "1h": 1396, "24h": 20497, "5m": 103, "6h": 10312 }, "volume_usd": { "1h": 623461, "24h": 10330472, "5m": 83055.3, "6h": 6824884 } }, { "address": "0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea", "buy_volume_usd": { "1h": 133427, "24h": 4487530, "5m": 801.518, "6h": 1670779 }, "buyers": { "1h": 118, "24h": 1173, "5m": 7, "6h": 499 }, "buys": { "1h": 452, "24h": 14559, "5m": 9, "6h": 5347 }, "change_pct": { "1h": -0.00703424, "24h": -3.40455, "5m": -0.0708291, "6h": -0.22877 }, "created_block": 412861, "created_ts": 1782740860100, "decimals": 18, "fdv_usd": 13549210, "holders": 116370, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 3716808, "logo": null, "market_cap_usd": 13549000, "name": "Space Exploration Technologies Corp. Class A Common Stock • Robinhood Token", "price_eth": 0.0611357, "price_usd": 144.005, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 138415, "24h": 5276839, "5m": 11840.2, "6h": 1775402 }, "sellers": { "1h": 145, "24h": 1584, "5m": 15, "6h": 693 }, "sells": { "1h": 499, "24h": 15226, "5m": 25, "6h": 5620 }, "status": null, "symbol": "SPCX", "traders": { "1h": 180, "24h": 1956, "5m": 21, "6h": 821 }, "txns": { "1h": 887, "24h": 28427, "5m": 34, "6h": 10519 }, "volume_usd": { "1h": 271842, "24h": 9764370, "5m": 12641.7, "6h": 3446181 } } ], "meta": { "block": 100409896, "block_age_ms": 750, "block_ts": 1793225395000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 160, "list": "top_volume", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Tokenized stocks lead: NVIDIA (`0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec`, `volume_usd["24h"]` 11,560,738), the S&P 500 ETF (`0x117cc2133c37b721f49de2a7a74833232b3b4c0c`, 10,330,472) and SpaceX Class A (`0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea`, 9,764,370), all quoted in USDG (`quote: "USDG"`). A meme-token screener adds `launchpad=pons` (or another launchpad id) to the same call. - Each row has stats for `5m`, `1h`, `6h` and `24h`: NVIDIA’s 24h has 33,049 `txns` from 3,513 `traders`, with more `sellers` (2,643) than `buyers` (1,993) and `change_pct` of −1.5%. - `holders` (192,282 for NVIDIA), `liquidity_usd`, `market_cap_usd` and `fdv_usd` are on the row, so most screener columns need no second call. - `launchpad`, `status` and `progress_pct` are `null` for tokens not launched on a launchpad; for curve tokens they give the launchpad id, `bonding` / `graduated` and curve progress. - `meta.next_cursor` pages to the next rows; `limit` goes up to 100. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Top%2024h%20volume%2C%20clean%20tokens%20with%20%2410k%2B%20liquidity&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-token-screener%2F%23rows%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtop_volume%26window%3D24h%26clean%3Dtrue%26min_liquidity_usd%3D10000%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The extra columns: batch profiles Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-token-profiles/) ### Five fields for two tokens in one call I have a list of addresses. How do I get just the fields my table needs? POST/v1/robinhood/tokens/batch **cURL** ```bash curl -X POST "https://api.crius.sh/v1/robinhood/tokens/batch" \ -H "content-type: application/json" \ -d '{"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}' ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens/batch", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ], "fields": [ "symbol", "price.usd", "price.change_pct.24h", "market.market_cap_usd", "market.liquidity_usd" ] }), }); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.post( "https://api.crius.sh/v1/robinhood/tokens/batch", json={"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 40 lines (arrays trimmed)** ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "market": { "liquidity_usd": 73135530, "market_cap_usd": 90409474 }, "price": { "change_pct": { "24h": 0.286017 }, "usd": 2355.49 }, "symbol": "WETH" }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "market": { "liquidity_usd": 5611.8, "market_cap_usd": 3773.42 }, "price": { "change_pct": { "24h": -0.171971 }, "usd": 0.00000388948 }, "symbol": "CHARGE" } }, "meta": { "block": 100406780, "block_age_ms": 575, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 196, "missing": [], "safe_block": 100401329 } } ``` What this tells you - `fields` takes dot paths into the [token profile](https://docs.crius.sh/reference/tokens/token-profile/); the response has exactly those paths per token, keyed by address. - WETH (`0x0bd7d308f8e1639fab988df18a8011f41eacad73`) has `market.liquidity_usd` of 73,135,530; CHARGE (`0x7b8892cea949bc60d494681d1bc3ea96071ab0b8`) has 5,611.8 and a market cap of 3,773.42. - Unknown addresses go to `meta.missing` instead of failing the call (empty here), so one bad row never breaks a refresh. [Batch token profiles reference](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Five%20fields%20for%20two%20tokens%20in%20one%20call&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-a-token-screener%2F%23batch%0ARequest%3A%20POST%20%2Fv1%2Frobinhood%2Ftokens%2Fbatch%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Use it in your app This server keeps the table in memory, refreshes it every 30 seconds and answers `GET /screener?min_liq=50000&max_top10=30&sort=volume` for your front end. ```js // screener.mjs: node screener.mjs, then GET http://localhost:8080/screener?sort=change (Node.js 22+) import { createServer } from "node:http"; const API = "https://api.crius.sh/v1/robinhood"; const HEADERS = { "content-type": "application/json", ...(process.env.CRIUS_API_KEY && { "x-api-key": process.env.CRIUS_API_KEY }) }; const LISTS = ["list=top_volume&window=24h&clean=true&min_liquidity_usd=10000", "list=new&min_liquidity_usd=5000", "list=graduating"]; const FIELDS = ["holders.top10_pct", "holders.dev_pct", "liquidity.status", "liquidity.locked_pct"]; const rows = new Map(); // address -> row const risk = new Map(); // address -> { risk, score, flags, at } const call = async (path, body) => { const res = await fetch(`${API}${path}`, body ? { method: "POST", headers: HEADERS, body: JSON.stringify(body) } : { headers: HEADERS }); return (await res.json()).data; }; async function refresh() { for (const q of LISTS) for (const t of (await call(`/tokens?${q}&limit=100`)) ?? []) rows.set(t.address, { ...rows.get(t.address), ...t, seen: Date.now() }); for (const [a, r] of rows) if (Date.now() - r.seen > 10 * 60_000) rows.delete(a); // drop rows no list returned for 10 min const addrs = [...rows.keys()]; for (let i = 0; i < addrs.length; i += 100) { const extra = (await call("/tokens/batch", { tokens: addrs.slice(i, i + 100), fields: FIELDS })) ?? {}; for (const [a, p] of Object.entries(extra)) if (rows.has(a)) Object.assign(rows.get(a), { top10_pct: p.holders?.top10_pct, dev_pct: p.holders?.dev_pct, lp: p.liquidity?.status, locked_pct: p.liquidity?.locked_pct }); } for (const a of addrs.filter((a) => Date.now() - (risk.get(a)?.at ?? 0) > 3_600_000).slice(0, 50)) { const s = await call(`/token/${a}/security`); if (s) risk.set(a, { risk: s.risk, score: s.score, flags: s.flags, at: Date.now() }); } } const SORTS = { volume: (r) => r.volume_usd?.["24h"] ?? 0, change: (r) => r.change_pct?.["24h"] ?? -Infinity, liquidity: (r) => r.liquidity_usd ?? 0, mcap: (r) => r.market_cap_usd ?? 0 }; createServer((req, res) => { const q = new URL(req.url, "http://x").searchParams; const out = [...rows.values()] .map((r) => ({ ...r, ...risk.get(r.address) })) .filter((r) => (r.liquidity_usd ?? 0) >= Number(q.get("min_liq") ?? 0)) .filter((r) => r.top10_pct == null || r.top10_pct <= Number(q.get("max_top10") ?? 100)) .filter((r) => r.risk !== "critical" && (q.get("risk") !== "low" || r.risk === "low")) .sort((a, b) => (SORTS[q.get("sort")] ?? SORTS.volume)(b) - (SORTS[q.get("sort")] ?? SORTS.volume)(a)) .slice(0, 100); res.writeHead(200, { "content-type": "application/json" }); res.end(JSON.stringify(out)); }).listen(8080); const loop = () => refresh().catch(console.error).finally(() => setTimeout(loop, 30_000)); loop(); ``` ## What it costs | Operation | Endpoint | Credits | | --- | --- | --- | | One list page (up to 100 tokens) | `GET /tokens` | 1 | | Extra fields for up to 100 tokens | `POST /tokens/batch` | 1 | | Risk for one token | `GET /token/{address}/security` | 1 | | Prices only, up to 100 tokens | `GET /prices` | 1 | With three lists refreshed every 30 seconds, the lists cost 8,640 credits a day and the batch calls about the same again (up to 300 tokens, three calls per refresh). Re-checking the risk of up to 300 rows once an hour adds at most 7,200 a day. That’s about 740,000 credits a month, inside the Free plan’s 1,000,000; refreshing every 60 seconds halves the list and batch part. Without a key the same calls run on the anonymous plan at 2 requests per second, which is enough for a prototype, not for a refresh of this size. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). Market cap alone is easy to fake In the [market cap list](https://docs.crius.sh/reference/discovery/token-lists/) sample, MJDQ (`0x124597e2d8bbe472825c4918a36de246ed0c92f7`) shows a market cap of about $1 billion with 4 holders and $3,795 of liquidity. Rank by volume or liquidity, set a `min_liquidity_usd`, and show the security risk next to the market cap. The [market cap guide](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) explains how market cap and FDV are computed. ## Frequently asked questions **How do I keep rugs and wash trading out of a screener?** Add `clean=true` to any list. It applies the `trending` list's checks: no crash of 90% or more from the window's peak, $1,000+ liquidity, 20+ real holders, no insider or wallet-farm launch, no bot distribution, and no single wallet holding 40%+ of the liquidity unlocked. Then show each token's `/security` risk next to it. **How many tokens can I fetch per call?** Up to 100 per page from `/tokens` (paginate with `cursor`), and up to 100 per call from `/tokens/batch` and `/prices`. Each of those calls costs 1 credit regardless of how many tokens it returns. **Can a screener update in real time?** Lists are a poll: refreshing every 15–60 seconds is enough for most screeners. For live rows, subscribe to `token:
` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) (price and holder count changes) for the tokens on screen, within your plan's subscription limit. **Which windows do the list stats cover?** List rows carry `volume_usd`, `buy_volume_usd`, `sell_volume_usd`, `txns`, `buys`, `sells`, `buyers`, `sellers`, `traders` and `change_pct` for `5m`, `1h`, `6h` and `24h`. `window` (for example `window=1h`) chooses which one ranks the list. ## Related [Use case **Token screeners** Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs. Read](https://docs.crius.sh/use-cases/token-screeners/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [Guide **Find tokens by market cap** Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses. Read](https://docs.crius.sh/guides/find-tokens-by-market-cap/) [Guide **Prices for many tokens** Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed. Read](https://docs.crius.sh/guides/get-prices-for-many-tokens/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Token lists API** Lists: new, bonding, graduating, graduated, trending, top\_volume, top\_gainers, top\_losers, top\_market\_cap (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Read](https://docs.crius.sh/reference/discovery/token-lists/) --- # Build Robinhood Chain price alerts with the WebSocket stream > Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Source: https://docs.crius.sh/guides/build-price-alerts/ · Updated 2026-10-28 Short answer Subscribe to `price:` plus the token address on `wss://api.crius.sh/v1/robinhood/stream`. You get a snapshot right away, then updates with `usd`, `eth` and `liquidity_usd` whenever the token trades (at most 10 a second). Compare `usd` with your thresholds, ignore updates with too little `liquidity_usd`, and check `GET /v1/robinhood/token/{address}/security` once before you alert. Free plan: 10 tokens per connection. [GET `/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) A price alert on Robinhood Chain is a rule (“tell me when AI crosses $0.10”, “tell me when TSLA moves 3% in 15 minutes”) checked against a live price. The Crius WebSocket gives you that price on the `price:` channel: a snapshot as soon as you subscribe, then a new `usd`, `eth` and `liquidity_usd` every time the token trades. A good alert bot adds two checks the price alone can’t give it: enough liquidity behind the price, and a token that isn’t a trap. ## What the price channel sends Subscribe with `{"op": "subscribe", "channels": ["price:0x2e8c31162b855a2ffa90f6f8634643ad6f111e18"]}`. Right after the `subscribed` reply, the server sends the current price with `"snapshot": true` and no `seq`; after that, each update is a normal stream message. | Field | Meaning | | --- | --- | | `data.usd` | Price per whole token in USD | | `data.eth` | Price per whole token in ETH | | `data.liquidity_usd` | Liquidity of the pool the price came from (2 × its quote side) | | `block`, `ts` | The block and chain time (unix ms) of the trade that moved the price | | `snapshot` | `true` on the first message after subscribing | Updates are capped at 10 a second per token, and only come when the token trades. The [stream reference](https://docs.crius.sh/reference/stream/) covers the envelope, heartbeats and reorgs. ## Check the price source before you rely on it The REST price has the same `usd`, `eth` and `liquidity_usd` plus the pool, a `confidence` level and a thin-liquidity flag. Call it once when a user creates an alert, to decide whether the token is worth alerting on at all. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### Artificial Inu's price and where it comes from A user wants an alert on Artificial Inu (AI, 0x2e8c31162b855a2ffa90f6f8634643ad6f111e18). Is its price solid enough to alert on? GET/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "high", "dex": "uniswap_v4", "eth": 0.0000341958, "eth_usd": 2355.49, "liquidity_usd": 657440, "quote": "0x39dbed3a2bd333467115de45665cc57f813c4571", "quote_liquidity_usd": 328720, "source_pool": "0x230bc4a0fb5fb7ab27f6e72350dfa3f2489b0cdbaf34f0189d68672086ccb919", "symbol": "AI", "thin_liquidity": false, "token": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", "usd": 0.0805479 }, "meta": { "block": 100410151, "block_age_ms": 315, "block_ts": 1793225421000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 26, "safe_block": 100405028 } } ``` What this tells you - `usd: 0.0805479` comes from a Uniswap v4 pool (`dex: "uniswap_v4"`, `source_pool` is its 32-byte pool id), quoted in another token rather than ETH (`quote` is `0x39dbed3a2bd333467115de45665cc57f813c4571`). - `liquidity_usd: 657440` is 2 × the real quote side (`quote_liquidity_usd: 328720`). That’s the same number the stream sends in `liquidity_usd`, so a floor such as $10,000 works on both. - `confidence: "high"` and `thin_liquidity: false`: a single small trade can’t move this price far. For a token showing `thin_liquidity: true`, require a larger move or a second update before alerting. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Artificial%20Inu's%20price%20and%20where%20it%20comes%20from&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-price-alerts%2F%23price-source%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x2e8c31162b855a2ffa90f6f8634643ad6f111e18%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### The same token's security, checked once per alert Before I tell users AI is pumping, is anything wrong with the token? GET/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 127 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862", "ownership": "active", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "ownership_active", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x9701fb0ade1e269c8f64ec0c7b3cfadb31a13a52", "liquidity_usd": 703900, "pct": 19.8021 }, "sniper_supply_pct": 1.70207, "sniper_top_wallet_pct": 1.70207, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 14.4982, "locked_pct": 0, "next_unlock_ts": 1794049200000, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 73.5823, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 85, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793225667000, "max_sell_pct_seen": 99.99, "samples": { "buys": 98750, "sells": 101250 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": { "amount_eth": 0.042421762259500888, "buy_gas": 145730, "buy_pct": 0, "can_buy": true, "can_sell": true, "can_transfer": true, "from": "eoa", "revert_reason": null, "router": "0x89e5db8b5aa49aa85ac63f691524311aeb649eba", "sell_gas": 126783, "sell_pct": 0, "transfer_pct": 0 }, "source": "realized", "transfer_pct": 0 }, "tax_history": [ { "from_block": 99878573, "pct": 0, "side": "buy" }, { "from_block": 99878935, "pct": 100, "side": "buy" }, { "from_block": 99880233, "pct": 0, "side": "buy" } ], "tax_history_total": 919, "tax_mode": "dynamic", "token": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18" }, "meta": { "block": 100412468, "block_age_ms": 741, "block_ts": 1793225673000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 5, "safe_block": 100405028, "simulation": "eth_simulateV1 via Uniswap V2 router at head" } } ``` What this tells you - `score: 85`, `risk: "low"`, with `ownership_active` (the owner can still act on the contract) and `unverified` as the only flags. - No taxes: `tax.buy_pct` and `tax.sell_pct` are 0, measured over 98,750 buys and 101,250 sells (`tax.realized.samples`), and the simulated buy, transfer and sell all went through (`tax.simulated.can_sell: true`, via the Uniswap V2 router named in `meta.simulation`). - `liquidity.status: "partially_locked"`: about 73.6% of the LP sits unlocked in wallets (`unlocked_in_wallets_pct`) and `next_unlock_ts` is 1794049200000 (November 7, 2026). A sharp drop could be liquidity leaving, so an alert bot can also subscribe to `lp:` for the token. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20same%20token's%20security%2C%20checked%20once%20per%20alert&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fbuild-price-alerts%2F%23security-before-alert%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x2e8c31162b855a2ffa90f6f8634643ad6f111e18%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## An alert bot in Node.js The bot reads rules, checks each token once, subscribes to their price channels and sends a message when a rule triggers. Each rule fires once, then re-arms after the price moves back past it. Delivery here is a webhook (`{"content": ...}` works with Discord webhooks); swap `notify` for email, Telegram or a push service. ```js // alerts.mjs: CRIUS_API_KEY=... WEBHOOK_URL=... node alerts.mjs (Node.js 22+) const KEY = process.env.CRIUS_API_KEY; const API = "https://api.crius.sh/v1/robinhood"; const MIN_LIQUIDITY_USD = 10_000; const RULES = [ { token: "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", name: "AI", above: 0.1 }, { token: "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", name: "AI", below: 0.07 }, { token: "0x322f0929c4625ed5bad873c95208d54e1c003b2d", name: "TSLA", movePct: 3, windowMs: 15 * 60_000 }, ]; const blocked = new Set(); // tokens that failed the security check const history = {}; // token -> [{ ts, usd }] for move rules let backoff = 1000; async function notify(text) { console.log(text); if (process.env.WEBHOOK_URL) { await fetch(process.env.WEBHOOK_URL, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ content: text }) }); } } async function screen(token) { const res = await fetch(`${API}/token/${token}/security`, { headers: { "x-api-key": KEY } }); const { data } = await res.json(); if (!data || data.risk === "critical" || data.honeypot?.is_honeypot) { blocked.add(token); console.warn(`not alerting on ${token}: ${data?.risk} ${data?.flags?.join(", ")}`); } } function evaluate(token, p, ts) { if (blocked.has(token) || p.liquidity_usd < MIN_LIQUIDITY_USD) return; const h = (history[token] ??= []); h.push({ ts, usd: p.usd }); while (h.length && h[0].ts < ts - 60 * 60_000) h.shift(); // keep one hour for (const r of RULES.filter((r) => r.token === token)) { let hit = false; let why = ""; if (r.above != null) [hit, why] = [p.usd >= r.above, `above $${r.above}`]; if (r.below != null) [hit, why] = [p.usd <= r.below, `below $${r.below}`]; if (r.movePct != null) { const base = h.find((x) => x.ts >= ts - r.windowMs)?.usd; const pct = base ? ((p.usd - base) / base) * 100 : 0; [hit, why] = [Math.abs(pct) >= r.movePct, `${pct.toFixed(2)}% in ${r.windowMs / 60_000} min`]; } if (hit && !r.fired) notify(`${r.name} $${p.usd} (${why}), liquidity $${Math.round(p.liquidity_usd)}`).catch(console.error); r.fired = hit; // re-arm once the condition is no longer true } } function connect() { const tokens = [...new Set(RULES.map((r) => r.token))].filter((t) => !blocked.has(t)); const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); }; ws.onopen = () => { backoff = 1000; touch(); ws.send(JSON.stringify({ op: "subscribe", channels: tokens.map((t) => `price:${t}`) })); }; ws.onmessage = (e) => { touch(); const m = JSON.parse(e.data); if (m.ch === "error") return console.error(m.data); if (!m.ch.startsWith("price:") || m.data.removed) return; evaluate(m.ch.slice(6), m.data, m.ts ?? Date.now()); // the snapshot has no ts: use the clock }; ws.onclose = () => { clearTimeout(idle); setTimeout(connect, backoff + Math.random() * 500); backoff = Math.min(backoff * 2, 30_000); }; ws.onerror = () => ws.close(); } for (const t of new Set(RULES.map((r) => r.token))) await screen(t); connect(); ``` 1. **Screen once, not per update.** One security call per token (1 credit, or free without a key at 2 requests per second) when the alert is created. Re-check daily, or subscribe to `tax:` and `lp:` for the token to hear about tax changes and liquidity removal. 2. **Use the snapshot.** After every reconnect the snapshot gives the current price immediately. A price alert doesn’t need `resume`: the latest price is what counts, and the snapshot is it. 3. **Floor the liquidity.** Skip updates whose `liquidity_usd` is under your floor. Meme tokens often have one deep pool and several thin ones; the stream’s price comes from the deepest, but a token whose only pool is thin is easy to push across a threshold. 4. **Mind your subscription count.** The `hello` message carries `max_subscriptions`. Past it, the server answers `channel_denied` with the channels it refused; split them across connections (Starter and up) or poll [batch prices](https://docs.crius.sh/reference/tokens/batch-prices/) for the rest. Plan and cost The price stream needs a Free key with the `stream` scope and costs 1 credit per connection. On the Free plan that’s 10 tokens on one connection; more tokens need Starter or above, or REST polling. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Frequently asked questions **How often does the price channel update?** Every time the token trades, at most once per 100 ms per token. A token that doesn't trade sends nothing, so a quiet price is not a stale connection: the 15-second heartbeat tells you the socket is alive. **How many tokens can one alert bot watch?** One `price:` subscription per token. The Free plan allows 10 subscriptions on 1 connection, Starter 100 on each of 3 connections, Pro 1,000 on each of 10. For a long watch list on a small plan, poll [batch prices](https://docs.crius.sh/reference/tokens/batch-prices/) (100 tokens per 1-credit call) and stream only the tokens closest to a threshold. **Why did my alert fire on a price nobody can trade at?** A thin pool can print a price far from the real market. Each price message carries `liquidity_usd` (2 × the quote side of the pool the price came from): skip updates below a floor you choose. The REST [price](https://docs.crius.sh/reference/tokens/token-price/) also returns `confidence` and `thin_liquidity` for a second look before you send. **Do price alerts need an API key?** The stream does: a Free key with the `stream` scope. The REST calls the bot makes (price, security, batch prices) also work without a key on the anonymous plan, at 2 requests per second. ## Related [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) [Concept **Token prices** How the Crius API prices Robinhood Chain tokens from on-chain pools, how the price pool is picked, and what confidence and thin\_liquidity mean. Read](https://docs.crius.sh/concepts/token-prices/) --- # Check a token developer's history (past launches and rugs) > Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling. Source: https://docs.crius.sh/guides/check-developer-history/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/dev/{address}` (Free plan, 5 credits). `summary` gives `tokens_created`, `graduated`, `graduation_rate_pct`, `rugged` and the best and median peak market cap; `tokens[]` lists each launch with `status`, `ath_market_cap_usd`, `market_cap_usd`, `liquidity_usd`, `dev_sold_pct` and `rugged`. Get the creator from the token profile's `launch.creator`. [GET `/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/) A developer profile is a token creator’s track record: every token the wallet launched on a launchpad or deployed directly, how high each one went, where it is now, whether it graduated, whether it rugged, and how much of it the developer sold. It’s the first thing to check before buying a new launch. A creator with ten dead tokens behind them is telling you something the contract can’t. ## Check the developer in one call Example [Free plan · 5 credits](https://docs.crius.sh/reference/wallets/developer-profile/) ### CHARGE's creator: one Pons launch, graduated, not a rug Has the developer of Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) launched other tokens, and how did they do? GET/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 61 lines (arrays trimmed)** ```json { "data": { "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "first_seen_ts": 1792283372000, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "label": "bridge:Relay solver" }, "summary": { "best_ath_market_cap_usd": 68675.8, "by_launchpad": { "pons": 1 }, "graduated": 1, "graduation_rate_pct": 100, "median_ath_market_cap_usd": 68675.8, "rugged": 0, "tokens_created": 1 }, "tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "created_block": 88385886, "created_ts": 1791982834000, "deployed_via": "launchpad", "dev_sold_pct": null, "launchpad": "pons", "launchpad_name": "Pons", "liquidity_usd": 5611.81, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "market_cap_usd": 3773.42, "name": "Charge AI", "rugged": false, "status": "graduated", "symbol": "CHARGE" } ], "top_tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" } ] }, "meta": { "block": 100406874, "block_age_ms": 1212, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 26, "next_cursor": null, "rugged_rule": "market cap < 10% of ATH (ATH > $5k) and liquidity < $500", "safe_block": 100401329 } } ``` What this tells you - `summary.tokens_created: 1` with `by_launchpad: {"pons": 1}`, `graduated: 1` and `graduation_rate_pct: 100`: a first-time creator whose only token completed its bonding curve. - The token is CHARGE (`0x7b8892cea949bc60d494681d1bc3ea96071ab0b8`), `deployed_via: "launchpad"` on Pons, created in block 88385886 (`created_ts: 1791982834000`, 2026-10-14 13:00 UTC), `status: "graduated"`. - `ath_market_cap_usd: 68675.8` against `market_cap_usd: 3773.42` now: about 95% below its peak. Yet `rugged: false` and `summary.rugged: 0`, because `liquidity_usd: 5611.81` is still above the $500 in `meta.rugged_rule` (“market cap < 10% of ATH (ATH > $5k) and liquidity < $500”). The token faded; nobody pulled the liquidity. - `dev_sold_pct: null`: the creator never held any CHARGE, so it couldn’t dump on buyers. Its [trade history](https://docs.crius.sh/guides/get-wallet-trade-history/#creator-no-trades) is empty too. - `funded_by` is `0xd782268f600403843484b70710daee6846fc0db8` (`bridge:Relay solver`, 0.008148386337868892 ETH): the wallet was funded over a bridge, not by another known dev. [Connected wallets](https://docs.crius.sh/guides/find-connected-wallets/#creator-connections) confirms no `linked_devs`. - `top_tokens` lists the creator’s best launches by peak market cap (up to three); here only CHARGE. [Developer profile reference](https://docs.crius.sh/reference/wallets/developer-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20creator%3A%20one%20Pons%20launch%2C%20graduated%2C%20not%20a%20rug&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-developer-history%2F%23charge-dev%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fdev%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `summary.tokens_created`, `by_launchpad` | Tokens launched or deployed, in total and per launchpad (`direct` for contracts deployed without one). | | `summary.graduated`, `graduation_rate_pct` | Launches that completed their bonding curve, and their share. | | `summary.rugged` | Tokens that match `meta.rugged_rule`. | | `summary.best_ath_market_cap_usd`, `median_ath_market_cap_usd` | The highest and the median peak market cap of the creator's tokens. | | `tokens[].status` | Launch stage, for example `graduated`. | | `tokens[].deployed_via`, `launchpad`, `launchpad_name` | `launchpad` or `direct`, and which launchpad. | | `tokens[].created_block`, `created_ts` | When the token was created. | | `tokens[].ath_market_cap_usd`, `ath_scope`, `market_cap_usd` | Peak market cap, the period it covers (`all_time`), and the market cap now. | | `tokens[].liquidity_usd` | Liquidity now, across the token's pools. | | `tokens[].dev_sold_pct` | Share of the tokens the creator received that it later moved out of its wallet; `null` if it never held any. | | `tokens[].rugged` | `true` when the token matches the rug rule. | | `top_tokens[]` | Up to three best launches by peak market cap: `address`, `symbol`, `logo`, `ath_market_cap_usd`. | | `funded_by` | The creator's first funder: `address`, `label`, `amount_eth`. | `sort` orders `tokens[]` by `created` (default, newest first), `ath` or `market_cap`. `limit` takes up to 500 (default 50); page with `cursor` (`meta.next_cursor`). ## What to look for - **Many launches, few graduations.** A creator with dozens of tokens and a `graduation_rate_pct` near zero is making throwaway tokens: most never found enough buyers to fill the curve. - **`rugged` above zero.** Read which tokens, and check `dev_sold_pct` on them: a dev who sold 100% into a dying token did the dumping. - **A low median peak.** `median_ath_market_cap_usd` far below `best_ath_market_cap_usd` means one lucky hit among many failures. - **The wallet is new.** A fresh creator wallet says nothing on its own. Check who funded it: a creator funded by another dev’s wallet should be judged by that dev’s history too. [Connected wallets](https://docs.crius.sh/guides/find-connected-wallets/) shows the link. ## Use it in your app 1. **Find the creator.** The token profile (`GET /v1/robinhood/token/{address}`, anonymous plan) has `launch.creator` for launchpad tokens. For CHARGE it’s `0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca`. 2. **Get a Free key and call `/dev/{creator}`.** 5 credits per call; send the key in `x-api-key`. 3. **Turn the summary into a verdict.** For example: warn when `summary.rugged` is 1 or more, or when `tokens_created` is high and `graduation_rate_pct` is low. Show the past tokens so users can judge for themselves. 4. **Combine it with the token’s own checks.** The [security score](https://docs.crius.sh/guides/token-security-score/) covers the contract, taxes and liquidity, and [bundles & snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/) who bought the launch. ```js // Dev check for a new launch: find the creator, then read their track record. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const api = "https://api.crius.sh/v1/robinhood"; const headers = { "x-api-key": process.env.CRIUS_API_KEY }; const { data: profile } = await (await fetch(`${api}/token/${token}`, { headers })).json(); const creator = profile.launch?.creator; if (!creator) throw new Error("not a launchpad token"); const { data: dev } = await (await fetch(`${api}/dev/${creator}?sort=created`, { headers })).json(); const s = dev.summary; console.log(`${s.tokens_created} tokens, ${s.graduated} graduated (${s.graduation_rate_pct}%), ${s.rugged} rugged`); for (const t of dev.tokens) { console.log(t.symbol, t.status, `peak $${t.ath_market_cap_usd}`, `now $${t.market_cap_usd}`, t.rugged ? "RUGGED" : "", `dev sold ${t.dev_sold_pct ?? "-"}%`); } ``` ## Frequently asked questions **How do I check if a token's developer has rugged before?** Get the creator from the token profile (`launch.creator` on `/token/{address}`, no key needed), then call `/dev/{creator}`. `summary.rugged` counts their past tokens that rugged, and each entry in `tokens[]` has `rugged`, `ath_market_cap_usd`, `market_cap_usd` and `dev_sold_pct`. **What counts as a rug?** A token whose market cap is under 10% of its all-time high (when that high was above $5k) and whose liquidity is under $500. The rule is returned in `meta.rugged_rule`. A token that fell hard but still has liquidity isn't counted as a rug: CHARGE is down about 95% from its peak but keeps $5,611.81 of liquidity. **What does \`dev\_sold\_pct\` mean?** The share of the tokens the creator received that later left its wallet, from 0 to 100. A dev who bought their own launch and sold everything shows 100. It's `null` when the creator never held the token. **Does it include tokens deployed without a launchpad?** Yes. `tokens[]` covers launchpad launches by the creator (`deployed_via: "launchpad"`) and token contracts it deployed directly (`deployed_via: "direct"`). `summary.by_launchpad` counts them per launchpad. **Which plan does the developer profile need?** The Free plan (a free API key), 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Connected wallets** Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Read](https://docs.crius.sh/guides/find-connected-wallets/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [API reference **Developer profile API** A token creator's track record: every token they deployed or launched, with peak market cap, current state and outcomes. Read](https://docs.crius.sh/reference/wallets/developer-profile/) --- # Check if a token's liquidity is locked or burned > Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Source: https://docs.crius.sh/guides/check-liquidity-locked/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/liquidity` (Free plan, 5 credits). `status` is `locked`, `burned`, `partially_locked`, `unlocked`, `unknown` or `no_liquidity`, and `summary` gives the `locked_pct`, `burned_pct` and `unlocked_in_wallets_pct` weighted by each pool's liquidity. Each pool lists who holds the LP and every lock, with `permanent` or an unlock time. The same `status` and `summary` are in `/security` without a key. [GET `/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) Locked liquidity is the guarantee that a token’s pool can’t be emptied: the LP tokens or position NFTs that own the pool’s funds are burned or held in a locker contract, so nobody can withdraw them and leave holders with nothing to sell into. Crius checks this for every pool of a Robinhood Chain token: who holds each LP position, which locker it is in, whether the lock is permanent, and how much of the token’s liquidity is still in wallets that could pull it. ## Check the locks in one call Example [Free plan · 5 credits](https://docs.crius.sh/reference/security/liquidity-locks/) ### CHARGE: the main pool permanently locked, a small pool in wallets Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) graduated from Pons to Uniswap v4. Is its liquidity locked? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 133 lines (arrays trimmed)** ```json { "data": { "pools": [ { "breakdown": [ { "holder": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "kind": "lp_locker", "locker": "pons_v2_launch_locker", "pct": 100, "position_id": "3790055", "tags": [ "lp_locker" ] } ], "dex": "uniswap_v4", "liquidity_usd": 5604.57, "locks": [ { "amount_raw": 81632653061224486519505762, "last_block": 88461321, "last_event": "TokenSupplyLocked", "lock_id": null, "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" }, { "last_block": 88461321, "last_event": "PositionLocked", "lock_id": "3790055", "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" } ], "lp_type": "nft_positions", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "summary": { "burned_pct": 0, "locked_pct": 100, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0 } }, { "breakdown": [ { "holder": "0x2d424d69b1ead72b30de4c7fe4c53e4853e1419d", "kind": "wallet", "locker": null, "pct": 49.1677, "position_id": "3807218", "tags": [] }, { "holder": "0x7aa15762e68e0f0574f1032663502d23d8b7c7e7", "kind": "wallet", "locker": null, "pct": 38.0286, "position_id": "3846225", "tags": [] }, { "holder": "0x0e6710b35de6960a3e4140d10e9f94e0c5a855d1", "kind": "wallet", "locker": null, "pct": 7.61082, "position_id": "3850136", "tags": [] } ], "dex": "uniswap_v4", "liquidity_usd": 6.29539, "locks": [ { "amount_raw": 81632653061224486519505762, "last_block": 88461321, "last_event": "TokenSupplyLocked", "lock_id": null, "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" }, { "last_block": 88461321, "last_event": "PositionLocked", "lock_id": "3790055", "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" } ], "lp_type": "nft_positions", "pool": "0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3", "summary": { "burned_pct": 0, "locked_pct": 0, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100 } } ], "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 99.8878, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.1122, "weighting": "by pool liquidity_usd" } }, "meta": { "block": 100406846, "block_age_ms": 1266, "block_ts": 1793225082000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 100, "note": "V2 LP shares from LP-token balances (complete once history backfill finishes); V3/V4 by position NFT owner (live ownerOf)", "safe_block": 100401329 } } ``` What this tells you - `status: "partially_locked"` with `summary.locked_pct: 99.8878` and `unlocked_in_wallets_pct: 0.1122`. Nearly everything is locked; the rest is a second, tiny pool. - The main pool `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913` holds $5,604.57 (`liquidity_usd`). Its only position (`position_id: "3790055"`) is held by `0x267444d099b10fb5ed7c3cc7b7c767adca574952`, `kind: "lp_locker"`, `locker: "pons_v2_launch_locker"`. - Its `locks` show a `PositionLocked` event at block 88461321 with `permanent: true` and `status: "locked"`: the Pons launch locker never releases it. `summary.next_unlock_ts: null` confirms nothing is due to unlock. - The second pool `0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3` has $6.30 in it, all in wallets: `0x2d424d69b1ead72b30de4c7fe4c53e4853e1419d` holds 49.17%, `0x7aa15762e68e0f0574f1032663502d23d8b7c7e7` 38.03%. They can withdraw it, but it’s 0.11% of the token’s liquidity. - `summary.weighting: "by pool liquidity_usd"`: the percentages weight each pool by its size, so a dust pool can’t make a locked token look unlocked, or the other way round. [Liquidity & locks reference](https://docs.crius.sh/reference/security/liquidity-locks/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE%3A%20the%20main%20pool%20permanently%20locked%2C%20a%20small%20pool%20in%20wallets&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-liquidity-locked%2F%23locked-lp%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fliquidity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Burned liquidity, checked without a key: ENDAI Is the liquidity of Let's End AI (0xc882f10529a5518ee3393af5a80e9ff00d38d44b) locked? GET/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 140 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x0000000000000000000000000000000000000000", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": true, "upgradeable": false, "verified": "none" }, "flags": [ "honeypot", "unverified", "uniform_holders" ], "honeypot": { "is_honeypot": true, "reason": "simulated sell failed", "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "uniform_holders" ], "lp_top_wallet": { "address": "0xabe3a51937eb4c76ab6449e9823dbffd4409776f", "liquidity_usd": 8.58651, "pct": 0.0253312 }, "sniper_supply_pct": 0.000299049, "sniper_top_wallet_pct": 0.000299049, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": { "balance_pct": 0.112731, "holders": 51, "of_top": 100 }, "wallet_farm": null }, "limits": { "max_tx": "1000000000", "max_tx_getter": "maxTxAmount()", "max_tx_pct": 100, "max_wallet": "1000000000", "max_wallet_getter": "maxWalletSize()", "max_wallet_pct": 100 }, "liquidity": { "status": "burned", "summary": { "burned_pct": 99.9715, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0284848, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v2", "risk": "critical", "score": 0, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793224820000, "max_sell_pct_seen": 0, "samples": { "buys": 27197, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": { "amount_eth": 0.042454083286938696, "buy_gas": 159144, "buy_pct": 0, "can_buy": true, "can_sell": false, "can_transfer": true, "from": "eoa", "revert_reason": { "code": 3, "data": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000245472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c454400000000000000000000000000000000000000000000000000000000", "message": "execution reverted: TransferHelper: TRANSFER_FROM_FAILED" }, "router": "0x89e5db8b5aa49aa85ac63f691524311aeb649eba", "sell_gas": 229228, "sell_pct": null, "transfer_pct": 0 }, "source": "realized", "transfer_pct": 0 }, "tax_history": [ { "from_block": 62239227, "pct": 0, "side": "buy" }, { "from_block": 62240181, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b" }, "meta": { "block": 100406838, "block_age_ms": 1257, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 14, "safe_block": 100401329, "simulation": "eth_simulateV1 via Uniswap V2 router at head" } } ``` What this tells you - `liquidity.status: "burned"`, `liquidity.summary.burned_pct: 99.9715`, `locked_pct: 0`: the LP was sent to a burn address and can never be withdrawn. - `launch.lp_top_wallet` names the largest unlocked holder, `0xabe3a51937eb4c76ab6449e9823dbffd4409776f`, with 0.0253% of the liquidity (about $8.59): too little to matter. - The same response has `honeypot.is_honeypot: true`. Burned liquidity stops the pool being pulled; it doesn’t stop a token from blocking sells. See [How to detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/). [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Burned%20liquidity%2C%20checked%20without%20a%20key%3A%20ENDAI&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-liquidity-locked%2F%23burned-lp%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xc882f10529a5518ee3393af5a80e9ff00d38d44b%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `status` | `locked` or `burned` (locked plus burned is over 99.9%), `partially_locked`, `unlocked` (nothing locked or burned), `unknown` (positions not indexed yet), `no_liquidity`. | | `summary.locked_pct`, `burned_pct`, `unlocked_in_wallets_pct`, `protocol_fee_pct` | Shares of the token's liquidity, weighted by pool `liquidity_usd`. | | `summary.next_unlock_ts` | The earliest unlock time (ms) of a lock still in force; `null` when none is due. | | `pools[]` | The token's deepest pools (up to 8), each with `pool`, `dex`, `liquidity_usd`, `lp_type` (`erc20` for v2 LP tokens, `nft_positions` for v3 and v4) and its own `summary`. | | `pools[].breakdown[]` | Who holds the LP: `holder`, `kind` (`burn`, `lp_locker`, `protocol_fee`, `launchpad`, `wallet`), `locker`, `pct`, `position_id`. | | `pools[].locks[]` | Each lock: `locker`, `locker_address`, `lock_id`, `locked_block`, `last_event`, `permanent`, `unlock_ts` (ms) when the locker sets an unlock time, and `status` (`locked`, `relocked`, `unlockable`, `withdrawn`). | In the [security score](https://docs.crius.sh/guides/token-security-score/), `status: "unlocked"` costs 20 points (`lp_unlocked`), and one wallet holding 40% or more of the token’s liquidity unlocked costs 25 (`lp_single_wallet`). A small share in wallets next to a locked main pool, as with CHARGE, costs nothing. ## Use it in your app 1. **Screen with `/security`.** It’s on the anonymous plan (no key needed) and already has `liquidity.status` and `liquidity.summary`. Treat `unlocked` and `unknown` as warnings. 2. **Call `/liquidity` for the detail.** With a free key (5 credits), show users each pool, its locker and whether the lock is permanent or when it ends. 3. **Watch the unlock date.** If `summary.next_unlock_ts` is set, alert before it passes; after it, a lock turns `unlockable` and the owner can withdraw. 4. **Check who holds the unlocked part.** A few dollars in wallets is normal. A large `pct` held by one `kind: "wallet"` holder in the main pool can drain it. ```js // List each pool's lock status for a token. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; // CHARGE const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/liquidity`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); console.log(`${data.status}: ${data.summary.locked_pct}% locked, ${data.summary.burned_pct}% burned`); for (const p of data.pools) { const lock = p.locks.find((l) => l.status === "locked" || l.status === "relocked"); const until = lock?.permanent ? "permanent" : lock?.unlock_ts ? new Date(lock.unlock_ts).toISOString() : "no lock"; console.log(`${p.pool} $${p.liquidity_usd}: ${p.summary?.unlocked_in_wallets_pct ?? "?"}% in wallets, ${until}`); } ``` v2 positions during backfill For Uniswap v2 pools, LP shares come from LP-token balances, which are complete once Crius has indexed the pool’s full history (`meta.note`). A pool whose positions aren’t indexed yet has `summary: null` and doesn’t count as unlocked; if that is most of the liquidity, `status` is `unknown`. ## Frequently asked questions **Is the liquidity locked?** Call `GET https://api.crius.sh/v1/robinhood/token/{address}/liquidity` with a free key and read `status` and `summary.locked_pct`. `locked` or `burned` means more than 99.9% of the liquidity (weighted by pool size) can't be withdrawn; `partially_locked` means some can, and `pools[].breakdown` shows exactly who holds it. Without a key, `/security` returns the same `liquidity.status` and `liquidity.summary`. **What's the difference between burned and locked liquidity?** Burned liquidity was sent to a burn address (`0x0000000000000000000000000000000000000000` or `0x000000000000000000000000000000000000dead`) and can never be withdrawn. Locked liquidity sits in a locker contract until an unlock time, or forever when the lock is `permanent: true` (the Pons launch locker). After an unlock time passes, a lock shows `status: "unlockable"` and the owner can take the LP back. **Does locked liquidity mean a token is safe?** No. It means the pool can't be emptied by withdrawing the LP. The token can still block sells, charge a high tax or be dumped by insiders who bought the launch. Let's End AI has 99.97% of its liquidity burned and Crius flags it as a honeypot. Check the full [security score](https://docs.crius.sh/guides/token-security-score/). **Which lockers does Crius recognize?** The Pons launch locker, UNCX v2, v3 and v4, Team Finance, TitanLocker and HoodLock. LP held by any address Crius doesn't recognize as a burn address, locker or protocol fee sink is reported as `kind: "wallet"` and counts as unlocked. **What happens after liquidity is unlocked?** Crius keeps following the LP: the lock moves to `status: "withdrawn"`, and the breakdown shows the wallet that now holds it, until it is removed from the pool or locked again (`relocked`). ## Related [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [API reference **Liquidity & locks API** Who owns the token's liquidity, per pool: burned, locked (which locker, until when, who can withdraw) or held by wallets. Read](https://docs.crius.sh/reference/security/liquidity-locks/) --- # How to check a Robinhood Chain token's buy and sell tax > Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Source: https://docs.crius.sh/guides/check-token-taxes/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/security` and read `tax.buy_pct` and `tax.sell_pct`. They are measured from what real buyers and sellers paid (`tax.source: "realized"`), backed by a buy-and-sell simulation where the token has a Uniswap v2 WETH pair. A tax over 5% adds the `tax_over_5pct` flag, over 10% `high_tax`. No API key needed. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) A token tax is the share of each trade the token (or its pool) keeps for itself: with Recast’s 7% buy tax, $100 of ETH buys about $93 of tokens, and with Ruby’s 5% sell tax you get about 5% less than the pool paid out. Crius measures it from real trades on Robinhood Chain, so the number you get is what buyers and sellers actually paid in the last 30 days, not what a contract claims. One call to `/security` returns the buy tax, the sell tax, how sure the number is and every past change. How sure is the number? A realized tax is only as good as the trades behind it: check `tax.confidence` and `tax.realized.samples`, and treat `tax.source: "none"` as unknown, not zero. A tax raised a minute ago shows up as new trades arrive. See [Security score: confidence and limitations](https://docs.crius.sh/concepts/security-score-limits/). ## Get the buy and sell tax in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A 5% sell tax: Ruby (RUBY) Ruby (0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be) has a renounced contract. What does it really cost to sell? GET/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 191 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x000000000000000000000000000000000000dead", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "tax_over_5pct", "hook_can_block_swaps", "hook_medium_risk", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0x97240e95756c7b70db1ffaeee85a6c091c33a4ce", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": false, "can_modify_liquidity_amounts": true, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207142599, "code_hash": "0x5cb5a35842eb82ff5c9dbed2dca84d023823d841a2c0fc642568bc8ff276f72f", "family": "0xaa8854cbf2bd", "kind": "contract", "logic": null, "owner": "0x33acedd086ee7fec19764b5f4a93a6ef067953f5", "ownership": "active", "size": 24040 }, "family": { "honeypot_pct": 0, "hooks": 3, "id": "0xaa8854cbf2bd", "liquidity_pulled_pct": 0, "pools_traded": 10, "taxed_pct": 90, "verified_hooks": 0 }, "flags": [ { "evidence": "7 of its 7 measured pools take 1%+ per trade (median per pool, up to 6.3%); only 10.83% of traded hooked pools tax at all", "flag": "tax_observed", "severity": "medium" }, { "evidence": "can take part of every swap (return delta); 4.55% of traded pools of hooks that can block swaps and change swap amounts taxed, 0.61% became honeypots", "flag": "can_modify_swap_amounts", "severity": "low" } ], "name": null, "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1793119940000, "honeypot_pools": 0, "last_trade_ts": 1793223286000, "liquidity_pulled_pct": 0, "liquidity_pulled_pools": 0, "max_buy_tax_pct": 2.545, "max_sell_tax_pct": 6.28, "median_pool_life_min": 1380, "pools": 18, "pools_traded": 8, "tax_measured_pools": 7, "taxed_10pct_pools": 0, "taxed_pools": 7, "volume_usd": 924751 }, "pattern": { "description": "hooks that can block swaps and change swap amounts", "honeypot_pct": 0.608377, "id": "before_swap_with_delta", "liquidity_pulled_pct": 21.5893, "pools_traded": 18574, "taxed_pct": 4.55475 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "beforeSwap", "afterSwap", "beforeSwapReturnDelta" ], "risk": [ "can_block_or_reprice_swaps", "can_modify_swap_amounts", "can_modify_liquidity_amounts", "unverified" ], "risk_level": "medium" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x20ac92362ead44f457913ca1a6c24fae049078d9", "liquidity_usd": 23.0571, "pct": 0.214633 }, "sniper_supply_pct": 1.77655, "sniper_top_wallet_pct": 1.77655, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 99.2777, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.722259, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 70, "tax": { "buy_pct": 0.84, "confidence": "high", "realized": { "buy_pct": 0.84, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 5.28 }, "last_sample_ts": 1793221716000, "max_sell_pct_seen": 16.65, "samples": { "buys": 8, "sells": 240 }, "sell_pct": 5.28, "window": "30d" }, "sell_pct": 5.28, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 99421932, "pct": 5, "side": "sell" }, { "from_block": 99791485, "pct": 1, "side": "buy" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be" }, "meta": { "block": 100406622, "block_age_ms": 595, "block_ts": 1793225060000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 100, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `tax.sell_pct: 5.28` and `tax.buy_pct: 0.84`, from real trades (`tax.source: "realized"`, `confidence: "high"`). `tax.realized.samples` counts 240 sells and 8 buys measured. - `tax.realized.by_wallet_class.others_sell_pct: 5.28` is what ordinary sellers pay; `dev_sell_pct: null` means the developer hasn’t sold, so there is nothing to compare. - `tax.realized.max_sell_pct_seen: 16.65` is the worst single sell. The headline rate is a median of recent trades, so one unlucky trade doesn’t set it. - `tax_history` shows a 5% sell tax from block 99421932 and a 1% buy tax from block 99791485; `tax_mode: "static"` means neither side has changed since. - The token contract can’t tax: `contract.can_change_tax: false`, `ownership: "renounced"`. The tax comes from the pool’s v4 hook, whose `hook.flags` include `tax_observed` (“7 of its 7 measured pools take 1%+ per trade… up to 6.3%”). - The 5.28% costs 15 points (`tax_over_5pct`), and the hook costs 10 more (`hook_medium_risk`): `score: 70`, `risk: "medium"`. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%205%25%20sell%20tax%3A%20Ruby%20\(RUBY\)&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-token-taxes%2F%23sell-tax%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A 7% buy tax that changed over time: Recast (CAST) Recast (0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a) is a graduated Pons token. How much do buyers lose? GET/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 188 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "tax_over_5pct", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x441568fdd10b00ddc90b4a95aee03d8d06242283", "liquidity_usd": 2.08528, "pct": 0.0195019 }, "sniper_supply_pct": 0.61622, "sniper_top_wallet_pct": 0.61622, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "locked", "summary": { "burned_pct": 0, "locked_pct": 99.9805, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.019502, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 80, "tax": { "buy_pct": 6.99, "confidence": "high", "realized": { "buy_pct": 6.99, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793223683000, "max_sell_pct_seen": 1, "samples": { "buys": 1107, "sells": 530 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 82850924, "pct": 0, "side": "buy" }, { "from_block": 82929088, "pct": 0, "side": "sell" }, { "from_block": 85677230, "pct": 1, "side": "buy" }, { "from_block": 85686101, "pct": 0, "side": "buy" }, { "from_block": 90626923, "pct": 7, "side": "buy" } ], "tax_history_total": 9, "tax_mode": "dynamic", "token": "0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a" }, "meta": { "block": 100406621, "block_age_ms": 400, "block_ts": 1793225060000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 10, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `tax.buy_pct: 6.99` and `tax.sell_pct: 0`, measured over 1,107 buys and 530 sells (`confidence: "high"`). - `tax_mode: "dynamic"`: the buy tax has moved. `tax_history_total: 9` changes; the first ones show the buy side going from 0 to 1%, back to 0, then 7% from block 90626923. - `tax.simulated: null` and `meta.simulation: "no V2 WETH pair: realized tax only"`: the token only trades in a Uniswap v4 pool, so there is no router simulation and the realized rate is the answer. - `flags: ["tax_over_5pct", "unverified"]` and `score: 80`, still `risk: "low"`. The score treats a 7% buy tax as a cost, not a trap: you can buy and sell, you just pay for it. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%207%25%20buy%20tax%20that%20changed%20over%20time%3A%20Recast%20\(CAST\)&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-token-taxes%2F%23buy-tax%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the tax fields mean | Field | Meaning | | --- | --- | | `tax.buy_pct`, `tax.sell_pct` | The current tax in percent, from real trades where there are any, else from the simulation. `null` when there is nothing to measure. | | `tax.source` | `realized` (real trades), `realized+simulated` (buys from trades, sells from the simulation), `simulated`, or `none`. | | `tax.confidence` | `high` with 20+ measured trades, `medium` with 3+, `low` below that. | | `tax.realized.samples` | How many buys and sells were measured. | | `tax.realized.by_wallet_class` | `others_sell_pct` for ordinary sellers and `dev_sell_pct` for the developer, measured separately. | | `tax.realized.max_sell_pct_seen` | The highest tax a single sell paid. Much higher than `sell_pct` means some sells were hit hard. | | `tax.simulated` | The simulated buy → transfer → sell at the latest block (`can_buy`, `can_sell`, `buy_pct`, `sell_pct`, `transfer_pct`, `revert_reason`), or `null` without a Uniswap v2 WETH pair. | | `tax.transfer_pct` | Tax on a plain wallet-to-wallet transfer, from the simulation. | | `tax_mode` | `static`, or `dynamic` when a side's measured rate has changed more than once. | | `tax_history` | Each change: `from_block`, `side` (`buy` or `sell`) and `pct` in whole percent. `tax_history_total` counts them all. | | `contract.can_change_tax` | The contract has a function to change its tax. It only matters while `contract.ownership` is `active`. | How the realized and simulated numbers are produced, and when they disagree, is explained in [How Crius measures taxes](https://docs.crius.sh/concepts/taxes/). ## Use it in your app 1. **Call `/security` for the token.** It’s on the anonymous plan; with a key it costs 1 credit. The tax fields come back with the rest of the security check. 2. **Show both sides and the evidence.** Display `buy_pct` and `sell_pct` with `confidence`, and say when they come from fewer than 20 trades. 3. **Warn on taxes that can move.** Treat `tax_mode: "dynamic"`, `contract.can_change_tax` with an active owner, or a hook flagged `fee_changeable` or `dynamic_tax` as “the tax may change after you buy”. 4. **Use the tax in your quote.** Take `buy_pct` off the tokens a user expects to receive and `sell_pct` off the ETH they expect back, so the slippage setting covers the tax. ```js // Read a token's tax before quoting a trade. const token = "0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be"; // Ruby const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/security`); const { data } = await res.json(); const { buy_pct, sell_pct, source, confidence } = data.tax; console.log(`buy ${buy_pct ?? "?"}%, sell ${sell_pct ?? "?"}% (${source}, ${confidence} confidence)`); if (data.tax_mode === "dynamic") console.warn(`tax has changed ${data.tax_history_total} times`); if (data.flags.includes("high_tax")) console.warn("tax above 10%"); ``` A 0% tax is not a safe sell `tax.sell_pct: 0` only means the sells that happened paid nothing. A token that blocks sells has no sells to measure. Always check `honeypot.is_honeypot` as well: see [How to detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/). ## Frequently asked questions **How to check token tax on Robinhood Chain?** Send `GET https://api.crius.sh/v1/robinhood/token/{address}/security` (no key needed) and read `tax.buy_pct` and `tax.sell_pct`, in percent. Check `tax.source` and `tax.confidence` to see what the numbers are based on, and `tax_mode` to see whether the tax has changed over time. **Does Crius read the tax from the contract or measure it?** It measures it. For every trade Crius compares what the pool sent with what the wallet received, so the tax is what traders really paid, whether the token contract or a Uniswap v4 hook takes it. Where the token has a Uniswap v2 WETH pair, a simulated buy, transfer and sell at the latest block backs it up (`tax.simulated`). The contract is only checked for whether someone can still change the tax (`contract.can_change_tax`). **The token contract has no tax and ownership is renounced. Why does the API show a 5% sell tax?** Because the tax is taken somewhere else, usually in the pool's Uniswap v4 hook. Ruby (`0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be`) has a renounced contract with `can_change_tax: false`, yet sellers pay 5.28%: its pool's hook takes it. That is why Crius measures taxes from trades instead of reading the token's code. **Can a token's tax change after I buy?** Yes, if someone can still change it. `tax_mode: "dynamic"` means the measured rate has already changed more than once; `tax_history` lists each change with the block it took effect. `contract.can_change_tax` with an active owner, or a hook with a fee setter, means it can change again. Subscribe to the [WebSocket stream](https://docs.crius.sh/reference/stream/) or re-check before each trade. **Is the ~3% buy fee on Pons tokens a tax?** It is counted in `tax.buy_pct`, because buyers receive less than the pool sent. On graduated Pons tokens it is the launchpad's standard fee taken by its v4 hook (sockets pays 2.69%), and it stays under the 5% that costs points in the security score. ## Related [Concept **Score confidence & limits** What the Crius security score can and can't see on Robinhood Chain, how to read its confidence fields, and why a low-risk result is not a guarantee a token is safe. Read](https://docs.crius.sh/concepts/security-score-limits/) [Concept **Token taxes** How Crius measures buy, sell and transfer taxes on Robinhood Chain tokens from real trades and from a simulated buy and sell, how the two are combined, and how tax changes are tracked. Read](https://docs.crius.sh/concepts/taxes/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Get fees & creator rewards** See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response. Read](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/) [API reference **Security checks API** Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. Read](https://docs.crius.sh/reference/security/security-checks/) --- # Check the risk of a Uniswap v4 hook > Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Source: https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/security` and read `hook`: its `risk_level` (`low`, `medium`, `high`, `critical`), `flags` with evidence, decoded `permissions` and `capabilities`, its `code`, what happened in its pools (`observed`) and its code family's record. For any hook address, `GET /v1/robinhood/hook/{address}` returns the same and more (Free plan, 2 credits); `GET /v1/robinhood/hooks` lists every hook on chain. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/hook/{address}`](https://docs.crius.sh/reference/pools/hook-detail/) [GET `/hooks`](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) A Uniswap v4 hook is a contract that a pool calls on every swap or liquidity change. It is how launchpads take their fee, and also how a pool can tax, reprice or block trades without the token contract doing anything. Crius inspects every hook on Robinhood Chain: what its address allows it to do, what code sits there and who owns it, and what has actually happened in the pools that use it. The result is a `risk_level` and a list of flags, each with the evidence behind it. ## Check a token’s hook in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A hook that taxes: Ruby's pool, medium risk Ruby (0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be) trades in a Uniswap v4 pool with an unnamed hook. What can the hook do? GET/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 191 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x000000000000000000000000000000000000dead", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "tax_over_5pct", "hook_can_block_swaps", "hook_medium_risk", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0x97240e95756c7b70db1ffaeee85a6c091c33a4ce", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": false, "can_modify_liquidity_amounts": true, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207142599, "code_hash": "0x5cb5a35842eb82ff5c9dbed2dca84d023823d841a2c0fc642568bc8ff276f72f", "family": "0xaa8854cbf2bd", "kind": "contract", "logic": null, "owner": "0x33acedd086ee7fec19764b5f4a93a6ef067953f5", "ownership": "active", "size": 24040 }, "family": { "honeypot_pct": 0, "hooks": 3, "id": "0xaa8854cbf2bd", "liquidity_pulled_pct": 0, "pools_traded": 10, "taxed_pct": 90, "verified_hooks": 0 }, "flags": [ { "evidence": "7 of its 7 measured pools take 1%+ per trade (median per pool, up to 6.3%); only 10.83% of traded hooked pools tax at all", "flag": "tax_observed", "severity": "medium" }, { "evidence": "can take part of every swap (return delta); 4.55% of traded pools of hooks that can block swaps and change swap amounts taxed, 0.61% became honeypots", "flag": "can_modify_swap_amounts", "severity": "low" } ], "name": null, "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1793119940000, "honeypot_pools": 0, "last_trade_ts": 1793223286000, "liquidity_pulled_pct": 0, "liquidity_pulled_pools": 0, "max_buy_tax_pct": 2.545, "max_sell_tax_pct": 6.28, "median_pool_life_min": 1380, "pools": 18, "pools_traded": 8, "tax_measured_pools": 7, "taxed_10pct_pools": 0, "taxed_pools": 7, "volume_usd": 924751 }, "pattern": { "description": "hooks that can block swaps and change swap amounts", "honeypot_pct": 0.608377, "id": "before_swap_with_delta", "liquidity_pulled_pct": 21.5893, "pools_traded": 18574, "taxed_pct": 4.55475 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "beforeSwap", "afterSwap", "beforeSwapReturnDelta" ], "risk": [ "can_block_or_reprice_swaps", "can_modify_swap_amounts", "can_modify_liquidity_amounts", "unverified" ], "risk_level": "medium" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x20ac92362ead44f457913ca1a6c24fae049078d9", "liquidity_usd": 23.0571, "pct": 0.214633 }, "sniper_supply_pct": 1.77655, "sniper_top_wallet_pct": 1.77655, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 99.2777, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.722259, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 70, "tax": { "buy_pct": 0.84, "confidence": "high", "realized": { "buy_pct": 0.84, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 5.28 }, "last_sample_ts": 1793221716000, "max_sell_pct_seen": 16.65, "samples": { "buys": 8, "sells": 240 }, "sell_pct": 5.28, "window": "30d" }, "sell_pct": 5.28, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 99421932, "pct": 5, "side": "sell" }, { "from_block": 99791485, "pct": 1, "side": "buy" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be" }, "meta": { "block": 100406622, "block_age_ms": 595, "block_ts": 1793225060000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 100, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `hook.address: "0x97240e95756c7b70db1ffaeee85a6c091c33a4ce"`, `name: null`: not a known launchpad or protocol hook. `hook.risk_level: "medium"`. - `hook.capabilities`: `can_block_swaps`, `can_modify_swap_amounts` and `can_modify_liquidity_amounts` are all `true`. `permissions` include `beforeSwap` and `beforeSwapReturnDelta`: it runs before every swap and can change the amounts. - The `medium` comes from what it did, not what it could do. The `tax_observed` flag’s evidence: “7 of its 7 measured pools take 1%+ per trade (median per pool, up to 6.3%); only 10.83% of traded hooked pools tax at all”. `observed.max_sell_tax_pct: 6.28` matches the token’s `tax.sell_pct: 5.28`. - `observed.honeypot_pools: 0` and `liquidity_pulled_pools: 0` over 8 traded pools: no trapped buyers and no rugs so far. - `code.ownership: "active"` with owner `0x33acedd086ee7fec19764b5f4a93a6ef067953f5`, and `code.admin_functions: []`: an owner exists, but no fee setter, pause, blacklist or withdraw function was found in its code. - `pattern.id: "before_swap_with_delta"`: across 18,574 traded pools of hooks with these permissions, 0.61% became honeypots and 21.59% had liquidity pulled. - On the token: `hook_medium_risk` (−10 points) and `hook_can_block_swaps` (for information, 0 points). [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20hook%20that%20taxes%3A%20Ruby's%20pool%2C%20medium%20risk&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-uniswap-v4-hook-risk%2F%23taxing-hook%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Free plan · 2 credits](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) ### The most-used hooks on Robinhood Chain Which hooks do most v4 pools use, and how risky are they? GET/v1/robinhood/hooks?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/hooks?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/hooks?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/hooks?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 258 lines (arrays trimmed)** ```json { "data": [ { "address": "0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", "attribution": "unattributed", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143998, "code_hash": "0xc41a91106002f15bf70ae266824317f3f3ac638ac72ca5253bae395fa47ee631", "family": "0xaa37a5a3457a", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 25533 }, "events_sample": [ "Swap", "ModifyLiquidity", "Create" ], "family": { "honeypot_pct": 0.0318652, "hooks": 1, "id": "0xaa37a5a3457a", "liquidity_pulled_pct": 0.0389463, "pools_traded": 28244, "taxed_pct": 1.78091, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x2544", "launchpad": null, "launchpad_name": null, "name": "DopplerHookInitializer", "observed": { "dynamic_tax_pools": 24, "first_trade_ts": 1782922953000, "honeypot_pools": 9, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.0389463, "liquidity_pulled_pools": 11, "max_buy_tax_pct": 99.52, "max_sell_tax_pct": 93.49, "median_pool_life_min": 2138, "pools": 224061, "pools_traded": 28244, "tax_measured_pools": 5814, "taxed_10pct_pools": 29, "taxed_pools": 503, "volume_usd": 1968346259 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "afterRemoveLiquidity" ], "pools": 224090, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "trades_24h": 59387, "volume_usd_24h": 7478239 }, "verified": true }, { "address": "0x48b8f6ad3a1b4aa477314c9a23035b8f84dde8cc", "attribution": "unattributed", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": true, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143709, "code_hash": "0x0883056c4856f8fe464ff49f9c1c028455459dad8ceddcc6d5159259fe51e07f", "family": "0x8f75b80c2683", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 16405 }, "events_sample": [ "ClaimProtocolFees", "PoolInitialized", "PoolCreatedFactory" ], "family": { "honeypot_pct": 3.67232, "hooks": 1, "id": "0x8f75b80c2683", "liquidity_pulled_pct": 1.41243, "pools_traded": 354, "taxed_pct": 0, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x28cc", "launchpad": null, "launchpad_name": null, "name": "ClankerHookStaticFeeV2", "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1783535745000, "honeypot_pools": 13, "last_trade_ts": 1793222422000, "liquidity_pulled_pct": 1.41243, "liquidity_pulled_pools": 5, "max_buy_tax_pct": 0.99, "max_sell_tax_pct": 0.395, "median_pool_life_min": 6549.5, "pools": 15412, "pools_traded": 354, "tax_measured_pools": 276, "taxed_10pct_pools": 0, "taxed_pools": 0, "volume_usd": 14554905 }, "pattern": { "description": "hooks that can block swaps and change swap amounts", "honeypot_pct": 0.608377, "id": "before_swap_with_delta", "liquidity_pulled_pct": 21.5893, "pools_traded": 18574, "taxed_pct": 4.55475 }, "permissions": [ "beforeInitialize", "beforeAddLiquidity", "beforeSwap" ], "pools": 15412, "risk": [ "can_block_or_reprice_swaps", "can_modify_swap_amounts", "can_gate_liquidity_add" ], "risk_level": "low", "stats": { "trades_24h": 335, "volume_usd_24h": 29851.6 }, "verified": true }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "attribution": "known_launchpad", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "events_sample": [ "HookFeeCollected", "PoolFeesSwept", "PoolRegistered" ], "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x2044", "launchpad": "pons", "launchpad_name": "Pons", "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "pools": 10479, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "trades_24h": 118712, "volume_usd_24h": 11871071 }, "verified": true } ], "meta": { "block": 100406858, "block_age_ms": 657, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "intel_computed_ts": 1793223685333, "lag_ms": 221, "next_cursor": "3", "safe_block": 100401329, "total": 29952 } } ``` What this tells you - `meta.total: 29952` hooks on chain; sorted by pool count, the top three are DopplerHookInitializer (224,090 pools), ClankerHookStaticFeeV2 (15,412) and PonsV2MemeHook (10,479). All three are `verified: true` and `risk_level: "low"`. - ClankerHookStaticFeeV2 (`0x48b8f6ad3a1b4aa477314c9a23035b8f84dde8cc`) has `can_block_swaps: true` and `can_gate_liquidity: true`, and `observed.honeypot_pools: 13` of 354 traded. It stays `low`: it’s a verified protocol hook, and 13 of 354 is a small share. - PonsV2MemeHook (`0xe5e702641ea86f4ae6cc3cdaed2b886f976be044`) has `attribution: "known_launchpad"`, `launchpad: "pons"`. Its `family.taxed_pct` of 51.97 is the launchpad’s own fee, which is why a verified launchpad hook is only flagged for tax when its pools take 10% or more. - `stats.trades_24h` and `stats.volume_usd_24h` show how active each hook is: 118,712 trades in 24 hours for the Pons hook. [Uniswap v4 hooks reference](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20most-used%20hooks%20on%20Robinhood%20Chain&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-uniswap-v4-hook-risk%2F%23hook-list%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fhooks%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Free plan · 2 credits](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) ### Critical hooks: no code, and a honeypot code family Which Uniswap v4 hooks on Robinhood Chain are the most dangerous, and why? GET/v1/robinhood/hooks?risk\_level=high,critical&sort=risk&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/hooks?risk_level=high,critical&sort=risk&limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/hooks?risk_level=high,critical&sort=risk&limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/hooks?risk_level=high,critical&sort=risk&limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 297 lines (arrays trimmed)** ```json { "data": [ { "address": "0x00000000000000000000000000000000dead0030", "attribution": "unattributed", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": false }, "code": { "admin_functions": [], "checked_ts": 1793208104654, "code_hash": "", "family": null, "kind": "no_code", "logic": null, "owner": null, "ownership": "none", "size": 0 }, "family": null, "flags": [ { "evidence": "no contract at the hook address: v4 calls into it fail, so swaps in its pools revert", "flag": "no_code", "severity": "critical" }, { "evidence": "liquidity was pulled in 142 of its 143 traded pools", "flag": "rugs_observed", "severity": "high" }, { "evidence": "tax swung by 5%+ within 22 of its 124 measured pools", "flag": "dynamic_tax", "severity": "medium" } ], "flags_hex": "0x30", "launchpad": null, "launchpad_name": null, "name": null, "observed": { "dynamic_tax_pools": 22, "first_trade_ts": 1786194462000, "honeypot_pools": 0, "last_trade_ts": 1792690001000, "liquidity_pulled_pct": 99.3007, "liquidity_pulled_pools": 142, "max_buy_tax_pct": 1.99, "max_sell_tax_pct": 1.99, "median_pool_life_min": 150, "pools": 205, "pools_traded": 143, "tax_measured_pools": 124, "taxed_10pct_pools": 0, "taxed_pools": 2, "volume_usd": 1597201 }, "pattern": { "description": "hook addresses with no code", "honeypot_pct": 0, "id": "no_code", "liquidity_pulled_pct": 99.3007, "pools_traded": 143, "taxed_pct": 1.3986 }, "permissions": [ "beforeDonate", "afterDonate" ], "pools": 205, "risk": [ "unverified" ], "risk_level": "critical", "stats": { "trades_24h": 0, "volume_usd_24h": 0 }, "verified": null }, { "address": "0x593da569c2a5a6999f59fcc5b06477d8bb4dc080", "attribution": "unattributed", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": false }, "code": { "admin_functions": [ "blacklist" ], "checked_ts": 1793207136068, "code_hash": "0x49d3bdb05d0e518dbd5da6a7335e820fc4b5d84bc59c9cce45bb972a8c0798a9", "family": "0x6f11e9734465", "kind": "contract", "logic": null, "owner": "0x4e59b44847b379578588920ca78fbf26c0b4956c", "ownership": "active", "size": 2458 }, "family": { "honeypot_pct": 94.2857, "hooks": 34, "id": "0x6f11e9734465", "liquidity_pulled_pct": 80, "pools_traded": 35, "taxed_pct": 0, "verified_hooks": 0 }, "flags": [ { "evidence": "94% of 35 traded pools of its code family 0x6f11e9734465 (34 hooks) became honeypots", "flag": "honeypot_family", "severity": "critical" }, { "evidence": "liquidity was pulled in 80% of 35 traded pools of its code family 0x6f11e9734465 (34 hooks)", "flag": "rug_family", "severity": "high" }, { "evidence": "10.6% of 3326 traded pools of hooks that can block or reprice swaps (beforeSwap) without taking a delta became honeypots, 69% had liquidity pulled", "flag": "can_block_swaps", "severity": "high" }, { "evidence": "owner-callable functions: blacklist", "flag": "owner_controls", "severity": "medium" } ], "flags_hex": "0x80", "launchpad": null, "launchpad_name": null, "name": null, "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1785744995000, "honeypot_pools": 0, "last_trade_ts": 1785773803000, "liquidity_pulled_pct": 0, "liquidity_pulled_pools": 0, "max_buy_tax_pct": 0, "max_sell_tax_pct": 0, "median_pool_life_min": 0, "pools": 142, "pools_traded": 0, "tax_measured_pools": 0, "taxed_10pct_pools": 0, "taxed_pools": 0, "volume_usd": 53234.8 }, "pattern": { "description": "hooks that can block or reprice swaps (beforeSwap) without taking a delta", "honeypot_pct": 10.6133, "id": "before_swap_only", "liquidity_pulled_pct": 69.1221, "pools_traded": 3326, "taxed_pct": 1.89417 }, "permissions": [ "beforeSwap" ], "pools": 142, "risk": [ "can_block_or_reprice_swaps", "unverified" ], "risk_level": "critical", "stats": { "trades_24h": 0, "volume_usd_24h": 0 }, "verified": null }, { "address": "0xce9b07b09b9a2b016a343e85936ffb7849f2c080", "attribution": "unattributed", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": false }, "code": { "admin_functions": [ "blacklist" ], "checked_ts": 1793207142720, "code_hash": "0x49d3bdb05d0e518dbd5da6a7335e820fc4b5d84bc59c9cce45bb972a8c0798a9", "family": "0x6f11e9734465", "kind": "contract", "logic": null, "owner": "0x4e59b44847b379578588920ca78fbf26c0b4956c", "ownership": "active", "size": 2458 }, "family": { "honeypot_pct": 94.2857, "hooks": 34, "id": "0x6f11e9734465", "liquidity_pulled_pct": 80, "pools_traded": 35, "taxed_pct": 0, "verified_hooks": 0 }, "flags": [ { "evidence": "1 of its 1 traded pools had 10+ buys and no sells", "flag": "honeypot_observed", "severity": "critical" }, { "evidence": "94% of 35 traded pools of its code family 0x6f11e9734465 (34 hooks) became honeypots", "flag": "honeypot_family", "severity": "critical" }, { "evidence": "liquidity was pulled in 80% of 35 traded pools of its code family 0x6f11e9734465 (34 hooks)", "flag": "rug_family", "severity": "high" }, { "evidence": "10.6% of 3326 traded pools of hooks that can block or reprice swaps (beforeSwap) without taking a delta became honeypots, 69% had liquidity pulled", "flag": "can_block_swaps", "severity": "high" }, { "evidence": "owner-callable functions: blacklist", "flag": "owner_controls", "severity": "medium" } ], "flags_hex": "0x80", "launchpad": null, "launchpad_name": null, "name": null, "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1788387847000, "honeypot_pools": 1, "last_trade_ts": 1788725350000, "liquidity_pulled_pct": 100, "liquidity_pulled_pools": 1, "max_buy_tax_pct": 0, "max_sell_tax_pct": 0, "median_pool_life_min": 16, "pools": 141, "pools_traded": 1, "tax_measured_pools": 1, "taxed_10pct_pools": 0, "taxed_pools": 0, "volume_usd": 142769 }, "pattern": { "description": "hooks that can block or reprice swaps (beforeSwap) without taking a delta", "honeypot_pct": 10.6133, "id": "before_swap_only", "liquidity_pulled_pct": 69.1221, "pools_traded": 3326, "taxed_pct": 1.89417 }, "permissions": [ "beforeSwap" ], "pools": 141, "risk": [ "can_block_or_reprice_swaps", "unverified" ], "risk_level": "critical", "stats": { "trades_24h": 0, "volume_usd_24h": 0 }, "verified": null } ], "meta": { "block": 100415559, "block_age_ms": 1099, "block_ts": 1793225982000, "chain": "robinhood", "finalized_block": 100405028, "intel_computed_ts": 1793225485302, "lag_ms": 364, "next_cursor": "3", "safe_block": 100408671, "total": 20073 } } ``` What this tells you - `meta.total: 20073`: that many hooks are rated `high` or `critical`, against 29,952 in the unfiltered list above. `sort=risk` puts the worst first. - `0x00000000000000000000000000000000dead0030` has `code.kind: "no_code"` (flag `no_code`, critical): there is no contract at the address. It also has `rugs_observed`: “liquidity was pulled in 142 of its 143 traded pools”, with a `median_pool_life_min` of 150. - `0x593da569c2a5a6999f59fcc5b06477d8bb4dc080` has no traded pools of its own (`observed.pools_traded: 0`), yet it is critical: `honeypot_family` says “94% of 35 traded pools of its code family 0x6f11e9734465 (34 hooks) became honeypots”. A new hook inherits its family’s record. - `0xce9b07b09b9a2b016a343e85936ffb7849f2c080` has the same `code_hash` and family, and its own pool confirms it: `honeypot_observed`, “1 of its 1 traded pools had 10+ buys and no sells”, after a median pool life of 16 minutes. - Both family hooks have only the `beforeSwap` permission (`can_block_swaps: true`), an owner (`ownership: "active"`) and a `blacklist` function (`owner_controls`): a hook that can refuse swaps, with an owner who can blacklist wallets. [Uniswap v4 hooks reference](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Critical%20hooks%3A%20no%20code%2C%20and%20a%20honeypot%20code%20family&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcheck-uniswap-v4-hook-risk%2F%23critical-hooks%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fhooks%3Frisk_level%3Dhigh%2Ccritical%26sort%3Drisk%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the hook fields mean | Field | Meaning | | --- | --- | | `risk_level` | The worst severity among `flags`: `low`, `medium`, `high` or `critical`. | | `flags[]` | Each finding: `flag`, `severity` and `evidence` (a sentence with the numbers behind it). | | `permissions`, `flags_hex` | The callbacks the hook can run, decoded from the low 14 bits of its address. They can't change after deployment. | | `capabilities` | Plain-language summary: `can_block_swaps`, `can_modify_swap_amounts`, `can_modify_liquidity_amounts`, `can_gate_liquidity`. | | `code` | What sits at the address (`kind`), its `owner` and `ownership`, `admin_functions` found in its code, `size`, `code_hash` and `family`. | | `observed` | Its own pools: `pools`, `pools_traded`, `honeypot_pools`, `liquidity_pulled_pools`, `taxed_pools`, `taxed_10pct_pools`, `max_buy_tax_pct`, `max_sell_tax_pct`, `dynamic_tax_pools`, `volume_usd`, `median_pool_life_min`. | | `family` | The same record summed over every hook with the same code (`hooks`, `pools_traded`, `honeypot_pct`, `liquidity_pulled_pct`, `taxed_pct`): a new hook inherits its family's history. | | `pattern` | Honeypot, rug and tax rates of all hooks with the same swap permissions (`id`, `description`). | | `verified`, `attribution`, `launchpad` | Whether the hook is a known launchpad or protocol hook (on `/hooks` and `/hook`). | The full list of flags, what triggers each one and how verified hooks are treated is in [Uniswap v4 hook risk](https://docs.crius.sh/concepts/uniswap-v4-hooks/). ## Use it in your app 1. **Read `hook` from `/security`.** It’s `null` for tokens priced in a pool without a hook (any v2 or v3 pool, or a v4 pool without one). No key needed. 2. **Gate on `risk_level`.** Block `critical` (swaps can fail, the code can be replaced, or its pools trap buyers), warn on `high`, and show `medium` with its evidence. 3. **Show the evidence, not just the level.** Each `flags[].evidence` is written to be shown to users as-is. 4. **Look up hooks directly.** `/hook/{address}` adds the events the hook emits and its pools’ fee tiers; `/hooks?risk_level=high,critical&sort=risk` lists the riskiest hooks on chain (Free plan). ```js // Warn about a token's v4 hook before trading. const token = "0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be"; // Ruby const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/security`); const { hook } = (await res.json()).data; if (!hook) console.log("no v4 hook on the pricing pool"); else { console.log(`${hook.name ?? hook.address}: ${hook.risk_level} risk`); for (const f of hook.flags) console.log(`- [${f.severity}] ${f.flag}: ${f.evidence}`); } ``` Which pool's hook? `/security` reports the hook of the pool the token’s price comes from (its main pool). A token with several v4 pools can have other hooks: list them with [`/token/{address}/pools`](https://docs.crius.sh/reference/tokens/token-markets/) and check each with `/hook/{address}`. ## Frequently asked questions **What is a Uniswap v4 hook and why does it matter for a token?** A hook is a contract a Uniswap v4 pool calls before or after swaps and liquidity changes. It can take a fee on every trade, change swap amounts, block swaps or stop liquidity from being added or removed. A token with a clean contract can still be taxed or trapped by its pool's hook, so the hook needs its own check. **How do I check a Uniswap v4 hook's risk on Robinhood Chain?** For a token, call `/v1/robinhood/token/{address}/security` (no key) and read `hook.risk_level` and `hook.flags`. For a hook address, call `/v1/robinhood/hook/{address}` with a free key. Each flag has a `severity` and an `evidence` sentence you can show users as-is. **Why is a hook that can block swaps rated low risk?** Permissions say what a hook could do, not what it does. Hooks verified in Crius's registry (launchpads and known protocols, `verified: true`) are judged only on what happened in their pools, and those results are shares, not counts: a hook with 13 honeypot pools out of 354 traded is not a honeypot hook. Unverified hooks are also judged on their permissions and their code family's record. **How much does a risky hook cost in the security score?** The token loses 60 points for a `critical` hook (`hook_critical_risk`, and the token becomes `risk: "high"`), 30 for `high` and 10 for `medium`. A `low` hook costs nothing. `hook_can_block_swaps` is added for information when the hook can block swaps. **How often is hook risk updated?** Every hook on chain is re-assessed every 30 minutes (`meta.intel_computed_ts` on `/hooks` and `/hook`). Hooks whose code can change (proxies, delegated wallets) are re-inspected every 6 hours, and hooks with an active owner daily. ## Related [Concept **v4 hook risk** How Crius rates every Uniswap v4 hook on Robinhood Chain, from its permissions, its code and owner, what happened in its pools and its code family's record, with each risk flag and its threshold. Read](https://docs.crius.sh/concepts/uniswap-v4-hooks/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Hook detail API** One hook: decoded permissions, code (kind, owner, admin functions), what happened in its pools, its code family's history, flags with evidence and risk level, and the events it emits. Read](https://docs.crius.sh/reference/pools/hook-detail/) [API reference **Uniswap v4 hooks API** Every v4 hook seen on chain, with pool count, volume, verification, risk level and flags. Read](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) --- # What is the best Robinhood Chain data API? How to choose one > How to choose a Robinhood Chain data API: nine criteria, from launchpads and realized taxes to WebSockets and free plans, and a sourced provider comparison. Source: https://docs.crius.sh/guides/choose-a-robinhood-chain-data-api/ · Updated 2026-10-28 Short answer It depends on what you build. For Robinhood Chain app data (prices, candles, trades, holders at past blocks, launchpads, realized taxes, honeypots, v4 hook risk) a chain-specific indexed API such as Crius answers each question in one call. To send transactions or read raw state, use an RPC provider (Alchemy, QuickNode, Goldsky Edge). For one schema across many chains, Bitquery, GoldRush or Mobula. For SQL research, Dune. [GET `/v1/status`](https://docs.crius.sh/reference/chain/service-status/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/holders/snapshot`](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) The best Robinhood Chain data API is the one that answers your app’s questions in the fewest calls, with data you can trust and a plan you can afford. A trading bot needs realized taxes, honeypot checks and a live stream; a screener needs launchpad attribution and clean token lists; an analytics product needs history from the first block. This page lists the criteria that separate providers on Robinhood Chain, how to test each, and a comparison built from the providers’ own documentation, checked in October 2026. ## The criteria 1. **Coverage depth.** Does history start at block 0, and are Uniswap v2, v3, v4 and the launchpad bonding curves decoded? Check the provider’s status or coverage information for a start block. 2. **Launchpad attribution.** Many Robinhood Chain tokens launch on bonding curves (Pons, Flap.sh, Bankr, Long.xyz and others). Can the API tell you which launchpad a token came from, how far along its curve it is, and when and where it graduated? 3. **Realized taxes.** Reading a tax from the contract misses taxes taken by v4 hooks. Ask whether taxes are measured from what buyers and sellers actually paid, with a sample count. 4. **Honeypot simulation.** A token can have clean past trades and still block sells now. Ask whether the API simulates a buy, transfer and sell at the current block. 5. **Uniswap v4 hook risk.** v4 pools can run arbitrary hook code that blocks or reprices swaps. Does the API decode hook permissions and flag risky hooks? 6. **Holders at past points.** “Who held before $50k market cap?” needs balances at an earlier block. Can you ask by block, time, market cap or lifecycle event, or only for today’s holders? 7. **WebSocket.** Push channels per token, pool and wallet, a replay buffer after disconnects, and explicit reorg handling, rather than polling. 8. **Free plan.** Can you build and test without a card, and is there a keyless tier for prototypes? 9. **Latency.** How far behind the chain head is the data? Look for a lag number in every response, and measure it yourself at the time of day you’ll run. ## Measure coverage and latency yourself Example [Anonymous · no key · free](https://docs.crius.sh/reference/chain/service-status/) ### Index health: start block, lag and size How far back does Crius's Robinhood Chain index go, and how far behind the chain is it? GET/v1/status **cURL** ```bash curl "https://api.crius.sh/v1/status" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/status"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/status", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 21 lines (arrays trimmed)** ```json { "data": { "chains": { "robinhood": { "addresses": 29509881, "block_age_ms": 1203, "chain_id": 4663, "finalized_block": 100397649, "indexed_block": 100406757, "lag_ms": 50, "pools": 2780862, "safe_block": 100401329, "start_block": 0, "status": "live", "tokens": 2406786 } }, "region": "rigel", "version": "0.1.0" } } ``` What this tells you - `start_block: 0`: the index starts at the chain’s first block, so history, holders at past blocks and all-time stats cover the whole chain. - `status: "live"` and `lag_ms: 50`: when this was captured, the index was 50 ms behind the chain head. Every data response repeats `lag_ms` and `block` in `meta`, so you can log it over time. - The index holds 2,406,786 `tokens`, 2,780,862 `pools` and 29,509,881 `addresses`, with `safe_block` and `finalized_block` for apps that need settled data. [Service status reference](https://docs.crius.sh/reference/chain/service-status/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Index%20health%3A%20start%20block%2C%20lag%20and%20size&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fchoose-a-robinhood-chain-data-api%2F%23coverage%0ARequest%3A%20GET%20%2Fv1%2Fstatus%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How the providers compare From each provider’s public documentation, checked in October 2026. “Not verified” means we couldn’t confirm it from their docs, not that the feature is missing. Each provider links to a full comparison with sources. **Access, real-time and history** | Provider | What it is | Real-time | History | RPC | Free access | | --- | --- | --- | --- | --- | --- | | Crius | Robinhood Chain REST + WebSocket API | WebSocket channels per token, pool, wallet, launches, new pools | From block 0 | No (read API only) | Free plan: 1M credits/month, no card; keyless core calls | | [Bitquery](https://crius.sh/compare/bitquery/) | Indexed GraphQL data API | Any query as a GraphQL subscription | Not verified | No RPC or broadcasting (per Bitquery) | 7-day trial; paid from $49/month (per Bitquery) | | [Alchemy](https://crius.sh/compare/alchemy/) | RPC provider with token, transfer and price APIs | eth\_subscribe WebSockets, Webhooks | Not verified for Robinhood Chain | Full RPC; Debug/Trace not supported on this chain | Free account; Robinhood Chain limits not verified | | [QuickNode](https://crius.sh/compare/quicknode/) | RPC provider with archive, debug/trace and Streams | eth\_subscribe, Streams, Webhooks | Full archive (raw state, logs, traces) | Full RPC incl. debug and trace | “Start building for free” (limits not verified) | | [GoldRush (Covalent)](https://crius.sh/compare/goldrush/) | Multi-chain REST data API + JSON-RPC | Not verified for Robinhood Chain | Historical balances and transactions | JSON-RPC endpoint | Not verified | | [Mobula](https://crius.sh/compare/mobula/) | Multi-chain token and wallet REST API | Not verified for Robinhood Chain | Price history and OHLCV; depth not verified | Not documented | Not verified | | [Dune](https://crius.sh/compare/dune/) | SQL analytics warehouse | Warehouse queries, not push streams | Raw and decoded tables | No | Free tier exists; limits not verified | | [Goldsky](https://crius.sh/compare/goldsky/) | Subgraphs, data pipelines and RPC | Streaming pipelines | Backfilled into your subgraph or DB | Edge RPC | “Sign up for free” (limits not verified) | **Robinhood Chain specifics** | Provider | Launchpads | Uniswap v4 hooks | Honeypot / tax checks | Token holders | | --- | --- | --- | --- | --- | | Crius | Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets | Decoded permissions and risk flags | Realized + simulated tax, honeypot verdict | Live, snapshots at any block, cohorts, history | | Bitquery | Guides for Pons, Flap.sh, Bags.fm, trench.today, Pools.trade | v4 trades and events; hook risk not documented | Not verified | Token holders cube | | Alchemy | Not documented | Not documented | Not documented | Not verified | | QuickNode | Not documented | Not documented | Not documented | Build from transfers yourself | | GoldRush | Not documented | Not documented | Security API listed (scope not verified) | Token holders endpoint | | Mobula | Integration guides for several launchpads | Not verified | Token security endpoint | Holders endpoints | | Dune | Decoded tables if contracts are decoded | Decoded events in SQL | Not provided | Build from transfer events in SQL | | Goldsky | If you index them | If you index them | Not provided | If you build them | Other services you’ll come across: the **DexScreener API** lists Robinhood Chain pairs (pair-level prices and volume, no holder, wallet or launchpad lifecycle data); **Tatum** announced a Data API for Robinhood Chain on September 10, 2026, alongside RPC; **Blockscout** runs the chain’s explorer with its explorer API; **CoinGecko** has a Robinhood Chain API page for price and market data (details not verified); and Robinhood’s **public RPC** is free, shared and rate limited, described by RPC providers as meant for testing and wallet connectivity. ## When another provider fits better - **You send transactions, or need raw state, debug or trace data.** Use an RPC provider: QuickNode lists full archive with debug and trace and Streams; Alchemy adds Bundler, Gas Manager and Webhooks; Goldsky Edge serves RPC with failover. Many apps pair one with Crius. - **You need one schema across many chains.** Bitquery (GraphQL, Kafka, bulk exports), GoldRush (wallet and transaction APIs across chains) and Mobula (token and wallet data across chains) fit portfolio and multi-chain products. - **You do research in SQL.** Dune’s `robinhood` tables are built for ad hoc queries and dashboards, not low-latency app calls. - **You want your own schema and storage.** Goldsky’s subgraphs and pipelines index exactly the contracts you define, including your own. - **You need a launchpad Crius doesn’t attribute.** Bitquery and Mobula document some launchpads (Bags.fm, trench.today, Pools.trade, ApeStore, Bottom.fun, Bow.fun, DYOR.fun) that Crius doesn’t. Crius fits when the app needs Robinhood Chain answers rather than raw data: launchpad lifecycles, holders at any block or market cap, trades attributed to the real trader, realized taxes, honeypot simulation and v4 hook risk, over REST and a WebSocket stream, with a Free plan to start. If something on this page is out of date, write to [support@crius.sh](mailto:support@crius.sh). Try before you choose Every anonymous-plan endpoint in these docs has a **Run** button that calls the live API without a key. Compare the same token on each provider you’re considering: its taxes, its holders a week ago, its launchpad. The differences show up quickly. ## Frequently asked questions **What is the best Robinhood Chain data API?** There isn't one answer for every app. For trading bots, screeners, wallets and dashboards that need Robinhood Chain market data, an API built for the chain gives the most per call: Crius covers launchpad lifecycles, holders at any past block, realized and simulated taxes, honeypot checks and v4 hook risk, with history from block 0 and a WebSocket stream. If you need RPC, multi-chain schemas or SQL, see the providers in the table: each is the better fit for some of those jobs. **Which Robinhood Chain data APIs have a free plan?** Crius has a Free plan with 1,000,000 credits a month and no card, plus keyless core endpoints. As checked in October 2026: Bitquery lists a 7-day trial and paid plans from $49/month; QuickNode and Goldsky advertise free sign-up with limits we couldn't verify; Dune has a free tier with limits not verified; Alchemy, GoldRush and Mobula limits for Robinhood Chain were not verified. **Which APIs detect honeypots and taxes on Robinhood Chain?** Crius returns a honeypot verdict from a simulated buy, transfer and sell, plus taxes measured from real trades. Mobula documents a token security endpoint for Robinhood Chain, and GoldRush lists a Security API whose scope we couldn't verify. For Bitquery it isn't verified; Alchemy and QuickNode don't document one, and Dune and Goldsky don't provide one. **Which APIs cover Pons and other Robinhood Chain launchpads?** Crius attributes Pons, Flap.sh, Bankr, Long.xyz, Flywheel and King of the Markets, with curve progress, graduations and launch streams. Bitquery has GraphQL guides for Pons, Flap.sh, Bags.fm, trench.today and Pools.trade; Mobula has integration guides for ApeStore, Bottom.fun, Bow.fun and DYOR.fun. **Do I need an RPC provider as well as a data API?** If your app sends transactions, yes. Crius is read-only. Alchemy, QuickNode and Goldsky Edge serve Robinhood Chain RPC (QuickNode with debug and trace; Alchemy lists Debug and Trace as not supported on this chain), and Robinhood runs a shared public RPC meant for testing. ## Related [Guide **Migrate from RPC** Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs. Read](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/) [Concept **Robinhood Chain** What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Read](https://docs.crius.sh/concepts/robinhood-chain/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Docs **Plans, limits & credits** Crius API plans (Free, Starter, Pro, Business, Enterprise), monthly credits, requests per second, WebSocket limits, credit cost per endpoint and the rate-limit response headers. Read](https://docs.crius.sh/plans-and-limits/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) --- # How to create a token on Robinhood Chain (launchpads compared) > The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data. Source: https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/ · Updated 2026-10-28 Short answer Crius doesn't create tokens. On Robinhood Chain you create one through a launchpad (Pons, Flap.sh, Bankr, Long.xyz, Flywheel or King of the Markets) or by deploying your own ERC-20 and adding a Uniswap pool. Once it exists, `GET /v1/robinhood/tokens?list=new` lists it, `/token/{address}` shows how it was created (`creation.attribution`, `launchpad`) and `/token/{address}/security` scores it, all without an API key. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/search`](https://docs.crius.sh/reference/discovery/search/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) Crius doesn’t create tokens: it indexes them once they exist. On Robinhood Chain (chain ID 4663) a token is created in one of two ways. Most go through a **launchpad**, a set of contracts that deploys the token for you, gives it a first market (a bonding curve or a Uniswap v4 pool) and locks or burns the liquidity. The rest are **deployed directly**: someone deploys their own ERC-20 contract and adds a Uniswap pool by hand. This guide compares the six launchpads Crius attributes, using their live stats, and then shows how to find and check a new token, whichever way it was made. ## Robinhood Chain launchpads, side by side Each launchpad has its own page with contracts, fees and graduation rules. In short: | Launchpad (`launchpad` id) | How a token launches | After launch | Liquidity | Launches (all time / 24h) | | --- | --- | --- | --- | --- | | [Pons](https://docs.crius.sh/launchpads/pons/) (`pons`) | Per-token bonding curve priced in ETH, USDG or a stock token | Graduates to a Uniswap v4 pool with the PonsV2MemeHook | Locked permanently in the Pons launch locker | 716,441 / 1,942 | | [Flap.sh](https://docs.crius.sh/launchpads/flap/) (`flap`) | Curve inside the Flap Portal; tax or non-tax tokens | Graduates to a Uniswap v2 pair at 800 million tokens circulating | LP tokens burned | 387,424 / 1,185 | | [Bankr](https://docs.crius.sh/launchpads/bankr/) (`bankr`) | The Bankr agent launches through the Doppler Airlock | Trades on a Uniswap v4 pool from the first block; no graduation | Locked permanently | 98,674 / 22 | | [Long.xyz](https://docs.crius.sh/launchpads/long/) (`long`) | Long's launchers, through the Doppler Airlock | Trades on a Uniswap v4 pool from the first block; no graduation | In its Doppler v4 pool | 83,736 / 554 | | [Flywheel](https://docs.crius.sh/launchpads/flywheel/) (`flywheel`) | Factory opens a v4 pool whose hook holds the liquidity and takes 4% of every swap | Graduates in place when the hook's liquidity reaches its target | Held by the hook | 1,353 / 15 | | [King of the Markets](https://docs.crius.sh/launchpads/standard-reserve/) (`standard_reserve`) | Per-token bonding curve priced in SPCX, BABA or SKHY | Graduates to a Uniswap v4 pool against the same stock | Locked permanently | 2,193 / 1 | | Your own ERC-20 (`launchpad: null`) | You deploy the contract | Whatever pool you create on Uniswap v2, v3 or v4 | In your wallet unless you lock or burn it | Not counted per launchpad | Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/launchpads/launchpads/) ### Six launchpads: 716,441 Pons launches, 1.46% graduate Which Robinhood Chain launchpads exist, how many tokens has each launched, and how many graduate? GET/v1/robinhood/launchpads **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 225 lines (arrays trimmed)** ```json { "data": [ { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 114492, "tax": 155324, "total": 269817 }, "graduated": 10485, "graduated_24h": 22, "graduation_rate_pct": 1.46348, "launches_24h": 1942, "median_blocks_to_graduate": 2490, "tokens_launched": 716441, "traders_24h": 56613, "trades_24h": 308146, "volume_by_quote_usd_24h": { "eth": 13534110, "other": 3243864, "stock": 3335245, "usdg": 7256660 }, "volume_usd_24h": 27369878 }, "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, { "contracts": { "launch_contracts": [ "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" ] }, "id": "flap", "name": "Flap.sh", "since_block": 4227932, "stats": { "fees_usd_24h": { "lp": 2109.79, "tax": 7746.26, "total": 9856.05 }, "graduated": 338, "graduated_24h": 1, "graduation_rate_pct": 0.0872429, "launches_24h": 1185, "median_blocks_to_graduate": 8533, "tokens_launched": 387424, "traders_24h": 3319, "trades_24h": 8398, "volume_by_quote_usd_24h": { "eth": 386000, "other": 16.2147, "stock": 5084.87, "usdg": 11596.8 }, "volume_usd_24h": 402698 }, "type": "config_driven", "website": "https://flap.sh" }, { "contracts": { "launch_contracts": [ "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" ] }, "id": "bankr", "name": "Bankr", "since_block": 1565844, "stats": { "fees_usd_24h": { "lp": 5012.97, "tax": 13421, "total": 18434 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 22, "median_blocks_to_graduate": null, "tokens_launched": 98674, "traders_24h": 1984, "trades_24h": 7322, "volume_by_quote_usd_24h": { "eth": 236909, "other": 25290, "stock": 261447, "usdg": 85062.8 }, "volume_usd_24h": 608708 }, "type": "config_driven", "website": "https://bankr.bot" }, { "contracts": { "launch_contracts": [ "0x22e99278308b393ea1260859b181ad7e78f5eeed", "0x1eef016f22a943abc7dd11422edee9d235942104" ] }, "id": "long", "name": "Long.xyz", "since_block": 8658626, "stats": { "fees_usd_24h": { "lp": 53053.8, "tax": 69117.7, "total": 122171 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 554, "median_blocks_to_graduate": null, "tokens_launched": 83736, "traders_24h": 9312, "trades_24h": 72296, "volume_by_quote_usd_24h": { "eth": 2465731, "other": 2905525, "stock": 3391108, "usdg": 2270126 }, "volume_usd_24h": 11032490 }, "type": "config_driven", "website": "https://long.xyz" }, { "contracts": { "launch_contracts": [ "0x3d6ea4e97b8ab9e1a1b4943febffe22d8c920091" ] }, "id": "standard_reserve", "name": "King of the Markets (Standard Reserve)", "since_block": 88527856, "stats": { "fees_usd_24h": { "lp": 22.016, "tax": 9.88621, "total": 31.9022 }, "graduated": 22, "graduated_24h": 0, "graduation_rate_pct": 1.00319, "launches_24h": 1, "median_blocks_to_graduate": 2835, "tokens_launched": 2193, "traders_24h": 341, "trades_24h": 1057, "volume_by_quote_usd_24h": { "eth": 0.185538, "other": 0, "stock": 145002, "usdg": 261.257 }, "volume_usd_24h": 145263 }, "type": "config_driven", "website": "https://www.standardreserve.xyz" }, { "contracts": { "launch_contracts": [ "0xf05a26e92e27b8f0385f6895f5507db26a2f4b8d" ] }, "id": "flywheel", "name": "Flywheel", "since_block": 87735869, "stats": { "fees_usd_24h": { "lp": 1084.53, "tax": 3787, "total": 4871.53 }, "graduated": 23, "graduated_24h": 0, "graduation_rate_pct": 1.69993, "launches_24h": 15, "median_blocks_to_graduate": 25108, "tokens_launched": 1353, "traders_24h": 1776, "trades_24h": 5115, "volume_by_quote_usd_24h": { "eth": 82296.3, "other": 45051.6, "stock": 111250, "usdg": 20862.4 }, "volume_usd_24h": 259460 }, "type": "config_driven", "website": "https://flywheel.cash" } ], "meta": { "block": 100454745, "block_age_ms": 1379, "block_ts": 1793229989000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 228, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100449754 } } ``` What this tells you - Six entries, each with an `id` you can pass as `launchpad=` to the token lists: `pons`, `flap`, `bankr`, `long`, `standard_reserve` and `flywheel`. - Pons: `tokens_launched: 716441`, `graduated: 10485` (`graduation_rate_pct: 1.46348`), median 2,490 blocks to graduate (about 4 minutes at 100 ms blocks) and $27,369,878 of 24-hour volume. It is the only one with `type: "bonding_curve_to_v4"`. - Flap.sh: 387,424 launches and 338 graduations (`graduation_rate_pct: 0.0872429`, median 8,533 blocks). Flywheel: 23 of 1,353 (1.69993%, median 25,108 blocks). King of the Markets: 22 of 2,193 (1.00319%, median 2,835 blocks). - Bankr (98,674 launches) and Long.xyz (83,736) show `graduated: 0` and `median_blocks_to_graduate: null`: their tokens start on a Uniswap v4 pool, so there is no curve to complete. - 24-hour volume after Pons: Long.xyz $11,032,490, Bankr $608,708, Flap.sh $402,698, Flywheel $259,460 and King of the Markets $145,263. `contracts` lists each launchpad’s launch contracts, such as the Flap Portal `0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09`. [Launchpads reference](https://docs.crius.sh/reference/launchpads/launchpads/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Six%20launchpads%3A%20716%2C441%20Pons%20launches%2C%201.46%25%20graduate&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcreate-a-token-on-robinhood-chain%2F%23launchpads%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Deploying your own ERC-20 and a Uniswap pool Robinhood Chain is EVM-compatible, so the usual tools for Ethereum (Foundry, Hardhat, OpenZeppelin contracts) work with chain ID 4663, the public RPC and ETH for gas ([network settings](https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/)). After deploying, you add liquidity on one of the Uniswap deployments: the v2 factory `0x8bceaa40b9acdfaedf85adf4ff01f5ad6517937f`, the v3 factory `0x1f7d7550b1b028f7571e69a784071f0205fd2efa` with its position manager `0x73991a25c818bf1f1128deaab1492d45638de0d3`, or the v4 PoolManager `0x8366a39cc670b4001a1121b8f6a443a643e40951` with the position manager `0x58daec3116aae6d93017baaea7749052e8a04fa7`. What a launchpad would have done for you is now up to you: verifying the source on [robin.etherscan.io](https://robin.etherscan.io), renouncing owner powers you don’t need, and locking or burning the LP so buyers know it can’t be pulled. The security score counts each of these. ## Find your new token in Crius Names aren’t unique on Robinhood Chain: the same name is often launched several times, on launchpads and directly. Search shows them all; track your token by its address. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### Five tokens called nugs: two deployed directly, three on Pons I launched a token called nugs. How do I find mine? GET/v1/robinhood/search?q=nugs&limit=5 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=nugs&limit=5" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=nugs&limit=5"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=nugs&limit=5", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 113 lines (arrays trimmed)** ```json { "data": [ { "address": "0xaf432d11318701433df9dd09a2e0193ad51c233a", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 75261.8, "logo": null, "name": "nugs", "price_usd": 0.000158889, "symbol": "NUGS", "type": "token" }, { "address": "0x303d302908d62b402ffe2dc260323922b91a4d8f", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 48146.5, "logo": null, "name": "nugs", "price_usd": 0.000109079, "symbol": "NUGS", "type": "token" }, { "address": "0x1e6016155e0e1e73c95b4080f1180e60383a9026", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://ponsfamily.com/launchpad/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302", "website": "https://ponsfamily.com/launchpad/0xed488ad4401fd576c6d07c6ac695cd36dc9aece1" }, "liquidity_usd": 15572.5, "logo": "https://api.crius.sh/v1/robinhood/logo/0x1e6016155e0e1e73c95b4080f1180e60383a9026.png?size=128", "name": "nugs", "price_usd": 0.000050631, "symbol": "NUGS", "type": "token" }, { "address": "0x090e9a5ed54dba1b64a89a5d1bcc4a637489c590", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/n1721203925204/status/2105066683727499439", "website": "https://www.ponsfamily.com/launchpad/0x6fbcd1f3738263f33a3c2a41bde0f326a7ab9a04" }, "liquidity_usd": 4375.43, "logo": "https://api.crius.sh/v1/robinhood/logo/0x090e9a5ed54dba1b64a89a5d1bcc4a637489c590.png?size=128", "name": "Nugs", "price_usd": 0.00000289847, "symbol": "NUGS", "type": "token" }, { "address": "0xd6c3936b195579dda6a1a79230c74b430425094b", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 4056.02, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd6c3936b195579dda6a1a79230c74b430425094b.png?size=128", "name": "nugs", "price_usd": 0.00000226086, "symbol": "NUGS", "type": "token" } ], "meta": { "block": 100455094, "block_age_ms": 1051, "block_ts": 1793230029000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 2, "safe_block": 100449754 } } ``` What this tells you - Five `type: "token"` results named nugs or Nugs, all with the symbol NUGS. - `0xaf432d11318701433df9dd09a2e0193ad51c233a` ($75,261.8 of liquidity) and `0x303d302908d62b402ffe2dc260323922b91a4d8f` ($48,146.5) have `launchpad: null`: they were deployed directly. - `0x1e6016155e0e1e73c95b4080f1180e60383a9026`, `0x090e9a5ed54dba1b64a89a5d1bcc4a637489c590` and `0xd6c3936b195579dda6a1a79230c74b430425094b` have `launchpad: "pons"`; the first links its Pons launch page in `links.website`. - Here the results come in order of liquidity, so a copy can sit above the original. Search by the full address to get exactly one result. [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Five%20tokens%20called%20nugs%3A%20two%20deployed%20directly%2C%20three%20on%20Pons&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcreate-a-token-on-robinhood-chain%2F%23search%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3Dnugs%26limit%3D5%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### A directly deployed token: creation, market and holders How does Crius describe nugs (0x303d302908d62b402ffe2dc260323922b91a4d8f), a token deployed without a launchpad? GET/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 267 lines (arrays trimmed)** ```json { "data": { "address": "0x303d302908d62b402ffe2dc260323922b91a4d8f", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/bundles" }, "burned": 7022901.387660785443366196, "chain_id": 4663, "circulating_supply": 992977098.612339214556633804, "creation": { "attribution": "direct", "block": 100416220, "deployed_via": "direct", "deployer": "0x5d2193ef9b3d516b89bdf069f9ece5499b749e34", "factory": null, "source": "trace", "tx": "0xf820ea30ffc8f1adfe2b3ea77cf5449087b70619d565773f2daa905d1269bf6d" }, "decimals": 18, "dexscreener": { "status": "checking" }, "first_seen_block": 100416220, "history": "complete", "holders": { "burned_pct": 0.70229, "count": 351, "dev_holding": null, "dev_pct": null, "locked_pct": 0, "top10_pct": 30.7487 }, "launch": null, "liquidity": { "see": "/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/liquidity", "status": "unlocked", "summary": { "burned_pct": 0, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100, "weighting": "by pool liquidity_usd" } }, "locked": 0, "market": { "fdv_usd": 117854, "liquidity_usd": 50975.9, "market_cap_usd": 117026, "pools_count": 2, "quote_liquidity_usd": 25488 }, "metadata": { "banner": null, "description": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "logo": null, "logo_original": null, "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "source": null, "sources": { "links": null, "logo": null } }, "name": "nugs", "price": { "ath_market_cap_usd": 140938, "ath_scope": "all_time", "ath_ts": 1793227503000, "ath_usd": 0.000141935, "change_pct": { "1h": 15.2157, "1m": -6.63126, "1s": -1.37163, "24h": 900.41, "30s": -2.64262, "4h": 900.41, "5m": -14.8189, "6h": 900.41 }, "confidence": "high", "dex": "uniswap_v4", "eth": 0.0000000499717, "liquidity_usd": 50975.5, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 25487.8, "source_pool": "0x8e4a5ebdc4219611fda1bcecac1aaaa2217d9b599334066bfc3be48e53a28357", "thin_liquidity": false, "usd": 0.000117854 }, "security": { "see": "/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 240535, "buys": 730, "first_trade_ts": 1793226060000, "sell_volume_usd": 215037, "sells": 534, "since": "chain_start", "trades": 1264, "volume_usd": 455572 }, "avg_trade_usd": { "1h": 361.338, "1m": 333.612, "1s": 224.809, "24h": 360.421, "30s": 209.637, "4h": 360.421, "5m": 367.778, "6h": 360.421 }, "buy_volume_usd": { "1h": 203927, "1m": 1163.4, "1s": 0, "24h": 240535, "30s": 598.566, "4h": 240535, "5m": 6533.4, "6h": 240535 }, "buyers": { "1h": 477, "1m": 6, "1s": 0, "24h": 555, "30s": 3, "4h": 555, "5m": 20, "6h": 555 }, "buys": { "1h": 627, "1m": 6, "1s": 0, "24h": 730, "30s": 3, "4h": 730, "5m": 24, "6h": 730 }, "last_trade_ts": 1793229996000, "sell_volume_usd": { "1h": 201134, "1m": 2506.33, "1s": 449.619, "24h": 215037, "30s": 449.619, "4h": 215037, "5m": 10016.6, "6h": 215037 }, "sellers": { "1h": 339, "1m": 5, "1s": 2, "24h": 356, "30s": 2, "4h": 356, "5m": 20, "6h": 356 }, "sells": { "1h": 494, "1m": 5, "1s": 2, "24h": 534, "30s": 2, "4h": 534, "5m": 21, "6h": 534 }, "traders": { "1h": 509, "1m": 11, "1s": 2, "24h": 555, "30s": 5, "4h": 555, "5m": 38, "6h": 555 }, "trades": { "1h": 1121, "1m": 11, "1s": 2, "24h": 1264, "30s": 5, "4h": 1264, "5m": 45, "6h": 1264 }, "txns": { "1h": 1121, "1m": 11, "1s": 2, "24h": 1264, "30s": 5, "4h": 1264, "5m": 45, "6h": 1264 }, "volume_eth": { "1h": 171.753, "1m": 1.55602, "1s": 0.190644, "24h": 193.211, "30s": 0.444444, "4h": 193.211, "5m": 7.01906, "6h": 193.211 }, "volume_usd": { "1h": 405060, "1m": 3669.74, "1s": 449.619, "24h": 455572, "30s": 1048.18, "4h": 455572, "5m": 16550, "6h": 455572 } }, "symbol": "NUGS", "total_supply": 1000000000, "type": "generic", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": false, "sourcify": "none" } }, "meta": { "block": 100454811, "block_age_ms": 912, "block_ts": 1793229996000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 67, "pending": [], "safe_block": 100449754 } } ``` What this tells you - `creation.attribution: "direct"`, `deployed_via: "direct"` and `factory: null`: the deployer `0x5d2193ef9b3d516b89bdf069f9ece5499b749e34` created it in block 100416220 (transaction `0xf820ea30ffc8f1adfe2b3ea77cf5449087b70619d565773f2daa905d1269bf6d`). A Pons token shows `attribution: "known_launchpad"` and the factory address instead. - `launch: null`: there is no curve and no graduation to follow. The token was priced on a Uniswap v4 pool from its first trade (`price.dex: "uniswap_v4"`, quote native ETH). - `market`: 2 pools, $50,975.9 of liquidity, a market cap of $117,026; `stats.all_time` counts 1,264 trades and $455,572 of volume. - `holders.count: 351`, top 10 holders 30.7487%. `liquidity.status: "unlocked"` with `unlocked_in_wallets_pct: 100`: no LP is locked or burned. - `verification.sourcify: "none"`: the source isn’t verified. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20directly%20deployed%20token%3A%20creation%2C%20market%20and%20holders&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcreate-a-token-on-robinhood-chain%2F%23direct-token%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x303d302908d62b402ffe2dc260323922b91a4d8f%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Check it like a buyer would Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Clean contract, unlocked LP: score 50 What does the security score say about the directly deployed nugs token? GET/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x303d302908d62b402ffe2dc260323922b91a4d8f/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 112 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "lp_unlocked", "unverified", "lp_single_wallet" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "lp_single_wallet" ], "lp_top_wallet": { "address": "0x5d2193ef9b3d516b89bdf069f9ece5499b749e34", "liquidity_usd": 53484.6, "pct": 100 }, "sniper_supply_pct": 0.0000399708, "sniper_top_wallet_pct": 0.0000399708, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "unlocked", "summary": { "burned_pct": 0, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 50, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793229973000, "max_sell_pct_seen": 0, "samples": { "buys": 727, "sells": 531 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100416293, "pct": 0, "side": "buy" }, { "from_block": 100417007, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x303d302908d62b402ffe2dc260323922b91a4d8f" }, "meta": { "block": 100454699, "block_age_ms": 610, "block_ts": 1793229985000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 67, "safe_block": 100449754, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 50`, `risk: "medium"`, from three flags: `lp_unlocked` (−20), `lp_single_wallet` (−25) and `unverified` (−5). - `launch.lp_top_wallet` is the deployer `0x5d2193ef9b3d516b89bdf069f9ece5499b749e34` with 100% of the liquidity ($53,484.6): one wallet could remove the pool. - The contract itself is clean: `ownership: "none"`, not mintable, no blacklist or pause, and `honeypot.is_honeypot: false`. - `tax.buy_pct` and `tax.sell_pct` are 0, measured from 727 buys and 531 sells (`source: "realized"`). `meta.simulation` says why no sell was simulated: `"no V2 WETH pair: realized tax only"`. - Compare the Pons token sockets in the [security score guide](https://docs.crius.sh/guides/token-security-score/#clean-token): score 95, with about 97% of its LP in the Pons launch locker. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Clean%20contract%2C%20unlocked%20LP%3A%20score%2050&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fcreate-a-token-on-robinhood-chain%2F%23security%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x303d302908d62b402ffe2dc260323922b91a4d8f%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Use it in your app 1. **Watch for the launch.** Poll `GET /v1/robinhood/tokens?list=new` (add `launchpad=pons` or another id to follow one launchpad), or subscribe to `launches:all` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) with a free key. 2. **Read how it was made.** `/token/{address}` gives `creation.attribution`, `deployed_via`, the factory and the deployer. For launchpad tokens, `/token/{address}/launch` (Free plan) has the curve, progress, graduation pool and LP locker; the [bonding guide](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) walks through one. 3. **Score it.** `/token/{address}/security` on the anonymous plan. The flags say what a buyer will see: unlocked LP, owner powers, taxes, snipers at launch. 4. **Follow the holders.** `holders.count` is on the profile; the full list is `/token/{address}/holders` on the Free plan ([holders guide](https://docs.crius.sh/guides/get-token-holders/)). ```js // After you create a token: how Crius sees it. const token = "0x303d302908d62b402ffe2dc260323922b91a4d8f"; const api = "https://api.crius.sh/v1/robinhood"; const { data: t } = await (await fetch(`${api}/token/${token}`)).json(); const { data: s } = await (await fetch(`${api}/token/${token}/security`)).json(); console.log(`${t.name}: created by ${t.creation.deployer} (${t.creation.attribution}, factory ${t.creation.factory ?? "none"})`); console.log(`holders ${t.holders.count}, liquidity $${t.market.liquidity_usd}, LP ${t.liquidity.status}`); console.log(`score ${s.score} (${s.risk}): ${s.flags.join(", ") || "no flags"}`); ``` Most launches never take off Fewer than 2 in 100 bonding-curve launches graduate. The best signal that a token is alive is in the list row: `traders`, `buys` and `sells` per window and `liquidity_usd`. Add `min_liquidity_usd=1000` to `list=new` to skip tokens nobody has bought. ## Frequently asked questions **Can I create a token with Crius?** No. Crius is a read-only data API: it indexes tokens after they are created and doesn't deploy contracts or send transactions. Use a launchpad's website or deploy your own contract, then look the token up with `GET /v1/robinhood/token/{address}`. **Which Robinhood Chain token creator has the most launches?** Pons, by far: 716,441 tokens launched and 1,942 in the 24 hours before the sample on this page, then Flap.sh (387,424 and 1,185), Bankr (98,674 and 22), Long.xyz (83,736 and 554), King of the Markets (2,193 and 1) and Flywheel (1,353 and 15). `GET /v1/robinhood/launchpads` returns the live numbers. **Do I need a launchpad to create a Robinhood Chain coin?** No. Robinhood Chain is EVM-compatible, so any ERC-20 contract can be deployed with chain ID 4663 and paired on Uniswap v2, v3 or v4. Crius reports such tokens with `launchpad: null` and `creation.attribution: "direct"`. The difference is what you set up yourself: a launchpad deploys the contract, runs the curve and locks or burns the liquidity; on your own, the LP stays in your wallet unless you lock or burn it. **How fast does a new token appear in Crius?** Usually a second or two after its creation block. It shows up in `list=new` (newest first), in search by name or address, and on the WebSocket stream's `launches:all` channel. Price and market cap stay `null` until the first trade. **What do launchpad graduation rates mean for a new token?** Most launchpad tokens never leave their bonding curve. In the sample on this page, 1.46348% of Pons launches had graduated, 1.69993% of Flywheel's, 1.00319% of King of the Markets' and 0.0872429% of Flap.sh's. Bankr and Long.xyz tokens have no curve, so they have nothing to graduate from. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Find new tokens** List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Read](https://docs.crius.sh/guides/find-new-tokens/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) --- # Detect bundled launches, snipers and insiders > Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Source: https://docs.crius.sh/guides/detect-bundles-and-snipers/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/bundles` (Starter plan, 10 credits). It analyses the first 300 blocks of trading: `snipers` (wallets that bought in the first 10 blocks, their `supply_pct` and `still_holding_pct`), `bundles` (launch-transaction buys, multi-recipient transactions, same-block buys from one funder), funding `clusters`, the developer's buys and `insider_launch`. Without a key, `/security` returns the `launch` summary: `sniper_supply_pct`, `sniper_top_wallet_pct` and flags. [GET `/token/{address}/bundles`](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) Snipers are wallets that buy a token in its first seconds of trading, before most people can see it. Bundles are coordinated buys that spread one buyer’s purchase over several wallets. When insiders take most of the supply this way, the token can have a clean contract and locked liquidity and still be a pump and dump: they sell into everyone who buys after them. Crius analyses the first 300 blocks of every Robinhood Chain token’s trading to show who bought, how they were funded, and whether they still hold. ## See who bought the launch Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) ### An insider launch: Rebot (61% sniped, all of it sold) Rebot (0x192b126efea71ca5e7767bc6fc53038d869fbbba) fell 97% within hours of launching. Who bought it first? GET/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 99 lines (arrays trimmed)** ```json { "data": { "bundle_supply_pct": 1, "bundle_supply_pct_now": 0, "bundled": true, "bundles": [ { "block": 100238938, "bought": 10000000.000000000905969664, "cost_eth": 0.0174316, "funder": null, "id": "b_1", "still_holding_pct": 0, "supply_pct": 1, "type": "launch_tx_buy", "wallets": [ "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864" ] } ], "clusters": [], "dev": { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "bought_in_launch_tx": true, "first_buy_pct": 1, "funded_by": null, "holding_pct": 0 }, "early_buyers_analyzed": 54, "insider_launch": true, "launch": { "flags": [ "insider_launch" ], "lp_top_wallet": { "address": "0x6e8244ba97cbb7d136aafc667e8da302140dbc5b", "liquidity_usd": 5.70259, "pct": 0.0996139 }, "sniper_supply_pct": 60.9726, "sniper_top_wallet_pct": 53.1794, "sniper_wallets": 4, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "snipers": { "count": 4, "still_holding_pct": 0, "supply_pct": 60.9726, "wallets": [ { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "tags": [ "dev", "sniper" ] }, { "address": "0x0f0bb85fddc70f04344bc7704bb940e387ae7762", "tags": [ "sniper" ] }, { "address": "0x5051e45b2dbecf1b2041af3937bd85fc0dc43cd4", "tags": [ "sniper" ] }, { "address": "0x217be8970fa83b0864ca06d3c18ea6d9ac04e3a5", "tags": [ "sniper" ] } ], "window_blocks": 10 }, "trader_funding": { "bridge": 18, "dev_linked": 1, "other_wallets": 21, "protocol": 3, "unknown": 6, "unlabeled_hub": 5 } }, "meta": { "block": 100406882, "block_age_ms": 1103, "block_ts": 1793225086000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 134, "safe_block": 100401329, "scope": "first 300 blocks of trading" } } ``` What this tells you - `insider_launch: true`. `snipers.count: 4` wallets bought `snipers.supply_pct: 60.9726` of the supply in the first 10 blocks (`window_blocks: 10`), and `launch.sniper_top_wallet_pct: 53.1794` shows one of them took more than half on its own. - `snipers.still_holding_pct: 0`: every sniper has sold everything. That is the dump. - The developer `0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864` is one of the snipers (`tags: ["dev", "sniper"]`). `dev.bought_in_launch_tx: true`, `first_buy_pct: 1`, `holding_pct: 0`. - `bundles` has one entry, `type: "launch_tx_buy"`: the developer’s buy of 10,000,000 tokens (1% of supply) for 0.0174316 ETH inside the launch transaction, at block 100238938. `still_holding_pct: 0`. - `bundle_supply_pct: 1` and `bundle_supply_pct_now: 0`: bundles were a small part of this launch. The insiders bought as separate wallets in the first blocks instead. - `clusters: []`: no early buyers share a funder that links them. `trader_funding` shows the 54 analysed buyers (`early_buyers_analyzed`) were funded through bridges (18), other wallets (21), protocols (3), hub funders (5), the developer (1) or unknown sources (6). [Snipers, bundles & clusters reference](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20An%20insider%20launch%3A%20Rebot%20\(61%25%20sniped%2C%20all%20of%20it%20sold\)&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fdetect-bundles-and-snipers%2F%23insider-launch%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x192b126efea71ca5e7767bc6fc53038d869fbbba%2Fbundles%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A busy launch that isn't an insider launch: sockets sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a) had snipers too. Is that a problem? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 187 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x34062c5519d27d399b1deb897b6c769683ec7fa3", "liquidity_usd": 106.386, "pct": 0.549474 }, "sniper_supply_pct": 30.1177, "sniper_top_wallet_pct": 24.0035, "sniper_wallets": 6, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 98.9946, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 1.00542, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 95, "tax": { "buy_pct": 2.69, "confidence": "high", "realized": { "buy_pct": 2.69, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793225076000, "max_sell_pct_seen": 65.93, "samples": { "buys": 4144, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100193859, "pct": 0, "side": "buy" }, { "from_block": 100193869, "pct": 0, "side": "sell" }, { "from_block": 100213206, "pct": 3, "side": "buy" }, { "from_block": 100342818, "pct": 0, "side": "buy" }, { "from_block": 100344806, "pct": 3, "side": "buy" } ], "tax_history_total": 7, "tax_mode": "dynamic", "token": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "meta": { "block": 100406831, "block_age_ms": 624, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 32, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `launch.sniper_wallets: 6` bought `launch.sniper_supply_pct: 30.1177` in the first 10 blocks; the largest took `sniper_top_wallet_pct: 24.0035`. - That is under both thresholds (50% for one wallet, 80% for all snipers), so `launch.flags` is empty and the token keeps `score: 95`. - `launch.lp_top_wallet` shows the largest unlocked liquidity holder has 0.55% of the liquidity, and `uniform_holders` and `wallet_farm` are `null`: no other insider pattern either. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20busy%20launch%20that%20isn't%20an%20insider%20launch%3A%20sockets&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fdetect-bundles-and-snipers%2F%23sniped-not-insider%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `insider_launch` | `true` when the launch is flagged `insider_launch`, `wallet_farm` or `uniform_holders` (see `launch.flags`). | | `snipers` | `count`, `supply_pct` bought, `still_holding_pct` now, `window_blocks`, and `wallets` with their `tags` (`dev`, `sniper`, …). | | `bundles[]` | `id`, `type` (`launch_tx_buy`, `multi_recipient_tx`, `same_block_shared_funder`), `block`, `wallets`, `funder`, `bought`, `supply_pct`, `cost_eth`, `still_holding_pct`. | | `bundled`, `bundle_supply_pct`, `bundle_supply_pct_now` | Whether any bundle was found, and the share of supply bundled wallets bought and still hold. | | `clusters[]` | Early buyers linked by a shared funder, funding between them or token transfers between them. | | `dev` | The developer's `address`, `bought_in_launch_tx`, `first_buy_pct`, `holding_pct` and `funded_by`. | | `trader_funding` | How the early buyers got their first ETH, by funder type (bridge, protocol, the developer, hub funders, other wallets, unknown). | | `launch` | The same launch summary as `/security`: `sniper_supply_pct`, `sniper_top_wallet_pct`, `sniper_wallets`, `wallet_farm`, `uniform_holders`, `lp_top_wallet`, `flags`. | What each insider pattern means and the exact thresholds are in [Launch risk](https://docs.crius.sh/concepts/launch-risk/). ## Use it in your app 1. **Screen every token with `/security`.** `launch.flags` and `flags` include `insider_launch`, `wallet_farm` and `uniform_holders`, each of which makes the token `high` risk or costs points. No key needed. 2. **Call `/bundles` for the tokens you show in detail.** It costs 10 credits on the Starter plan, so fetch it when a user opens a token, not for every new launch. 3. **Show who still holds.** `snipers.still_holding_pct` and `bundle_supply_pct_now` matter more than what was bought: supply that’s already sold can’t be dumped again. 4. **Follow the developer.** If `dev.holding_pct` is high, or the developer is a sniper, check their past launches with [`/dev/{address}`](https://docs.crius.sh/guides/check-developer-history/). ```js // Summarize a token's launch for a token page. const token = "0x192b126efea71ca5e7767bc6fc53038d869fbbba"; // Rebot const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/bundles`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); const { snipers, dev } = data; console.log(`${snipers.count} snipers bought ${snipers.supply_pct}%, still hold ${snipers.still_holding_pct}%`); console.log(`${data.bundles.length} bundles, ${data.bundle_supply_pct_now}% of supply still in them`); if (dev) console.log(`developer holds ${dev.holding_pct}%${snipers.wallets.some((w) => w.tags?.includes("dev")) ? " and sniped" : ""}`); if (data.insider_launch) console.warn("insider launch:", data.launch.flags.join(", ")); ``` Tokens indexed after launch Snipers are measured from the token’s first trades. For a token whose launch happened before Crius saw its history, `launch.sniper_supply_pct` is `null` and no sniper flag is set. `/bundles` always covers the first 300 blocks of trading Crius has (`meta.scope`). ## Frequently asked questions **How do I detect snipers on a Robinhood Chain token?** Call `/v1/robinhood/token/{address}/bundles` with a Starter key. `snipers.wallets` lists every wallet that bought in the first `window_blocks` blocks of trading (10 by default), `snipers.supply_pct` how much they bought and `snipers.still_holding_pct` how much they hold now. For a quick check without a key, `/security` returns `launch.sniper_supply_pct` and `launch.sniper_top_wallet_pct`. **What's the difference between a sniper and a bundle?** A sniper is any wallet that bought in the first blocks of trading, often a bot. A bundle is a set of buys that were coordinated: one transaction buying for several wallets, a buy inside the launch transaction itself, or two or more wallets buying in the same block with ETH from the same funder. Bundles hide one buyer behind many wallets. **Is every heavily sniped launch an insider launch?** No. Crius flags `insider_launch` when one sniping wallet bought 50% or more of the supply, or all snipers together 80% or more. Six wallets sniping 30% of sockets (score 95) is a busy launch, not an insider one; four wallets taking 61% of Rebot, one of them 53%, is. **Can I change the sniper window?** Yes: `window_blocks` sets it for `/bundles` (default 10, up to 1,000). The `launch` summary and the `insider_launch` flag always use 10 blocks, so they stay comparable across tokens. **Why are some early buyers not linked even though they were funded by the same address?** Exchanges, bridges, app relayers and other funders that pay hundreds of wallets never link wallets, or every exchange user would be one cluster. Funding is counted only from sends of at least 0.00001 ETH, and links between lookalike addresses (address poisoning) are dropped. `trader_funding` shows how the early buyers were funded. ## Related [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Developer history** Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling. Read](https://docs.crius.sh/guides/check-developer-history/) [Guide **Connected wallets** Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Read](https://docs.crius.sh/guides/find-connected-wallets/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Snipers, bundles & clusters API** Snipers (bought within the first blocks after trading opened), bundles, funding clusters and the share of supply they hold. Read](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) --- # How to detect a honeypot token on Robinhood Chain > Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Source: https://docs.crius.sh/guides/detect-honeypot/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/security` and read `honeypot.is_honeypot`. It is `true` when a simulated sell at the latest block fails (`honeypot.reason: "simulated sell failed"`, with the revert in `tax.simulated.revert_reason`), or when 20+ buys have no sells at all; `honeypot.selective` is `true` when only the developer has sold. A honeypot always gets `risk: "critical"`. No API key needed. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) A honeypot is a token you can buy but can’t sell: the price chart looks healthy because every trade is a buy, and the money stays in the pool. Crius checks this two ways for every Robinhood Chain token. It simulates a real buy, transfer and sell at the latest block, and it looks at who has actually managed to sell. If either test fails, `honeypot.is_honeypot` is `true` and the token’s risk is `critical`, whatever else it has going for it. A pass is not a guarantee The sell simulation only runs for tokens with a Uniswap v2 WETH pair, from a fresh wallet at the current block. Traps that whitelist new wallets, switch on after launch or block only some wallets can pass, and a brand-new token needs 20+ buys before the realized rule can flag it. See [Security score: confidence and limitations](https://docs.crius.sh/concepts/security-score-limits/). ## Check if a token can be sold Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Crius flags Let's End AI (ENDAI) as a honeypot Let's End AI (0xc882f10529a5518ee3393af5a80e9ff00d38d44b) has burned liquidity and a renounced owner. Can I sell it? GET/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 140 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x0000000000000000000000000000000000000000", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": true, "upgradeable": false, "verified": "none" }, "flags": [ "honeypot", "unverified", "uniform_holders" ], "honeypot": { "is_honeypot": true, "reason": "simulated sell failed", "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "uniform_holders" ], "lp_top_wallet": { "address": "0xabe3a51937eb4c76ab6449e9823dbffd4409776f", "liquidity_usd": 8.58651, "pct": 0.0253312 }, "sniper_supply_pct": 0.000299049, "sniper_top_wallet_pct": 0.000299049, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": { "balance_pct": 0.112731, "holders": 51, "of_top": 100 }, "wallet_farm": null }, "limits": { "max_tx": "1000000000", "max_tx_getter": "maxTxAmount()", "max_tx_pct": 100, "max_wallet": "1000000000", "max_wallet_getter": "maxWalletSize()", "max_wallet_pct": 100 }, "liquidity": { "status": "burned", "summary": { "burned_pct": 99.9715, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0284848, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v2", "risk": "critical", "score": 0, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793224820000, "max_sell_pct_seen": 0, "samples": { "buys": 27197, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": { "amount_eth": 0.042454083286938696, "buy_gas": 159144, "buy_pct": 0, "can_buy": true, "can_sell": false, "can_transfer": true, "from": "eoa", "revert_reason": { "code": 3, "data": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000245472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c454400000000000000000000000000000000000000000000000000000000", "message": "execution reverted: TransferHelper: TRANSFER_FROM_FAILED" }, "router": "0x89e5db8b5aa49aa85ac63f691524311aeb649eba", "sell_gas": 229228, "sell_pct": null, "transfer_pct": 0 }, "source": "realized", "transfer_pct": 0 }, "tax_history": [ { "from_block": 62239227, "pct": 0, "side": "buy" }, { "from_block": 62240181, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b" }, "meta": { "block": 100406838, "block_age_ms": 1257, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 14, "safe_block": 100401329, "simulation": "eth_simulateV1 via Uniswap V2 router at head" } } ``` What this tells you - `honeypot.is_honeypot: true`, `reason: "simulated sell failed"`, `score: 0`, `risk: "critical"`. - The evidence is in `tax.simulated`: `can_buy: true` and `can_transfer: true`, but `can_sell: false`. Buying about 0.042 ETH worth (`amount_eth`) and sending tokens to another wallet work; selling them back reverts with `"execution reverted: TransferHelper: TRANSFER_FROM_FAILED"`. The router couldn’t move the tokens from the seller into the pool: the token’s `transferFrom` failed. - `meta.simulation: "eth_simulateV1 via Uniswap V2 router at head"`: the test ran against the live chain state through the Uniswap v2 router `0x89e5db8b5aa49aa85ac63f691524311aeb649eba`. - What looks safe doesn’t help: `contract.ownership: "renounced"` (owner `0x0000000000000000000000000000000000000000`), `liquidity.status: "burned"` (99.97%) and a 0% buy tax. - `contract.trading_switch: true`: the code includes a trading switch (a function such as `openTrading()`), common in contracts that control who can trade. - `launch.uniform_holders`: 51 of the top 100 holders hold nearly the same amount (about 0.113% of supply each), which costs another 30 points. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Crius%20flags%20Let's%20End%20AI%20\(ENDAI\)%20as%20a%20honeypot&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fdetect-honeypot%2F%23honeypot%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xc882f10529a5518ee3393af5a80e9ff00d38d44b%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### The market agrees: 150 buyers and no sellers in 24 hours What do Let's End AI's (0xc882f10529a5518ee3393af5a80e9ff00d38d44b) recent trades look like? GET/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 303 lines (arrays trimmed)** ```json { "data": { "address": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/bundles" }, "burned": 0, "chain_id": 4663, "circulating_supply": 1000000000, "creation": { "attribution": "direct", "block": 62239223, "deployed_via": "direct", "deployer": "0xb9707a550b874137da35bbcbbb0f6992a8f5e84b", "factory": null, "source": "trace", "tx": "0xc3e87157315181f6982525fa677d217f1b6a0b863eafd19c358f2946312b3f2f" }, "decimals": 9, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 1, "last_ts": 1789335376746, "total_amount": 100 }, "checked_ts": 1793040466789, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1789332236212, "orders": [ { "payment_ts": 1789332236212, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": null, "header": "https://cdn.dexscreener.com/cms/images/gvWC0hpE9DWAKeSG?width=1500&height=500&quality=95&format=auto", "icon": "https://cdn.dexscreener.com/cms/images/BunNPZVadA3UN23s?width=800&height=800&quality=95&format=auto", "links": [ { "label": "Website", "type": "website", "url": "https://www.letsendai.fun" }, { "type": "twitter", "url": "https://x.com/letsendaix" } ] }, "url": "https://dexscreener.com/robinhood/0xc882f10529a5518ee3393af5a80e9ff00d38d44b" }, "first_seen_block": 62239223, "history": "complete", "holders": { "burned_pct": 0, "count": 12467, "dev_holding": null, "dev_pct": null, "locked_pct": 0, "top10_pct": 65.7728 }, "launch": null, "liquidity": { "see": "/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/liquidity", "status": "burned", "summary": { "burned_pct": 99.9715, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0284847, "weighting": "by pool liquidity_usd" } }, "locked": 0, "market": { "fdv_usd": 890863960, "liquidity_usd": 33898.9, "market_cap_usd": 890863960, "pools_count": 45, "quote_liquidity_usd": 16949.4 }, "metadata": { "banner": "https://cdn.dexscreener.com/cms/images/gvWC0hpE9DWAKeSG?width=1500&height=500&quality=95&format=auto", "description": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/letsendaix", "website": "https://www.letsendai.fun" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc882f10529a5518ee3393af5a80e9ff00d38d44b.png?size=128", "logo_original": "https://cdn.dexscreener.com/cms/images/BunNPZVadA3UN23s?width=800&height=800&quality=95&format=auto", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "source": null, "sources": { "links": "dexscreener", "logo": "dexscreener" } }, "name": "Let's End AI", "price": { "ath_market_cap_usd": 890863960, "ath_scope": "all_time", "ath_ts": 1793225323000, "ath_usd": 0.890864, "change_pct": { "1h": -0.371574, "1m": -0.595507, "1s": -0.595507, "24h": 2.18224, "30s": -0.595507, "4h": 1.26767, "5m": -0.595507, "6h": 2.21205 }, "confidence": "high", "dex": "uniswap_v2", "eth": 0.000378207, "liquidity_usd": 33887.4, "quote": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "quote_liquidity_usd": 16943.7, "source_pool": "0x3d3d2ef643dfe12a0a15c51b34284025f048d7f0", "thin_liquidity": false, "usd": 0.890864 }, "security": { "see": "/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 4893579, "buys": 27252, "first_trade_ts": 1789331187000, "sell_volume_usd": 4876381, "sells": 3503, "since": "chain_start", "trades": 30755, "volume_usd": 9769960 }, "avg_trade_usd": { "1h": 0.694851, "1m": null, "1s": null, "24h": 0.964906, "30s": null, "4h": 0.902284, "5m": null, "6h": 0.942947 }, "buy_volume_usd": { "1h": 12.5073, "1m": 0, "1s": 0, "24h": 181.402, "30s": 0, "4h": 97.4467, "5m": 0, "6h": 120.697 }, "buyers": { "1h": 18, "1m": 0, "1s": 0, "24h": 150, "30s": 0, "4h": 86, "5m": 0, "6h": 100 }, "buys": { "1h": 18, "1m": 0, "1s": 0, "24h": 188, "30s": 0, "4h": 108, "5m": 0, "6h": 128 }, "last_trade_ts": 1793224820000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 18, "1m": 0, "1s": 0, "24h": 150, "30s": 0, "4h": 86, "5m": 0, "6h": 100 }, "trades": { "1h": 18, "1m": 0, "1s": 0, "24h": 188, "30s": 0, "4h": 108, "5m": 0, "6h": 128 }, "txns": { "1h": 18, "1m": 0, "1s": 0, "24h": 188, "30s": 0, "4h": 108, "5m": 0, "6h": 128 }, "volume_eth": { "1h": 0.00530164, "1m": 0, "1s": 0, "24h": 0.0772172, "30s": 0, "4h": 0.0413886, "5m": 0, "6h": 0.0513545 }, "volume_usd": { "1h": 12.5073, "1m": 0, "1s": 0, "24h": 181.402, "30s": 0, "4h": 97.4467, "5m": 0, "6h": 120.697 } }, "symbol": "ENDAI", "total_supply": 1000000000, "type": "generic", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": false, "sourcify": "none" } }, "meta": { "block": 100409183, "block_age_ms": 985, "block_ts": 1793225323000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 78, "pending": [], "safe_block": 100405028 } } ``` What this tells you - `stats.buyers["24h"]: 150` and `stats.buys["24h"]: 188`, against `stats.sellers["24h"]: 0` and `stats.sells["24h"]: 0`. Nobody has sold in a day of steady buying. - `stats.all_time` counts 3,503 sells against 27,252 buys, so selling worked at some point. A sell that worked last month is no proof it works today, which is why the simulation runs at the latest block. - `market.market_cap_usd` is about $890.9 million on `market.liquidity_usd` of about $33,899. A price that only goes up because no one can sell produces numbers like these. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20market%20agrees%3A%20150%20buyers%20and%20no%20sellers%20in%2024%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fdetect-honeypot%2F%23honeypot-trades%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xc882f10529a5518ee3393af5a80e9ff00d38d44b%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How the verdict is decided | Test | Honeypot when | Where to look | | --- | --- | --- | | Sell simulation | A simulated buy works but the sell reverts or returns no ETH. Runs only when the token has a Uniswap v2 WETH pair. | `tax.simulated.can_sell`, `revert_reason`, `meta.simulation` | | Real trades | 20+ buys and no sells at all. | `tax.realized.samples`, `honeypot.reason` | | Selective sells | 20+ buys and only the developer has sold (`selective_honeypot`, −60 points). | `honeypot.selective`, `tax.realized.by_wallet_class.dev_sell_pct` | | The pool's v4 hook | The hook has no code, is a delegated wallet, or many of its own or its code family's pools had 10+ buys and no sells (`hook_critical_risk`, −60 points). | `hook.risk_level`, `hook.flags` | A failed simulation or a market with no sellers sets `honeypot.is_honeypot` and takes the full 100 points. The hook test doesn’t set `is_honeypot` itself, but a critical hook makes the token `risk: "high"`. See [Check the risk of a Uniswap v4 hook](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). The simulation uses a $100 trade by default; pass `amount_usd` to test the size you plan to trade, since some contracts cap how much one transaction can move (see `limits`). Results are cached briefly; `fresh=1` forces a new simulation (Starter plan, 20 credits). ## Use it in your app 1. **Check before the first buy.** Call `/security` for every token a user or bot is about to buy. It’s on the anonymous plan, 1 credit with a key. 2. **Block on `honeypot.is_honeypot` or `honeypot.selective`.** Don’t rely on `risk` alone for this: a honeypot is always `critical`, but you want to say why. 3. **Show the evidence.** Quote `honeypot.reason` and, when present, `tax.simulated.revert_reason.message`, so users see it’s a measured result. 4. **Re-check before selling large amounts.** A token can turn into a honeypot after launch (`contract.trading_switch`, `contract.blacklist`). Re-run the check, with `amount_usd` set to the sell size. ```python # Refuse to buy tokens that can't be sold. import requests token = "0xc882f10529a5518ee3393af5a80e9ff00d38d44b" # Let's End AI data = requests.get(f"https://api.crius.sh/v1/robinhood/token/{token}/security").json()["data"] hp = data["honeypot"] if hp["is_honeypot"] or hp["selective"]: revert = (data["tax"]["simulated"] or {}).get("revert_reason") why = revert.get("message") if isinstance(revert, dict) else revert raise SystemExit(f"honeypot: {why or hp['reason'] or 'only the developer has sold'}") print("no honeypot found:", data["meta"]["simulation"]) ``` No sells yet is not the same as a honeypot A token minutes old may have a few buys and no sells simply because nobody has sold yet. The real-trade test waits for 20 buys, and `tax.confidence` stays `low` or `medium` until there are 20 measured trades. For brand-new tokens, rely on the simulation and the hook check, and look again a few minutes later. ## Frequently asked questions **How do I check if a Robinhood Chain token is a honeypot?** Call `GET https://api.crius.sh/v1/robinhood/token/{address}/security` (no key needed). If `honeypot.is_honeypot` is `true`, don't buy: `honeypot.reason` says whether the simulated sell failed or real buyers haven't been able to sell. `honeypot.selective: true` means only the developer has sold. **Can a token with burned liquidity and a renounced contract be a honeypot?** Yes. Let's End AI (`0xc882f10529a5518ee3393af5a80e9ff00d38d44b`) has 99.97% of its liquidity burned and its owner set to the zero address, and Crius still flags it as a honeypot because the simulated sell reverts. Burned liquidity means the pool can't be pulled; it says nothing about whether the token lets you sell into it. **What is a selective honeypot?** A token where the developer has sold but no one else has, across 20+ buys. Crius reports it as `honeypot.selective: true` with the `selective_honeypot` flag (−60 points). It usually means a whitelist: the contract lets chosen wallets sell and blocks the rest. **Why does the response say 'no V2 WETH pair, realized tax only'?** The sell simulation runs through the Uniswap v2 router, so it needs a v2 pair with WETH. Tokens that only trade on Uniswap v4 (most graduated launchpad tokens) are judged from real trades instead: 20+ buys and no sells is a honeypot, and sells by the developer only is a selective honeypot. Their pool's hook is checked too: hooks whose pools trap buyers are flagged `honeypot_observed`. **I think a token is wrongly flagged. What can I do?** Look at the evidence first: `honeypot.reason`, `tax.simulated.revert_reason` and `tax.realized.samples`. With a key on the Starter plan or higher, `?fresh=1` re-runs the simulation now (20 credits). If the verdict still looks wrong, email [support@crius.sh](mailto:support@crius.sh) with the token address. ## Related [Concept **Score confidence & limits** What the Crius security score can and can't see on Robinhood Chain, how to read its confidence fields, and why a low-risk result is not a guarantee a token is safe. Read](https://docs.crius.sh/concepts/security-score-limits/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Concept **Token taxes** How Crius measures buy, sell and transfer taxes on Robinhood Chain tokens from real trades and from a simulated buy and sell, how the two are combined, and how tax changes are tracked. Read](https://docs.crius.sh/concepts/taxes/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Safety checks for bots** Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts. Read](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/) [API reference **Security checks API** Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. Read](https://docs.crius.sh/reference/security/security-checks/) --- # Find wallets connected by funding > Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Source: https://docs.crius.sh/guides/find-connected-wallets/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/wallet/{address}/connections` (Starter plan, 10 credits). It returns `funded_by` and `funded` (ETH funding in and out, with `eth`, `txs`, `first_block`, `label`, `is_dev`), `transfers` (token transfers with other wallets), `shared_funder_with` (wallets with the same funder), `linked_devs` and a `cluster`. [GET `/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/) [GET `/token/{address}/bubblemap`](https://docs.crius.sh/reference/wallet-graph/bubble-map/) [GET `/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/) Wallets are connected when money or tokens moved between them: one funded the other with ETH, they sent each other tokens, or the same wallet funded both. On Robinhood Chain, as on any chain, one person can run many wallets, and funding is the trail they leave. Crius builds that graph from every ETH transfer (including internal transfers inside contract calls) and every token transfer, and leaves out exchanges, bridges, pools and other infrastructure that would link strangers. ## Get a wallet’s connections Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallets/wallet-connections/) ### CHARGE's creator: funded by a bridge, linked to no other dev Who funded the wallet that launched Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca), and is it linked to other wallets or devs? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 82 lines (arrays trimmed)** ```json { "data": { "cluster": { "funder": "0xd782268f600403843484b70710daee6846fc0db8", "id": "f_359981", "wallets": 1 }, "funded": [ { "address": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "eth": 0.0005, "first_block": 88385886, "is_dev": false, "label": "pons_v2_launch_factory", "txs": 1 }, { "address": "0xbcb09304eb37d79aada84e23710158e48fb15a3d", "eth": 0.11, "first_block": 89257687, "is_dev": false, "label": null, "txs": 2 }, { "address": "0x0cfbf98d825035fc049d9914b644d7887de27d6c", "eth": 0.01, "first_block": 90076749, "is_dev": false, "label": null, "txs": 1 } ], "funded_by": [ { "address": "0xd782268f600403843484b70710daee6846fc0db8", "eth": 0.008148386337868892, "first_block": 87601233, "is_dev": false, "label": "bridge:Relay solver", "txs": 1 } ], "linked_devs": [], "note": "ETH funding = top-level ETH transfers + internal (contract) transfers from call traces; swap / launchpad payouts are not funding", "scope": "all_history", "shared_funder_with": [], "transfers": [ { "address": "0xfbb464318e8c283a2bf186b6bd6420143338e1c8", "count": 2, "direction": "in", "is_dev": false, "tokens": 2 }, { "address": "0xbfd9bf98dc34cf4696ee73c781c3039a14ce5915", "count": 2, "direction": "out", "is_dev": false, "tokens": 2 }, { "address": "0x0cfbe3b71266a6ec456c0faaf9805730c6a67d6c", "count": 1, "direction": "out", "is_dev": false, "tokens": 1 } ], "wallet": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" }, "meta": { "block": 100406869, "block_age_ms": 932, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 88, "safe_block": 100401329 } } ``` What this tells you - `funded_by` has one entry: `0xd782268f600403843484b70710daee6846fc0db8`, labeled `bridge:Relay solver`, which sent 0.008148386337868892 ETH in block 87601233. The wallet’s first ETH came over a bridge. - `cluster.funder` is that solver and `cluster.wallets: 1`, with `shared_funder_with: []`: a bridge funds thousands of people, so it links this wallet to no one. - `funded` starts with `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e`, labeled `pons_v2_launch_factory`: 0.0005 ETH in block 88385886, the block CHARGE was created in. That’s the launch itself. - The wallet also funded `0xbcb09304eb37d79aada84e23710158e48fb15a3d` (0.11 ETH over 2 transactions) and `0x0cfbf98d825035fc049d9914b644d7887de27d6c` (0.01 ETH). All have `is_dev: false`, and `linked_devs` is empty: none of its connections launched a token. - Look at `transfers`: `0x0cfbe3b71266a6ec456c0faaf9805730c6a67d6c` (one token transfer, `direction: "out"`) has the same first four and last four characters as `0x0cfbf98d825035fc049d9914b644d7887de27d6c`, which the wallet really funded. That’s the pattern of address poisoning: a lookalike address planted in a wallet’s history so the owner copies it by mistake. Compare full addresses. - `scope: "all_history"`: for a wallet, the whole history is searched. [Wallet connections reference](https://docs.crius.sh/reference/wallets/wallet-connections/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20creator%3A%20funded%20by%20a%20bridge%2C%20linked%20to%20no%20other%20dev&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-connected-wallets%2F%23creator-connections%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%2Fconnections%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `funded_by[]` | Wallets that sent this one ETH, earliest first: `address`, total `eth`, `txs`, `first_block`, `label`, `is_dev`. | | `funded[]` | Wallets this one sent ETH to, same fields. | | `transfers[]` | Wallets it exchanged tokens with: `direction` (`in`, `out` or `both`), `count` (transfers), `tokens` (distinct tokens), `is_dev`. | | `shared_funder_with[]` | Other wallets funded by this wallet's funders. Funders that paid more than 500 wallets (exchanges, bridges, faucets) are skipped. | | `linked_devs[]` | Token creators among its funders, funded wallets and transfer counterparties. | | `cluster` | The group formed around its first funder: `id`, `funder`, `wallets` (this wallet plus the others that funder paid). | | `is_dev` | `true` when that address created a launchpad token. | | `label` | Known name of the address: an exchange, a bridge, a launchpad contract. | | `scope` | `all_history` for wallets; busy contracts are searched over the last 30 days. | | `note` | What counts as funding: top-level and internal ETH transfers; swap and launchpad payouts don't count. | `limit` sets how many entries each list returns (default 25, up to 200). ## Reading the graph - **Alt wallets.** A wallet funded by another non-exchange wallet shortly before it bought a token is the strongest link. Check `funded_by` first. - **Sybils and farms.** Many buyers of a token in each other’s `shared_funder_with` usually means one operator. For a whole token at once, the [bubble map](https://docs.crius.sh/guides/read-a-bubble-map/) draws these links between its top holders. - **Dev links.** Any address in `linked_devs` launched a token. A buyer funded by the dev is tagged `dev_linked` on token endpoints ([wallet tags](https://docs.crius.sh/concepts/attribution/#wallet-tags)); see [launch risk](https://docs.crius.sh/concepts/launch-risk/). - **Lookalikes.** Transfers with an address that mimics one the wallet really uses are poisoning attempts, not real links. ## Use it in your app 1. **Get a Starter key.** `/connections` needs the Starter plan and costs 10 credits per call. 2. **Start from a wallet that matters**: a token’s dev, a top holder, a copy-trading candidate. Call `/connections` and flag any `linked_devs` or non-exchange `funded_by`. 3. **Follow one hop at a time.** Call `/connections` on the funder or on wallets in `shared_funder_with` to grow the cluster. Stop at labeled addresses (exchanges, bridges, launchpads): they connect everyone. 4. **Cache by wallet.** Funding history only grows; refresh a wallet’s connections when it becomes relevant again, not on every page view. ```js // Flag a wallet that is linked to a token creator or funded by a non-labeled wallet. const wallet = "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca"; const res = await fetch(`https://api.crius.sh/v1/robinhood/wallet/${wallet}/connections`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); const privateFunders = data.funded_by.filter((f) => f.label === null); if (data.linked_devs.length) console.warn("linked to token creators:", data.linked_devs); if (privateFunders.length) console.warn("funded by wallets:", privateFunders.map((f) => `${f.address} (${f.eth} ETH)`)); console.log(`${data.shared_funder_with.length} wallets share a funder; cluster ${data.cluster?.id} has ${data.cluster?.wallets}`); ``` ## Frequently asked questions **How do I find wallets connected to a wallet on Robinhood Chain?** Call `/v1/robinhood/wallet/{address}/connections`. `funded_by` lists who sent it ETH, `funded` who it sent ETH to, `transfers` the wallets it exchanged tokens with, and `shared_funder_with` the other wallets its funders paid. Any of those that created a launchpad token also appears in `linked_devs`. **Why doesn't an exchange or a bridge link my wallet to others?** An exchange hot wallet or a bridge solver funds thousands of unrelated people. Funders that paid more than 500 wallets are skipped when looking for wallets that share a funder, so a withdrawal from an exchange or a Relay bridge payout never makes two strangers look related. **Does buying a token from a pool count as a connection?** No. Token transfers with pools, routers, lockers, launchpads and other known contracts are trading, not links between wallets, and are left out of `transfers`. ETH received from swaps or launchpad payouts isn't counted as funding either (`note` in the response says so). **How do I find a developer's other wallets?** Call `/connections` on the dev wallet and read `linked_devs`, `funded` and `shared_funder_with`: a dev who funds a fresh wallet for each launch shows up there. Then check each address with [`/dev/{address}`](https://docs.crius.sh/guides/check-developer-history/) for its own launches. **Which plan does wallet connections need?** The Starter plan or higher, 10 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Developer history** Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling. Read](https://docs.crius.sh/guides/check-developer-history/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [API reference **Wallet connections API** Wallets connected to this one through funding and transfers: who funded it, who it funded, and wallets sharing a funder. Read](https://docs.crius.sh/reference/wallets/wallet-connections/) --- # Find holders who held through a run (holder cohorts) > Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example. Source: https://docs.crius.sh/guides/find-diamond-hand-holders/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/holders/cohort?from=…&to=…` (Starter plan, 10 credits). Set a size threshold (`min_usd`, `min_balance` or `min_pct`), `continuous=true` to require holding for the whole window and `reset_on` to choose what breaks it. Each wallet comes back with `hold_time_s`, `entry_mcap_usd`, `sells_in_window`, `resets` and `pnl_usd`. [GET `/token/{address}/holders/cohort`](https://docs.crius.sh/reference/holders/holder-cohort/) [GET `/token/{address}/holders/snapshot`](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET `/token/{address}/traders`](https://docs.crius.sh/reference/holders/top-traders/) A holder cohort is the set of wallets that held a token through a window, for example from the moment the market cap crossed $50k until now. Crius replays every balance change in the window and, for each wallet, tells you when it started holding, how long it held, the market cap when it got in, whether it sold, and its PnL. It’s how you find “diamond hands” (wallets that bought early and didn’t sell into the pump), and the opposite: who took profit and when. ## Get the cohort in one call Example [Starter plan · 10 credits](https://docs.crius.sh/reference/holders/holder-cohort/) ### Who held CHARGE from $50k market cap to now Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) first crossed $50k market cap two hours after launch. Which wallets held from that moment until now? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap:50000&to=now&limit=5 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap:50000&to=now&limit=5" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap:50000&to=now&limit=5", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap:50000&to=now&limit=5", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 125 lines (arrays trimmed)** ```json { "data": { "criteria": { "continuous": false, "exclude": [], "min_balance": null, "min_hold_s": null, "min_pct": null, "min_usd": null, "reset_on": "sell" }, "holders": [ { "address": "0xfee5fee50000062bd986e86502c5acdf989067a0", "balance_at_from": 5758.56, "balance_now": 47534.9, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 5758.56, "pnl_usd": null, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [ "contract" ], "value_usd_now": 0.183244 }, { "address": "0xb823bd7738b61547221f54bb3410b94326aae1eb", "balance_at_from": 497321, "balance_now": 497321, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 497321, "pnl_usd": -22.1233, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 1.91714 }, { "address": "0x38c16e94e79383a5906449fc84477c1a7b19b613", "balance_at_from": 8344519, "balance_now": 0.00000000214748, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 0.00000000214748, "pnl_usd": -298.108, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 0.00000000000000827841 }, { "address": "0x8e56f6476d1361cdc6e75798c83354e70d033f23", "balance_at_from": 57.0322, "balance_now": 57.0322, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 57.0322, "pnl_usd": -0.00219735, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [ "smart_account" ], "value_usd_now": 0.000219856 }, { "address": "0xfd2a475d7ce02ec077867d72177063b5c2ab01b6", "balance_at_from": 429.912, "balance_now": 429.912, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 429.912, "pnl_usd": -0.396922, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 0.00165728 } ], "never_reached_threshold": 0, "qualified": 224, "reset_out": 942, "started_qualified": 229, "window": { "from": { "at": "mcap:50000", "block": 88461359, "ts": 1791990426900 }, "to": { "at": "now", "block": 100406815, "ts": 1793225079000 } } }, "meta": { "block": 100406816, "block_age_ms": 1088, "block_ts": 1793225079000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 86, "next_cursor": "5", "safe_block": 100401329 } } ``` What this tells you - `window.from` resolved `mcap:50000` to block 88461359 at `ts: 1791990426900` (2026-10-14 15:07 UTC); `window.to` is `now`, block 100406815. - `started_qualified: 229` wallets held at the $50k crossing, `qualified: 224` qualify at the end of the window, and `reset_out: 942` held at some point in the window but no longer qualify. - The five listed wallets all have `qualified_since_block: 88461359`, `resets: 0` and `sells_in_window: 0`: they held from the crossing to the end, `hold_time_s: 1234652` (about 14.3 days). `entry_mcap_usd: 51583.8` is the market cap at that block’s price. - `0xb823bd7738b61547221f54bb3410b94326aae1eb` never touched its position (`balance_at_from` and `balance_now` both 497321) and sits at `pnl_usd: -22.1233`: holding through the run doesn’t mean profit when the token later fell. - `0x38c16e94e79383a5906449fc84477c1a7b19b613` went from 8,344,519 tokens to `balance_now: 0.00000000214748` with `sells_in_window: 0`. It moved its tokens out by transfer, which the default `reset_on: "sell"` doesn’t count, and with no threshold (`criteria.min_usd: null`) a dust balance still qualifies. A real query should set `min_usd`. - `0xfee5fee50000062bd986e86502c5acdf989067a0` is tagged `contract` and has `pnl_usd: null`: it never bought or sold the token on a DEX, so there is no cost to measure against. [Holder cohort reference](https://docs.crius.sh/reference/holders/holder-cohort/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Who%20held%20CHARGE%20from%20%2450k%20market%20cap%20to%20now&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-diamond-hand-holders%2F%23charge-cohort%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%2Fcohort%3Ffrom%3Dmcap%3A50000%26to%3Dnow%26limit%3D5%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How a wallet qualifies A wallet **qualifies** while its balance is above your threshold. Choose one: - `min_usd`: the balance’s value at each block’s price, for example `min_usd=50`. - `min_balance`: a token amount. - `min_pct`: a share of supply. Without any of them, any non-zero balance qualifies, as in the example. A **reset** breaks a wallet’s holding streak. `reset_on` decides what counts: | `reset_on` | A wallet resets when | | --- | --- | | `sell` (default) | it sells on a DEX or launchpad, or drops below the threshold | | `any_decrease` | its balance goes down for any reason (sell or transfer out), or it drops below the threshold | | `below_threshold` | only when it drops below the threshold | | `none` | only when its balance reaches zero | After a reset, a wallet that still qualifies starts a new streak (its `qualified_since_block` moves to the reset, and `reset_history` records it). With `continuous=true`, any reset, or not qualifying at `from`, removes it from the result and counts it in `reset_out`. Other filters: `min_hold_s` (a minimum hold time), `entered_before` (a point: only wallets that first qualified before it), `exclude` (`infra`, `dev`, `snipers`) and `sort` (`hold_time`, the default, longest first; `balance`; `entry_mcap`). `from` and `to` take the same points as snapshots: `block:N`, `ts:MS`, `mcap:USD`, or the labels `launch`, `graduation`, `ath`, `now` (see [historical holders](https://docs.crius.sh/guides/get-historical-holders/#choose-the-point-in-time)). ## What the fields mean | Field | Meaning | | --- | --- | | `qualified` | Wallets that qualify at the end of the window (with `continuous=true`: held the whole window). | | `started_qualified` | Wallets that qualified at `from`. | | `reset_out` | Wallets that qualified at some point in the window but not at the end, or broke continuity. | | `never_reached_threshold` | Wallets that held in the window but never above the threshold. | | `holders[].qualified_since_block`, `qualified_since_ts` | Start of the wallet's current streak. | | `holders[].hold_time_s` | Seconds from the streak's start to `to`. | | `holders[].entry_mcap_usd` | Market cap at the streak's start. | | `holders[].balance_at_from`, `balance_now`, `min_balance_in_window` | Balance at `from`, at `to`, and the lowest in between. | | `holders[].sells_in_window`, `resets`, `reset_history` | Sells in the window, the number of resets and when they happened (block, time, reason, balance after). | | `holders[].value_usd_now`, `pnl_usd` | Value at `to`, and sells plus current value minus buys. `null` when the wallet never traded the token. | | `criteria` | The definition used, echoed back. | ## Use it in your app 1. **Define a diamond hand for your users.** A typical one: at least $50 (`min_usd=50`), held since a point (`from=mcap:10000`), never sold (`continuous=true&reset_on=sell`), not the dev or a sniper (`exclude=infra,dev,snipers`). 2. **Show the evidence.** `entry_mcap_usd` and `hold_time_s` are what readers trust: “in since a $10k market cap, held 14 days”. Add `pnl_usd` when it’s known. 3. **Use the counters as a conviction score.** `qualified` against `started_qualified` says how many early holders stayed. In the example, more wallets lost qualification during the window (942) than held at its start (229). 4. **Get a Starter key.** The cohort endpoint needs the Starter plan and costs 10 credits per call; cache results per window, since a closed window never changes. ```js // Wallets that held at least $50 of CHARGE from a $10k market cap to now, without selling. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const q = new URLSearchParams({ from: "mcap:10000", to: "now", min_usd: "50", continuous: "true", reset_on: "sell", exclude: "infra,dev,snipers", limit: "50", }); const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/holders/cohort?${q}`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); console.log(`${data.qualified} of ${data.started_qualified} early holders never sold`); for (const h of data.holders) { const days = (h.hold_time_s / 86400).toFixed(1); console.log(h.address, `in at $${h.entry_mcap_usd} mcap`, `${days} d`, `PnL $${h.pnl_usd ?? "?"}`); } ``` Big tokens and long windows The cohort replays every transfer up to `to`. Tokens with more than 2M transfers, or a window with more than 2M balance changes, return `400 window_too_large`: narrow the window. ## Frequently asked questions **How do I find diamond-hand holders of a token?** Ask for the cohort over the run with a strict definition: `/holders/cohort?from=mcap:10000&to=now&min_usd=50&continuous=true&reset_on=sell&exclude=infra`. Only wallets that held at least $50 at the start and never sold or dropped below $50 until now come back, sorted by how long they held. **What is the difference between \`continuous=true\` and the default?** By default a wallet qualifies if it meets the threshold at the end of the window, even if it joined late or sold and bought back (its hold time then starts at its last reset). With `continuous=true` it must already qualify at `from` and never reset until `to`; everyone else is counted in `reset_out`. **Does a transfer to another wallet count as selling?** Not with the default `reset_on=sell`: only sells on a DEX or launchpad reset a holder. Use `reset_on=any_decrease` to also break on transfers out, or a `min_usd` threshold so a wallet that moved its tokens away drops out (`below_threshold`). **How do I find early buyers who are still holding?** Use `entered_before`: `from=launch&to=now&entered_before=mcap:20000` keeps only wallets that first qualified before the market cap crossed $20k. Add `exclude=snipers,dev` to leave out the launch snipers and the creator. **Which plan does the cohort endpoint need?** The Starter plan or higher, 10 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Historical holders** Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder. Read](https://docs.crius.sh/guides/get-historical-holders/) [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [API reference **Holder cohort API** Wallets that held through a window. A holder qualifies when it stayed above a size threshold (min\_usd, min\_balance or min\_pct); with continuous=true it must hold for the whole window, and reset\_on dec Read](https://docs.crius.sh/reference/holders/holder-cohort/) --- # Find new tokens on Robinhood Chain as they launch > List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Source: https://docs.crius.sh/guides/find-new-tokens/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/tokens?list=new`. It returns the newest tokens first with `created_ts`, `launchpad`, `status`, `progress_pct`, price, liquidity, holders and trade counts per window. Narrow it with `launchpad=pons`, `min_liquidity_usd` and `created_after_ts`. Anonymous plan, no key needed. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) The `new` token list is a feed of every token created on Robinhood Chain, newest first. Each row says which launchpad created it (if any), whether it is still on a bonding curve, how much liquidity it has and how many wallets have traded it in the last 5 minutes, 1 hour, 6 hours and 24 hours. Tokens appear about a second after their creation block, so you can screen a launch before most traders have seen it. ## List new tokens in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The raw feed: three tokens created in the last 12 seconds Which tokens were created on Robinhood Chain in the last few seconds? GET/v1/robinhood/tokens?list=new&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xbdf2ec96464a76a0a779207f5b874add51d49598", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 100406901, "created_ts": 1793225088200, "decimals": 18, "fdv_usd": null, "holders": 1, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 0, "logo": null, "market_cap_usd": null, "name": "WAGIE", "price_eth": null, "price_usd": null, "progress_pct": null, "quote": null, "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": null, "symbol": "WAGIE", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } }, { "address": "0x6b7403d913ec9a579baa91041a537bf4fa4b6276", "buy_volume_usd": { "1h": 3917.87, "24h": 3917.87, "5m": 3917.87, "6h": 3917.87 }, "buyers": { "1h": 22, "24h": 22, "5m": 22, "6h": 22 }, "buys": { "1h": 25, "24h": 25, "5m": 25, "6h": 25 }, "change_pct": { "1h": 58.8899, "24h": 58.8899, "5m": 58.8899, "6h": 58.8899 }, "created_block": 100406804, "created_ts": 1793225078400, "decimals": 18, "fdv_usd": 12956.2, "holders": 20, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/texashedge17154/status/2115565415325630769", "website": "https://mafiacoin.site" }, "liquidity_usd": 4460.87, "logo": "https://api.crius.sh/v1/robinhood/logo/0x6b7403d913ec9a579baa91041a537bf4fa4b6276.png?size=128", "market_cap_usd": 12956.2, "name": "MAFIA", "price_eth": 0.00000000550045, "price_usd": 0.0000129562, "progress_pct": 11.347, "quote": "PYPL", "sell_volume_usd": { "1h": 1909.9, "24h": 1909.9, "5m": 1909.9, "6h": 1909.9 }, "sellers": { "1h": 6, "24h": 6, "5m": 6, "6h": 6 }, "sells": { "1h": 11, "24h": 11, "5m": 11, "6h": 11 }, "status": "bonding", "symbol": "MAFIA", "traders": { "1h": 22, "24h": 22, "5m": 22, "6h": 22 }, "txns": { "1h": 34, "24h": 34, "5m": 34, "6h": 34 }, "volume_usd": { "1h": 5827.78, "24h": 5827.78, "5m": 5827.78, "6h": 5827.78 } }, { "address": "0xea503b501082d8aa091e4d1e985f28e13ed3d6b3", "buy_volume_usd": { "1h": 0.00470845, "24h": 0.00470845, "5m": 0.00470845, "6h": 0.00470845 }, "buyers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "buys": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "change_pct": { "1h": -0.0099799, "24h": -0.0099799, "5m": -0.0099799, "6h": -0.0099799 }, "created_block": 100406793, "created_ts": 1793225077300, "decimals": 18, "fdv_usd": 23554.9, "holders": 3, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 0.00941591, "logo": null, "market_cap_usd": 23554.9, "name": "Fries in the bag", "price_eth": 0.00000001, "price_usd": 0.0000235549, "progress_pct": null, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": null, "symbol": "Fries", "traders": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "txns": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "volume_usd": { "1h": 0.00470845, "24h": 0.00470845, "5m": 0.00470845, "6h": 0.00470845 } } ], "meta": { "block": 100406905, "block_age_ms": 535, "block_ts": 1793225089000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 29, "list": "new", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - WAGIE (`0xbdf2ec96464a76a0a779207f5b874add51d49598`) was created 1.3 seconds before the response (`created_ts: 1793225088200`). It has `holders: 1`, `liquidity_usd: 0` and `price_usd: null`: nothing has traded yet, and `launchpad: null` means it wasn’t created by a launchpad Crius knows. - MAFIA (`0x6b7403d913ec9a579baa91041a537bf4fa4b6276`) is a Pons token (`launchpad: "pons"`, `status: "bonding"`). Eleven seconds after launch it already had 22 buyers, $5,827.78 of volume (`volume_usd["5m"]`) and was 11.347% of the way up its curve (`progress_pct`). Its `quote` is PYPL: the curve is priced in a tokenized stock, not ETH. - “Fries in the bag” (`0xea503b501082d8aa091e4d1e985f28e13ed3d6b3`) shows a $23,554.9 market cap on $0.0094 of liquidity and a single buyer. A market cap this early says nothing; liquidity and buyers do. - `meta.lag_ms: 29`: the list reflected the chain head 29 ms after the block arrived. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20raw%20feed%3A%20three%20tokens%20created%20in%20the%20last%2012%20seconds&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-new-tokens%2F%23raw-feed%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Most of the raw feed is noise: Pons alone had 1,781 launches in the 24 hours before these samples and 16 graduations (`launches_24h` and `graduated_24h` in the [launchpads](https://docs.crius.sh/reference/launchpads/launchpads/) response). A liquidity floor removes the tokens nobody has bought. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Only new tokens with $1,000+ liquidity Which new Robinhood Chain tokens already have real money in them? GET/v1/robinhood/tokens?list=new&min\_liquidity\_usd=1000&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&min_liquidity_usd=1000&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&min_liquidity_usd=1000&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&min_liquidity_usd=1000&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x5132c73e282f15e156d43fe1757115c4bda208be", "buy_volume_usd": { "1h": 1425.88, "24h": 1425.88, "5m": 1425.88, "6h": 1425.88 }, "buyers": { "1h": 8, "24h": 8, "5m": 8, "6h": 8 }, "buys": { "1h": 29, "24h": 29, "5m": 29, "6h": 29 }, "change_pct": { "1h": 6.40071, "24h": 6.40071, "5m": 6.40071, "6h": 6.40071 }, "created_block": 100409067, "created_ts": 1793225312360, "decimals": 18, "fdv_usd": 17454, "holders": 7, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/1vampnation1/status/2115566407018565807", "website": "https://trustinnom.xyz/" }, "liquidity_usd": 2392, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5132c73e282f15e156d43fe1757115c4bda208be.png?size=128", "market_cap_usd": 17454, "name": "paycat", "price_eth": 0.00000000740993, "price_usd": 0.000017454, "progress_pct": 3.19647, "quote": "PYPL", "sell_volume_usd": { "1h": 285.934, "24h": 285.934, "5m": 285.934, "6h": 285.934 }, "sellers": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "sells": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "status": "bonding", "symbol": "PAYCAT", "traders": { "1h": 8, "24h": 8, "5m": 8, "6h": 8 }, "txns": { "1h": 31, "24h": 31, "5m": 31, "6h": 31 }, "volume_usd": { "1h": 1711.82, "24h": 1711.82, "5m": 1711.82, "6h": 1711.82 } }, { "address": "0x578dfaf61257ea702b8834bb037740a6368947bd", "buy_volume_usd": { "1h": 9284.83, "24h": 9284.83, "5m": 9284.83, "6h": 9284.83 }, "buyers": { "1h": 36, "24h": 36, "5m": 36, "6h": 36 }, "buys": { "1h": 41, "24h": 41, "5m": 41, "6h": 41 }, "change_pct": { "1h": 144.257, "24h": 144.257, "5m": 144.257, "6h": 144.257 }, "created_block": 100408825, "created_ts": 1793225289500, "decimals": 18, "fdv_usd": 79032.9, "holders": 150, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 22199.3, "logo": null, "market_cap_usd": 18050.7, "name": "Housecoin", "price_eth": 0.0000000335526, "price_usd": 0.0000790329, "progress_pct": null, "quote": "ETH", "sell_volume_usd": { "1h": 5158.82, "24h": 5158.82, "5m": 5158.82, "6h": 5158.82 }, "sellers": { "1h": 20, "24h": 20, "5m": 20, "6h": 20 }, "sells": { "1h": 37, "24h": 37, "5m": 37, "6h": 37 }, "status": null, "symbol": "HOUSECOIN", "traders": { "1h": 36, "24h": 36, "5m": 36, "6h": 36 }, "txns": { "1h": 78, "24h": 78, "5m": 78, "6h": 78 }, "volume_usd": { "1h": 14443.6, "24h": 14443.6, "5m": 14443.6, "6h": 14443.6 } }, { "address": "0x3736c3daeb6bee85b8086354424e31e23d39a416", "buy_volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 }, "buyers": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "buys": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "change_pct": { "1h": 349.859, "24h": 349.859, "5m": 349.859, "6h": 349.859 }, "created_block": 100408733, "created_ts": 1793225280300, "decimals": 18, "fdv_usd": 9653.95, "holders": 18, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 4794.48, "logo": "https://api.crius.sh/v1/robinhood/logo/0x3736c3daeb6bee85b8086354424e31e23d39a416.png?size=128", "market_cap_usd": 9653.95, "name": "Ronald", "price_eth": 0.00000000409848, "price_usd": 0.00000965395, "progress_pct": 47.1712, "quote": "MCD", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "RONALD", "traders": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "txns": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 } } ], "meta": { "block": 100409873, "block_age_ms": 365, "block_ts": 1793225393000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 33, "list": "new", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - All three tokens are under two minutes old and every one has `liquidity_usd` above 1,000. The empty launches in between were skipped. - Housecoin (`0x578dfaf61257ea702b8834bb037740a6368947bd`) has no launchpad, $22,199.3 of liquidity and 150 holders 104 seconds after creation: someone deployed it and seeded a pool directly. - Ronald (`0x3736c3daeb6bee85b8086354424e31e23d39a416`) is a Pons token at `progress_pct: 47.1712` with 16 buys and 0 sells. Sixteen wallets buying and nobody selling in the first two minutes is worth a look at the [launch’s snipers and bundles](https://docs.crius.sh/guides/detect-bundles-and-snipers/) before you buy. - paycat (`0x5132c73e282f15e156d43fe1757115c4bda208be`) is quoted in PYPL like MAFIA above, with 7 holders and $2,392 of liquidity. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Only%20new%20tokens%20with%20%241%2C000%2B%20liquidity&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-new-tokens%2F%23with-liquidity%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26min_liquidity_usd%3D1000%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Filters for new tokens | Parameter | What it does | Example | | --- | --- | --- | | `launchpad` | Only tokens from one launchpad: `pons`, `flap`, `bankr`, `long`, `flywheel`, `standard_reserve`. | `launchpad=pons` | | `min_liquidity_usd` | Skip tokens whose `liquidity_usd` is below this. | `min_liquidity_usd=1000` | | `created_after_ts` | Only tokens created after this time, in milliseconds (the unit of `created_ts`). | `created_after_ts=1793225000000` | | `quote` | Only tokens quoted in ETH (or WETH) or USDG. | `quote=eth` | | `min_volume_usd` | Skip tokens with less volume in the `window`. | `min_volume_usd=500&window=1h` | | `clean` | Apply the trending quality checks: no crash, $1,000+ liquidity, 20+ real holders, no insider launch. | `clean=true` | | `limit`, `cursor` | Up to 100 rows per page; pass `meta.next_cursor` back as `cursor` for the next page. | `limit=100&cursor=100` | What each row means: - `created_ts` / `created_block`: when the token contract was created. - `launchpad` / `launchpad_name`: the launchpad’s id and display name, or `null` for tokens deployed directly. - `status`: `bonding` while on a launchpad’s curve, `graduated` after it moved to a DEX pool, `launched` for launchpads with no curve stage (Bankr, Long.xyz), `null` for direct deploys. - `progress_pct`: how far along the bonding curve the token is; `null` until the curve has been traded or when progress isn’t measured. - `buys`, `sells`, `buyers`, `sellers`, `traders`, `volume_usd`, `change_pct`: per window (`5m`, `1h`, `6h`, `24h`). - `logo` and `links`: the token’s metadata, when the launch included it. ## Use it in your app 1. **Poll `list=new` with a liquidity floor.** Every few seconds is enough: lists are refreshed continuously and the anonymous plan allows 2 requests per second. Keep `created_after_ts` a few minutes back so a token that gains liquidity after its first poll is still caught. 2. **Deduplicate by `address`.** The same token comes back on every poll while it is inside the time window. 3. **Screen each new address before showing it.** Call [`/security`](https://docs.crius.sh/guides/token-security-score/) (anonymous, 1 credit) for the honeypot, tax and insider checks, and drop `critical` or `high` risk tokens. 4. **Switch to the stream when polling isn’t fast enough.** The `launches:all` channel on the [WebSocket](https://docs.crius.sh/reference/stream/) pushes each launch as it is indexed. ```js // Print new Pons tokens with $1,000+ liquidity as they appear. const API = "https://api.crius.sh/v1/robinhood"; const seen = new Set(); async function poll() { const since = Date.now() - 10 * 60_000; // created_ts is in milliseconds const url = `${API}/tokens?list=new&launchpad=pons&min_liquidity_usd=1000&created_after_ts=${since}&limit=100`; const { data } = await (await fetch(url)).json(); for (const t of data) { if (seen.has(t.address)) continue; seen.add(t.address); console.log(`${t.symbol} ${t.address} ${t.status} ${t.progress_pct ?? "?"}% liq $${t.liquidity_usd} holders ${t.holders}`); } } setInterval(poll, 5000); ``` New means unchecked A token’s first minutes are when snipers, bundled buys and honeypots do their damage. The list tells you a token exists and is trading; it doesn’t say it’s safe. Check `/security` and the launch before you list or buy anything from this feed. ## Frequently asked questions **How do I find new tokens on Robinhood Chain?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=new`. Tokens come newest first, usually a second or two after the creation block, with their launchpad (`pons`, `flap`, …), price, liquidity and holder count. Add `min_liquidity_usd=1000` to skip tokens nobody has bought yet. **How do I get only new Pons tokens?** Add `launchpad=pons` to the list: `/v1/robinhood/tokens?list=new&launchpad=pons`. The same filter works with `flap`, `bankr`, `long`, `flywheel` and `standard_reserve`. Tokens deployed outside a known launchpad have `launchpad: null`. **Why does a new token have a null price and market cap?** Nobody has traded it yet. `price_usd`, `market_cap_usd` and `fdv_usd` stay `null` until the first trade gives the token a price, and `liquidity_usd` is 0 until a pool or curve holds quote currency. **Does an old token that starts trading again show up as new?** No. `list=new` only contains tokens created from scratch. A token that existed before and becomes active again is left out; look for it in `trending` or `top_volume` instead. **Can I get new tokens pushed to me instead of polling?** Yes. Subscribe to `launches:all` (or `launches:pons`, `launches:flap`, …) on the [WebSocket stream](https://docs.crius.sh/reference/stream/), which needs a free API key. Polling `list=new` every few seconds also works on the anonymous plan. ## Related [Guide **Stream new tokens** Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token. Read](https://docs.crius.sh/guides/stream-new-tokens/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [API reference **Token lists API** Lists: new, bonding, graduating, graduated, trending, top\_volume, top\_gainers, top\_losers, top\_market\_cap (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Read](https://docs.crius.sh/reference/discovery/token-lists/) --- # Find Robinhood Chain tokens above a market cap > Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses. Source: https://docs.crius.sh/guides/find-tokens-by-market-cap/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&clean=true`. It ranks tokens traded in the last 30 days by `market_cap_usd` (price × circulating supply), leaves out prices from thin markets, and `clean=true` removes tokens with too few holders, rugs and insider launches. Use `max_market_cap_usd` for a range. Anonymous plan. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) `top_market_cap` ranks Robinhood Chain tokens by market cap: the token’s USD price times its circulating supply. Only tokens traded in the last 30 days are ranked, and prices that come from thin markets don’t count. Market cap is still the easiest number to fake on a new chain, so the useful call combines a minimum (`min_market_cap_usd`) with the quality checks (`clean=true`). ## Rank tokens by market cap Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The unfiltered ranking: a $1 billion token with 4 holders Which Robinhood Chain tokens have a market cap above $100,000? GET/v1/robinhood/tokens?list=top\_market\_cap&min\_market\_cap\_usd=100000&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x124597e2d8bbe472825c4918a36de246ed0c92f7", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "change_pct": { "1h": 1.04445, "24h": 1.04445, "5m": 1.04445, "6h": 1.04445 }, "created_block": 89335667, "created_ts": 1792078513700, "decimals": 18, "fdv_usd": 1001391399, "holders": 4, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 3795.38, "logo": null, "market_cap_usd": 1001391399, "name": "MJDQ", "price_eth": 0.000425131, "price_usd": 1.00139, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 0, "24h": 132.148, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "status": null, "symbol": "MJDQ", "traders": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 1, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 132.148, "5m": 0, "6h": 0 } }, { "address": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b", "buy_volume_usd": { "1h": 13.6371, "24h": 181.872, "5m": 0.803523, "6h": 121.185 }, "buyers": { "1h": 20, "24h": 151, "5m": 1, "6h": 100 }, "buys": { "1h": 20, "24h": 189, "5m": 1, "6h": 129 }, "change_pct": { "1h": -0.223948, "24h": 2.12439, "5m": -0.641239, "6h": 2.20377 }, "created_block": 62239223, "created_ts": 1789331186300, "decimals": 9, "fdv_usd": 890862106, "holders": 12467, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/letsendaix", "website": "https://www.letsendai.fun" }, "liquidity_usd": 33898.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc882f10529a5518ee3393af5a80e9ff00d38d44b.png?size=128", "market_cap_usd": 890862106, "name": "Let's End AI", "price_eth": 0.000378207, "price_usd": 0.890862, "progress_pct": null, "quote": "WETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": null, "symbol": "ENDAI", "traders": { "1h": 20, "24h": 151, "5m": 1, "6h": 100 }, "txns": { "1h": 20, "24h": 189, "5m": 1, "6h": 129 }, "volume_usd": { "1h": 13.6371, "24h": 181.872, "5m": 0.803523, "6h": 121.185 } }, { "address": "0x51250b135174ca09450ec01c4aff73cf69dbb590", "buy_volume_usd": { "1h": 298.219, "24h": 194262, "5m": 0, "6h": 12765.1 }, "buyers": { "1h": 1, "24h": 241, "5m": 0, "6h": 21 }, "buys": { "1h": 1, "24h": 345, "5m": 0, "6h": 31 }, "change_pct": { "1h": -0.491361, "24h": -4.39846, "5m": -0.621303, "6h": 0.00152615 }, "created_block": 40138679, "created_ts": 1787100251900, "decimals": 18, "fdv_usd": 508267757, "holders": 14160, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/dpxkdevkhpe1mzlh", "twitter": "https://x.com/lalarochaas", "website": "https://www.novaai-robinhood.com/" }, "liquidity_usd": 2026836, "logo": "https://api.crius.sh/v1/robinhood/logo/0x51250b135174ca09450ec01c4aff73cf69dbb590.png?size=128", "market_cap_usd": 441684192, "name": "NovaAI", "price_eth": 0.00021578, "price_usd": 0.508268, "progress_pct": 100, "quote": "ETH", "sell_volume_usd": { "1h": 4489.37, "24h": 220591, "5m": 0, "6h": 18022 }, "sellers": { "1h": 4, "24h": 191, "5m": 0, "6h": 14 }, "sells": { "1h": 4, "24h": 298, "5m": 0, "6h": 22 }, "status": "graduated", "symbol": "NOVAAI", "traders": { "1h": 5, "24h": 403, "5m": 0, "6h": 33 }, "txns": { "1h": 5, "24h": 630, "5m": 0, "6h": 53 }, "volume_usd": { "1h": 4787.59, "24h": 414853, "5m": 0, "6h": 30787.1 } } ], "meta": { "block": 100406948, "block_age_ms": 1004, "block_ts": 1793225093000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 171, "list": "top_market_cap", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - MJDQ (`0x124597e2d8bbe472825c4918a36de246ed0c92f7`) is first with `market_cap_usd: 1001391399`. It has `holders: 4`, $3,795.38 of liquidity and one trade of $132.15 in 24 hours. A price of $1.00 on a billion tokens is all it takes. - Let’s End AI (`0xc882f10529a5518ee3393af5a80e9ff00d38d44b`) is second at $890.9 million. It is the honeypot from [Detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/): 189 buys and `sells["24h"]: 0`. - NovaAI (`0x51250b135174ca09450ec01c4aff73cf69dbb590`) is a graduated Pons token (`status: "graduated"`) at $441.7 million with 14,160 holders and $2.0 million of liquidity. It looks real, but see the third example below. - `market_cap_usd` and `fdv_usd` differ for NovaAI ($441,684,192 vs $508,267,757): part of the supply has been burned. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20unfiltered%20ranking%3A%20a%20%241%20billion%20token%20with%204%20holders&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-tokens-by-market-cap%2F%23unfiltered%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtop_market_cap%26min_market_cap_usd%3D100000%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The same ranking with clean=true Which Robinhood Chain tokens above $100,000 market cap have real holders and no rug or insider launch? GET/v1/robinhood/tokens?list=top\_market\_cap&min\_market\_cap\_usd=100000&clean=true&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&clean=true&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&clean=true&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&clean=true&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x39dbed3a2bd333467115de45665cc57f813c4571", "buy_volume_usd": { "1h": 118261, "24h": 4891132, "5m": 458.729, "6h": 820965 }, "buyers": { "1h": 81, "24h": 1544, "5m": 6, "6h": 441 }, "buys": { "1h": 473, "24h": 15610, "5m": 8, "6h": 2908 }, "change_pct": { "1h": -0.0859482, "24h": 12.9764, "5m": 0.264066, "6h": 1.08651 }, "created_block": 8963150, "created_ts": 1783975341000, "decimals": 18, "fdv_usd": 288440203, "holders": 104459, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/ponsdotfamily", "website": "https://ponsfamily.com/launchpad" }, "liquidity_usd": 5252526, "logo": "https://api.crius.sh/v1/robinhood/logo/0x39dbed3a2bd333467115de45665cc57f813c4571.png?size=128", "market_cap_usd": 193798205, "name": "Pons", "price_eth": 0.000122454, "price_usd": 0.28844, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 98393.7, "24h": 4246360, "5m": 3784.73, "6h": 814773 }, "sellers": { "1h": 88, "24h": 1348, "5m": 12, "6h": 516 }, "sells": { "1h": 366, "24h": 14467, "5m": 20, "6h": 3217 }, "status": null, "symbol": "PONS", "traders": { "1h": 143, "24h": 2449, "5m": 17, "6h": 858 }, "txns": { "1h": 802, "24h": 28086, "5m": 23, "6h": 5739 }, "volume_usd": { "1h": 216655, "24h": 9137492, "5m": 4243.46, "6h": 1635738 } }, { "address": "0x40858070814a57fdf33a613ae84fe0a8b4a874f7", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": 0.096588, "24h": 0.096588, "5m": 0.096588, "6h": 0.096588 }, "created_block": 34994, "created_ts": 1780673970480, "decimals": 6, "fdv_usd": 121240082, "holders": 142, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 3280741, "logo": null, "market_cap_usd": 121240082, "name": "syrupUSDG", "price_eth": 0.000431169, "price_usd": 1.01561, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 0, "24h": 366.094, "5m": 0, "6h": 366.094 }, "sellers": { "1h": 0, "24h": 1, "5m": 0, "6h": 1 }, "sells": { "1h": 0, "24h": 1, "5m": 0, "6h": 1 }, "status": null, "symbol": "syrupUSDG", "traders": { "1h": 0, "24h": 1, "5m": 0, "6h": 1 }, "txns": { "1h": 0, "24h": 1, "5m": 0, "6h": 1 }, "volume_usd": { "1h": 0, "24h": 366.094, "5m": 0, "6h": 366.094 } }, { "address": "0x020bfc650a365f8bb26819deaabf3e21291018b4", "buy_volume_usd": { "1h": 48510.9, "24h": 2822859, "5m": 25.927, "6h": 806803 }, "buyers": { "1h": 40, "24h": 882, "5m": 2, "6h": 337 }, "buys": { "1h": 232, "24h": 7886, "5m": 2, "6h": 2644 }, "change_pct": { "1h": -1.04522, "24h": 8.42326, "5m": 0.0577768, "6h": 6.65947 }, "created_block": 88836, "created_ts": 1781812852800, "decimals": 18, "fdv_usd": 104328983, "holders": 113911, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/cashcat_robinhood", "twitter": "https://x.com/cashcat_token", "website": "https://cashcat.cc/" }, "liquidity_usd": 3984810, "logo": "https://api.crius.sh/v1/robinhood/logo/0x020bfc650a365f8bb26819deaabf3e21291018b4.png?size=128", "market_cap_usd": 103050175, "name": "Cash Cat", "price_eth": 0.0000442918, "price_usd": 0.104329, "progress_pct": null, "quote": "WETH", "sell_volume_usd": { "1h": 73426.7, "24h": 2428869, "5m": 8961.26, "6h": 545082 }, "sellers": { "1h": 51, "24h": 1054, "5m": 9, "6h": 455 }, "sells": { "1h": 265, "24h": 8864, "5m": 33, "6h": 2354 }, "status": null, "symbol": "CASHCAT", "traders": { "1h": 80, "24h": 1584, "5m": 11, "6h": 661 }, "txns": { "1h": 487, "24h": 15671, "5m": 35, "6h": 4660 }, "volume_usd": { "1h": 121938, "24h": 5251728, "5m": 8987.19, "6h": 1351884 } } ], "meta": { "block": 100410083, "block_age_ms": 544, "block_ts": 1793225414000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 134, "list": "top_market_cap", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - All three tokens from the first example are gone. The top is now Pons (PONS, `0x39dbed3a2bd333467115de45665cc57f813c4571`) with `market_cap_usd: 193798205`, 104,459 holders, $5,252,526 of liquidity and $9.1 million traded in 24 hours. Its FDV is $288,440,203. - Cash Cat (CASHCAT, `0x020bfc650a365f8bb26819deaabf3e21291018b4`) is third at $103,050,175 with 113,911 holders and $5.25 million of 24-hour volume. - syrupUSDG (`0x40858070814a57fdf33a613ae84fe0a8b4a874f7`) is second at $121,240,082 with $3,280,741 of liquidity, but it has 142 holders and traded $366 in 24 hours. It passes every check; add `min_volume_usd` if you only want tokens people are trading. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20same%20ranking%20with%20clean%3Dtrue&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-tokens-by-market-cap%2F%23clean%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtop_market_cap%26min_market_cap_usd%3D100000%26clean%3Dtrue%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) NovaAI didn’t fail on holders or liquidity. The security check shows why it left the clean list: Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Why NovaAI was filtered out: an insider launch NovaAI has a $441 million market cap and 14,160 holders. Why doesn't it pass clean=true? GET/v1/robinhood/token/0x51250b135174ca09450ec01c4aff73cf69dbb590/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x51250b135174ca09450ec01c4aff73cf69dbb590/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x51250b135174ca09450ec01c4aff73cf69dbb590/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x51250b135174ca09450ec01c4aff73cf69dbb590/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 180 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified", "insider_launch" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.683956, "pools_traded": 10527, "taxed_pct": 51.9711, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793225483000, "liquidity_pulled_pct": 0.668003, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423, "pools": 10480, "pools_traded": 10479, "tax_measured_pools": 10394, "taxed_10pct_pools": 35, "taxed_pools": 5464, "volume_usd": 5385313118 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696217, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93456, "pools_traded": 43090, "taxed_pct": 15.7531 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [ "insider_launch" ], "lp_top_wallet": { "address": "0x5a0c1f73d39ccafe275b5e6b3b9a731784a9d24c", "liquidity_usd": 117.708, "pct": 0.00582113 }, "sniper_supply_pct": 71.223, "sniper_top_wallet_pct": 71.223, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "locked", "summary": { "burned_pct": 0.000219067, "locked_pct": 99.9686, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0312301, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "high", "score": 45, "tax": { "buy_pct": 0.99, "confidence": "high", "realized": { "buy_pct": 0.99, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793225775000, "max_sell_pct_seen": 99.98, "samples": { "buys": 35287, "sells": 22458 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 90208177, "pct": 0, "side": "buy" }, { "from_block": 90217260, "pct": 1, "side": "buy" }, { "from_block": 90500949, "pct": 0, "side": "buy" } ], "tax_history_total": 349, "tax_mode": "dynamic", "token": "0x51250b135174ca09450ec01c4aff73cf69dbb590" }, "meta": { "block": 100413574, "block_age_ms": 410, "block_ts": 1793225782000, "chain": "robinhood", "finalized_block": 100405028, "lag_ms": 76, "safe_block": 100408671, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `flags` contains `insider_launch`, `risk` is `high` and `score` is 45. - `launch.sniper_wallets: 1` and `launch.sniper_supply_pct: 71.223`: one wallet bought 71% of the supply within the first 10 blocks (`sniper_window_blocks: 10`). Whoever holds that much decides the price; the market cap is what it would be worth if they never sold. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Why%20NovaAI%20was%20filtered%20out%3A%20an%20insider%20launch&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-tokens-by-market-cap%2F%23novaai%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x51250b135174ca09450ec01c4aff73cf69dbb590%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How market cap is computed | Field | Meaning | | --- | --- | | `market_cap_usd` | `price_usd` × circulating supply: total supply minus the balances of the zero address and `0x000000000000000000000000000000000000dEaD` (burned) | | `fdv_usd` | `price_usd` × total supply | | `price_usd` | From the token's deepest pool, converted to USD through on-chain ETH and USDG pools | | `liquidity_usd` | Value of the liquidity behind that price: the number that tells you whether the market cap can be sold into | | `holders` | Wallets holding the token now | Ranking rules for `top_market_cap`: - Only tokens with a trade in the last 30 days. - Prices from thin markets are skipped, so a dust pool can’t push a token to the top. As MJDQ shows, a few thousand dollars of liquidity is not thin enough to be skipped. - `min_market_cap_usd` and `max_market_cap_usd` filter on `market_cap_usd`; rows with no market cap are excluded when either is set. Both work on every list, not only this one. For how Crius splits total, circulating, burned and locked supply, see [Market cap, FDV and supply](https://docs.crius.sh/guides/market-cap-fdv-and-supply/). ## Use it in your app 1. **Always send `clean=true`.** The unfiltered ranking is led by tokens nobody holds. The clean one is led by tokens with tens of thousands of holders. 2. **Set a liquidity floor that matches the market cap.** A $10 million token with $5,000 of liquidity can’t be sold at that price. `min_liquidity_usd` filters it out. 3. **Use a range for small-cap screens.** `min_market_cap_usd=100000&max_market_cap_usd=1000000` gives the band most screeners call “small caps”. 4. **Show FDV next to market cap.** The gap is the burned supply. Locked and vesting tokens still count as circulating here; the [token profile](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) breaks them out. ```js // Small caps with real markets: $100k–$1M market cap, $10k+ liquidity, clean. const params = new URLSearchParams({ list: "top_market_cap", min_market_cap_usd: "100000", max_market_cap_usd: "1000000", min_liquidity_usd: "10000", clean: "true", limit: "50", }); const { data } = await (await fetch(`https://api.crius.sh/v1/robinhood/tokens?${params}`)).json(); for (const t of data) { console.log(`${t.symbol} mcap $${Math.round(t.market_cap_usd)} fdv $${Math.round(t.fdv_usd ?? 0)} liq $${Math.round(t.liquidity_usd)} holders ${t.holders}`); } ``` A big number is not a safe token `clean=true` removes rugs, thin holder bases and insider launches, but not honeypots that hide behind real holders. Run [`/security`](https://docs.crius.sh/guides/token-security-score/) on any token before you trade it. ## Frequently asked questions **What are the biggest tokens on Robinhood Chain by market cap?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=top_market_cap&clean=true` for the live ranking. In the sample on this page the top three clean tokens were Pons (PONS) at $193.8 million, syrupUSDG at $121.2 million and Cash Cat (CASHCAT) at $103.1 million. **Why does a token with 4 holders have a $1 billion market cap?** Market cap is price × circulating supply, and anyone can mint a billion tokens and trade one at $1. Crius doesn't rank prices from thin markets, but a few thousand dollars of liquidity is enough to set a price. Add `clean=true` (20+ holders, $1,000+ liquidity, no crash or insider launch) and a `min_liquidity_usd` that fits your users. **What's the difference between market\_cap\_usd and fdv\_usd?** `market_cap_usd` uses the circulating supply: the total supply minus tokens burned to the zero address or `0x000000000000000000000000000000000000dEaD`. `fdv_usd` uses the total supply. In the samples, PONS has a $193.8 million market cap and a $288.4 million FDV. **How do I find tokens between $100k and $1M market cap?** Pass both bounds: `/v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000&max_market_cap_usd=1000000&clean=true`. The bounds also work on the other lists, for example `list=new&min_market_cap_usd=50000` for new tokens that already passed $50k. **Which tokens are included in top\_market\_cap?** Tokens with at least one trade in the last 30 days and a price that doesn't come from a thin market. Tokens that stopped trading drop out even if their last price was high. ## Related [Guide **Market cap, FDV and supply** Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed. Read](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Token screener** Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code. Read](https://docs.crius.sh/guides/build-a-token-screener/) [API reference **Token lists API** Lists: new, bonding, graduating, graduated, trending, top\_volume, top\_gainers, top\_losers, top\_market\_cap (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Read](https://docs.crius.sh/reference/discovery/token-lists/) --- # Get trending Robinhood Chain tokens (without rugs and wash trading) > Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Source: https://docs.crius.sh/guides/find-trending-tokens/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/tokens?list=trending&window=24h`. Tokens are ranked by unique traders weighted by volume, and only clean tokens qualify: no crash of 90%+ from the window's peak, $1,000+ liquidity, 20+ holders, no insider launch. Add `clean=true` to `top_gainers` or `top_volume` for the same checks. Anonymous plan. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) Trending on Crius means **many different wallets buying and selling a token that hasn’t been rugged**. The list ranks tokens by unique traders in a time window, weighted by volume, and leaves out anything that looks like a rug, wash trading or an insider launch. The same checks can be switched on for the other lists (top gainers, top volume, new tokens) with `clean=true`. ## Get trending tokens in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Trending over 24 hours: a new meme, a Long.xyz token and NVIDIA Which Robinhood Chain tokens had the most real trading activity in the last 24 hours? GET/v1/robinhood/tokens?list=trending&window=24h&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xd086f891229cd123aadfcae7c4b40150a80fd9d7", "buy_volume_usd": { "1h": 846676, "24h": 1760953, "5m": 213539, "6h": 1760953 }, "buyers": { "1h": 2862, "24h": 4951, "5m": 893, "6h": 4951 }, "buys": { "1h": 5160, "24h": 10660, "5m": 1143, "6h": 10660 }, "change_pct": { "1h": 219.677, "24h": 34319.8, "5m": 3.97796, "6h": 34319.8 }, "created_block": 100319502, "created_ts": 1793216058240, "decimals": 18, "fdv_usd": 2836574, "holders": 2857, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/search?q=0xd086f891229cd123aadfcae7c4b40150a80fd9d7&src=typed_query&f=live", "website": "https://xdcoinsol.lol" }, "liquidity_usd": 723990, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd086f891229cd123aadfcae7c4b40150a80fd9d7.png?size=128", "market_cap_usd": 2552917, "name": "Pizza", "price_eth": 0.00000120424, "price_usd": 0.00283657, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 706205, "24h": 1465984, "5m": 207484, "6h": 1465984 }, "sellers": { "1h": 1951, "24h": 3642, "5m": 630, "6h": 3642 }, "sells": { "1h": 7995, "24h": 17196, "5m": 1833, "6h": 17196 }, "status": null, "symbol": "PIZZA", "traders": { "1h": 3401, "24h": 5197, "5m": 1288, "6h": 5197 }, "txns": { "1h": 8316, "24h": 17544, "5m": 1915, "6h": 17544 }, "volume_usd": { "1h": 1552881, "24h": 3226937, "5m": 421023, "6h": 3226937 } }, { "address": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", "buy_volume_usd": { "1h": 68152.3, "24h": 3574310, "5m": 1310.32, "6h": 2375164 }, "buyers": { "1h": 168, "24h": 2815, "5m": 15, "6h": 1546 }, "buys": { "1h": 369, "24h": 11920, "5m": 17, "6h": 5582 }, "change_pct": { "1h": 0.783146, "24h": 25.2392, "5m": -1.01199, "6h": 21.3351 }, "created_block": 9721433, "created_ts": 1784051310300, "decimals": 18, "fdv_usd": 80269321, "holders": 58015, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/artificiallyinu", "website": "https://artificialinu.com/" }, "liquidity_usd": 4181412, "logo": "https://api.crius.sh/v1/robinhood/logo/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18.png?size=128", "market_cap_usd": 80102641, "name": "Artificial Inu", "price_eth": 0.0000343898, "price_usd": 0.0810048, "progress_pct": null, "quote": "PONS", "sell_volume_usd": { "1h": 50026.5, "24h": 3026550, "5m": 4390.97, "6h": 1840520 }, "sellers": { "1h": 151, "24h": 3051, "5m": 15, "6h": 1664 }, "sells": { "1h": 287, "24h": 12095, "5m": 20, "6h": 5933 }, "status": "launched", "symbol": "AI", "traders": { "1h": 272, "24h": 4132, "5m": 27, "6h": 2294 }, "txns": { "1h": 454, "24h": 14552, "5m": 28, "6h": 6627 }, "volume_usd": { "1h": 118179, "24h": 6600860, "5m": 5701.29, "6h": 4215684 } }, { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "buy_volume_usd": { "1h": 305614, "24h": 5466111, "5m": 20057.3, "6h": 2772574 }, "buyers": { "1h": 229, "24h": 1996, "5m": 56, "6h": 790 }, "buys": { "1h": 847, "24h": 16482, "5m": 104, "6h": 6874 }, "change_pct": { "1h": 0.3314, "24h": -1.40466, "5m": -0.235953, "6h": -1.21643 }, "created_block": 153563, "created_ts": 1782222069300, "decimals": 18, "fdv_usd": 18876187, "holders": 192283, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5815054, "logo": null, "market_cap_usd": 18876064, "name": "NVIDIA • Robinhood Token", "price_eth": 0.0911626, "price_usd": 214.732, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 159139, "24h": 6030012, "5m": 54077.9, "6h": 3340517 }, "sellers": { "1h": 224, "24h": 2645, "5m": 57, "6h": 1101 }, "sells": { "1h": 678, "24h": 18554, "5m": 151, "6h": 8629 }, "status": null, "symbol": "NVDA", "traders": { "1h": 325, "24h": 3519, "5m": 83, "6h": 1422 }, "txns": { "1h": 1413, "24h": 32946, "5m": 240, "6h": 14457 }, "volume_usd": { "1h": 464753, "24h": 11496124, "5m": 74135.1, "6h": 6113091 } } ], "meta": { "block": 100406892, "block_age_ms": 1238, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 117, "list": "trending", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Pizza (`0xd086f891229cd123aadfcae7c4b40150a80fd9d7`) is first with `traders["24h"]: 5197` and `volume_usd["24h"]: 3226937`. It was created about 2.5 hours before the response (`created_ts: 1793216058240`) and is up 34,319.8% (`change_pct["24h"]`), with 2,857 holders and $723,990 of liquidity. `launchpad: null`: it was deployed directly with a USDG pool. - Artificial Inu (`0x2e8c31162b855a2ffa90f6f8634643ad6f111e18`) is second: a Long.xyz token (`status: "launched"`) quoted in PONS, with 4,132 traders, $6.6 million of volume and 58,015 holders. - The NVIDIA stock token (`0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec`) traded $11,496,124, more than both, but ranks third: 3,519 traders. Trending counts wallets first, dollars second. - All three passed the quality checks, so none of them crashed 90% from its 24-hour peak, all have far more than 20 holders and $1,000 of liquidity. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Trending%20over%2024%20hours%3A%20a%20new%20meme%2C%20a%20Long.xyz%20token%20and%20NVIDIA&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-trending-tokens%2F%23trending-24h%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtrending%26window%3D24h%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Top gainers without filters are mostly tokens that went from nothing to slightly more than nothing, or pumps that are already being dumped. With `clean=true` they get the trending checks. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Top gainers over 24 hours, rugs filtered out Which Robinhood Chain tokens gained the most in 24 hours, leaving out rugs and wash-traded tokens? GET/v1/robinhood/tokens?list=top\_gainers&window=24h&clean=true&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=top_gainers&window=24h&clean=true&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_gainers&window=24h&clean=true&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=top_gainers&window=24h&clean=true&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x9f759111e492172d3881035db49777dd287574c2", "buy_volume_usd": { "1h": 0, "24h": 395674, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 1155, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 1709, "5m": 0, "6h": 0 }, "change_pct": { "1h": 0.404452, "24h": 15762.6, "5m": 0.404452, "6h": 0.404452 }, "created_block": 99773062, "created_ts": 1793159119200, "decimals": 18, "fdv_usd": 187681, "holders": 791, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 27364.5, "logo": null, "market_cap_usd": 187681, "name": "Robotaxi Coin", "price_eth": 0.0000000807115, "price_usd": 0.000190115, "progress_pct": null, "quote": "WETH", "sell_volume_usd": { "1h": 0, "24h": 381919, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 766, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 1434, "5m": 0, "6h": 0 }, "status": null, "symbol": "Robotaxi", "traders": { "1h": 0, "24h": 1155, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 3141, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 777593, "5m": 0, "6h": 0 } }, { "address": "0x75d874378ae31b33ab9e7a40b4dca96134221111", "buy_volume_usd": { "1h": 12561.1, "24h": 55083.9, "5m": 113.982, "6h": 55083.9 }, "buyers": { "1h": 71, "24h": 249, "5m": 5, "6h": 249 }, "buys": { "1h": 110, "24h": 510, "5m": 6, "6h": 510 }, "change_pct": { "1h": -0.916452, "24h": 3763.75, "5m": -7.67619, "6h": 3763.75 }, "created_block": 100316091, "created_ts": 1793215713100, "decimals": 18, "fdv_usd": 98207.5, "holders": 170, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/lobincoin", "website": "https://lobincoin.vercel.app/" }, "liquidity_usd": 28561.2, "logo": "https://api.crius.sh/v1/robinhood/logo/0x75d874378ae31b33ab9e7a40b4dca96134221111.png?size=128", "market_cap_usd": 98117.3, "name": "LOBIN", "price_eth": 0.0000000416931, "price_usd": 0.0000982075, "progress_pct": null, "quote": "ETH", "sell_volume_usd": { "1h": 12313.2, "24h": 40259.8, "5m": 979.897, "6h": 40259.8 }, "sellers": { "1h": 60, "24h": 146, "5m": 6, "6h": 146 }, "sells": { "1h": 85, "24h": 377, "5m": 6, "6h": 377 }, "status": null, "symbol": "LOBIN", "traders": { "1h": 101, "24h": 254, "5m": 10, "6h": 254 }, "txns": { "1h": 188, "24h": 880, "5m": 11, "6h": 880 }, "volume_usd": { "1h": 24874.3, "24h": 95343.7, "5m": 1093.88, "6h": 95343.7 } }, { "address": "0xf192dfffcc3bf99f48ed0602bb7c696b1ba8e7c0", "buy_volume_usd": { "1h": 7567.4, "24h": 432749, "5m": 2.985, "6h": 164497 }, "buyers": { "1h": 55, "24h": 1516, "5m": 1, "6h": 646 }, "buys": { "1h": 86, "24h": 3760, "5m": 1, "6h": 1562 }, "change_pct": { "1h": -7.51258, "24h": 2187.04, "5m": 0.0525215, "6h": -71.9046 }, "created_block": 100160899, "created_ts": 1793199599900, "decimals": 18, "fdv_usd": 126370, "holders": 467, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/PulseLaunchpad", "website": "https://www.pulsetoken.xyz/" }, "liquidity_usd": 41075, "logo": "https://api.crius.sh/v1/robinhood/logo/0xf192dfffcc3bf99f48ed0602bb7c696b1ba8e7c0.png?size=128", "market_cap_usd": 125404, "name": "Pulse", "price_eth": 0.0000000536492, "price_usd": 0.00012637, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 8839.7, "24h": 416296, "5m": 0, "6h": 192675 }, "sellers": { "1h": 58, "24h": 1463, "5m": 0, "6h": 781 }, "sells": { "1h": 67, "24h": 3303, "5m": 0, "6h": 1488 }, "status": null, "symbol": "PULSE", "traders": { "1h": 97, "24h": 1743, "5m": 1, "6h": 992 }, "txns": { "1h": 137, "24h": 6193, "5m": 1, "6h": 2548 }, "volume_usd": { "1h": 16407.1, "24h": 849045, "5m": 2.985, "6h": 357172 } } ], "meta": { "block": 100406916, "block_age_ms": 879, "block_ts": 1793225090000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 227, "list": "top_gainers", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Robotaxi Coin (`0x9f759111e492172d3881035db49777dd287574c2`) leads with `change_pct["24h"]: 15762.6`, 1,155 traders and 791 holders. Its `txns["1h"]` is 0: the whole move happened earlier in the day, and it has been quiet for the last hour. - LOBIN (`0x75d874378ae31b33ab9e7a40b4dca96134221111`) is up 3,763.75% with $28,561.2 of liquidity and 170 holders. - Pulse (`0xf192dfffcc3bf99f48ed0602bb7c696b1ba8e7c0`) is up 2,187.04% over 24 hours but down 71.9% over 6 hours (`change_pct["6h"]: -71.9046`). It still passes, because the crash rule is 90% below the window’s peak. Clean means “not rugged”, not “still going up”: read the shorter windows too. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Top%20gainers%20over%2024%20hours%2C%20rugs%20filtered%20out&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ffind-trending-tokens%2F%23clean-gainers%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtop_gainers%26window%3D24h%26clean%3Dtrue%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What makes a token trend A token is only listed in `trending` (or in any list with `clean=true`) when all of these hold for the chosen window: | Check | Rule | What it catches | | --- | --- | --- | | No crash | Price no more than 90% below its peak in the window | Rugs and dumps | | Liquidity | `liquidity_usd` of $1,000 or more | Dust markets that print any price | | Real holders | 20+ `holders`, and holders at least 10% of the window's `traders` | Wash trading spread over wallets that don't keep the token | | Fair launch | No insider launch (one wallet sniping 50%+ of supply in the first 10 blocks) and no wallet farm holding the supply | Insider dumps, as in the [security score](https://docs.crius.sh/guides/token-security-score/) `insider_launch` flag | | No bot distribution | Fewer than 25 of the top 100 holders with near-identical balances | Airdrops to controlled wallets | | Liquidity can't be pulled by one wallet | No single wallet holds 40%+ of the liquidity unlocked | Tokens one person can drain | Tokens that pass are ranked by traders × log10(volume). That is why NVIDIA, with the most volume in the sample, ranks below two tokens with more traders. The other lists rank differently: - `top_volume`: dollar volume in the window. Add `clean=true` for “volume leaders without rugs or wash trading”. - `top_gainers` / `top_losers`: price change in the window. They skip tokens with under $1,000 of liquidity unless you set `min_liquidity_usd` yourself. - All of them take the same filters as the other lists: `launchpad`, `quote`, `min_liquidity_usd`, `min_volume_usd`, `min_market_cap_usd`, `max_market_cap_usd`. ## Use it in your app 1. **Pick the window your users think in.** A trading terminal wants `5m` or `1h`; a daily digest wants `24h`. Without `window`, trending uses `1h`. 2. **Show the reason a token is there.** `traders`, `buyers` and `sellers` for the window explain the rank better than price change does. 3. **Add `clean=true` to every other list you show.** Gainers and volume leaders are where rugs and wash trading surface first. 4. **Refresh every few seconds, not every request.** Lists are recomputed continuously; one poller feeding your users is enough. ```python # Trending Robinhood Chain tokens over the last hour, with the numbers behind the rank. import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens", params={"list": "trending", "window": "1h", "limit": 10}, timeout=10, ) for t in r.json()["data"]: print( f"{t['symbol']:<10} {t['traders']['1h']:>5} traders " f"${t['volume_usd']['1h']:>12,.0f} {t['change_pct']['1h'] or 0:+.1f}% " f"{t['launchpad'] or 'direct'}" ) ``` Trending is not a safety check The quality checks remove the obvious traps, but they don’t simulate a sell or read the contract. Before a bot buys anything from this list, call [`/security`](https://docs.crius.sh/guides/token-security-score/) for the honeypot, tax and owner checks. ## Frequently asked questions **Which Robinhood Chain tokens are trending?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h` for the live answer. In the sample on this page the top three were Pizza (PIZZA) with 5,197 traders in 24 hours, Artificial Inu (AI, a Long.xyz token) with 4,132, and the NVIDIA stock token with 3,519. **How is trending ranked?** By the number of unique traders in the window, weighted by the logarithm of the window's volume. A token with many different wallets trading beats one with more dollars from fewer wallets, so a few whales or a wash-trading bot can't buy the top spot. **Why isn't a token with huge volume trending?** It failed one of the quality checks: its price fell more than 90% from its peak in the window, it has under $1,000 of liquidity, under 20 holders, fewer holders than 10% of its traders (wash trading), an insider launch or wallet farm, a bot-distributed supply, or one wallet holding 40%+ of the liquidity unlocked. Check it with `/security`. **What window does trending use?** `1h` when you don't pass one. Set `window` to `5m`, `1h`, `4h`, `6h` or `24h` (also `1s`, `30s`, `1m`); `meta.window` in the response confirms the one used. **What's the difference between trending, top\_volume and top\_gainers?** `trending` ranks by traders and always applies the quality checks. `top_volume` ranks by dollar volume and `top_gainers` by price change, and neither filters unless you add `clean=true`. ## Related [Guide **Find tokens by market cap** Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses. Read](https://docs.crius.sh/guides/find-tokens-by-market-cap/) [Guide **Find new tokens** List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Read](https://docs.crius.sh/guides/find-new-tokens/) [Guide **Token screener** Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code. Read](https://docs.crius.sh/guides/build-a-token-screener/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Token lists API** Lists: new, bonding, graduating, graduated, trending, top\_volume, top\_gainers, top\_losers, top\_market\_cap (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Read](https://docs.crius.sh/reference/discovery/token-lists/) --- # Get a token's all-time high and price change > Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change. Source: https://docs.crius.sh/guides/get-all-time-high-and-price-change/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}`. The `price` object has `ath_usd`, `ath_ts` (unix ms), `ath_market_cap_usd` and `ath_scope`, and `change_pct` for `1s`, `30s`, `1m`, `5m`, `1h`, `4h`, `6h` and `24h`. For longer periods, take daily candles (`/candles?interval=1d`) and compare closes. Both are on the anonymous plan. [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) Two questions every token page answers: how far is the price from its peak, and how much has it moved recently. The token profile carries both in its `price` object. `ath_usd` is the highest price the market held, with the time it was set and the market cap it implied, and `change_pct` gives the percentage change over eight windows from 1 second to 24 hours. For anything longer, daily candles fill the gap. ## Get the ATH and recent change in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### A fresh Pons token, 80% below a peak set the same evening How far is sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a) from its all-time high, and how has it moved today? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 319 lines (arrays trimmed)** ```json { "data": { "address": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bundles" }, "burned": 0, "chain_id": 4663, "circulating_supply": 1000000000, "creation": { "attribution": "known_launchpad", "block": 100193858, "deployed_via": "pons_v2", "deployer": "0x11a3fef7d8adbd78d36d9aaed4a7ba3a7beaa911", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "launchpad_name": "Pons", "tx": "0xd8ed9e0b091bcf1fcf3b0bb7d31b4165abaf42fa4fd5cb0d0bc56ffa7e18dde6" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793225005193, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1793203323421, "orders": [ { "payment_ts": 1793203323421, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": "Where agents build and trade on Robinhood Chain. Plug one in and let it run.", "header": "https://cdn.dexscreener.com/cms/images/mYazm5PF_nBhJs37?width=600&height=200&fit=crop&quality=95&format=auto", "icon": "https://cdn.dexscreener.com/cms/images/Fks_g91B2BrR_P4t?width=64&height=64&fit=crop&quality=95&format=auto", "links": [ { "label": "Website", "url": "https://socket.builders/" }, { "type": "twitter", "url": "https://x.com/poweredbysocket" } ] }, "url": "https://dexscreener.com/robinhood/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "first_seen_block": 100193858, "history": "complete", "holders": { "burned_pct": 0, "count": 523, "dev_holding": true, "dev_pct": 0.21319, "locked_pct": 8.16327, "top10_pct": 17.8434 }, "launch": { "creator": "0x11a3fef7d8adbd78d36d9aaed4a7ba3a7beaa911", "creator_label": null, "curve": "0xd362626da5a1ee6cd6a64774cadb8f8aeb7e2fa5", "curve_state": null, "graduated_block": 100213204, "graduation_threshold": 4.2, "launched_block": 100193858, "launchpad": "pons", "launchpad_name": "Pons", "pair_token": "0x0000000000000000000000000000000000000000", "progress_pct": 100, "raised": null, "status": "graduated" }, "liquidity": { "locked_pct": 100, "lockers": [ "pons_v2_launch_locker" ], "next_unlock_ts": null, "permanent": true, "status": "locked" }, "locked": 81632653.061224484575871987, "market": { "fdv_usd": 45488.4, "liquidity_usd": 19361.9, "market_cap_usd": 45488.4, "pools_count": 18, "quote_liquidity_usd": 9680.94 }, "metadata": { "banner": "https://cdn.dexscreener.com/cms/images/mYazm5PF_nBhJs37?width=600&height=200&fit=crop&quality=95&format=auto", "description": "Where agents build and trade on Robinhood Chain. Plug one in and let it run.", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/poweredbysocket/status/2115472554680791240?a=_i6sgGGYDCjSANAY-lQ&s=20", "website": "https://socket.builders/" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a.png?size=128", "logo_original": "https://ipfs.filebase.io/ipfs/bafkreig55u3h4g3qfzgexr7ag7mjvp6a2l3jsw4my7lyc4gyjiulxbpylm", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": { "source": "pons_launch", "url": "https://x.com/poweredbysocket/status/2115472554680791240?a=_i6sgGGYDCjSANAY-lQ&s=20" }, "website": { "source": "pons_launch", "url": "https://socket.builders/" } }, "source": "pons_launch", "sources": { "links": "pons_launch", "logo": "pons_launch" } }, "name": "sockets", "price": { "ath_market_cap_usd": 226336, "ath_scope": "all_time", "ath_ts": 1793215500000, "ath_usd": 0.000226336, "change_pct": { "1h": -56.2479, "1m": 0.0809595, "1s": -0.0376522, "24h": -5.58602, "30s": -0.131976, "4h": 10.4206, "5m": -9.7099, "6h": -5.58602 }, "confidence": "high", "dex": "uniswap_v4", "eth": 0.0000000193117, "liquidity_usd": 19166.7, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 9583.34, "source_pool": "0xe1cb1474a4c240a1e0bca5fb5c56f04a7d90789891fb59b68a142ca4071404e1", "thin_liquidity": false, "usd": 0.0000454884 }, "security": { "see": "/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 284074, "buys": 4327, "first_trade_ts": 1793202994000, "sell_volume_usd": 274803, "sells": 3658, "since": "chain_start", "trades": 7985, "volume_usd": 558877 }, "avg_trade_usd": { "1h": 91.6996, "1m": 33.6307, "1s": null, "24h": 69.9909, "30s": 16.733, "4h": 88.169, "5m": 52.8923, "6h": 70.1325 }, "buy_volume_usd": { "1h": 20861.7, "1m": 148.337, "1s": 0, "24h": 284074, "30s": 0, "4h": 124241, "5m": 717.821, "6h": 263844 }, "buyers": { "1h": 163, "1m": 2, "1s": 0, "24h": 1900, "30s": 0, "4h": 712, "5m": 12, "6h": 1766 }, "buys": { "1h": 288, "1m": 2, "1s": 0, "24h": 4327, "30s": 0, "4h": 1549, "5m": 14, "6h": 4083 }, "last_trade_ts": 1793225076000, "sell_volume_usd": { "1h": 26363.6, "1m": 154.34, "1s": 0, "24h": 274803, "30s": 50.1989, "4h": 125895, "5m": 1133.41, "6h": 262500 }, "sellers": { "1h": 166, "1m": 7, "1s": 0, "24h": 1630, "30s": 3, "4h": 696, "5m": 17, "6h": 1593 }, "sells": { "1h": 227, "1m": 7, "1s": 0, "24h": 3658, "30s": 3, "4h": 1288, "5m": 21, "6h": 3422 }, "traders": { "1h": 245, "1m": 9, "1s": 0, "24h": 1919, "30s": 3, "4h": 888, "5m": 28, "6h": 1875 }, "trades": { "1h": 515, "1m": 9, "1s": 0, "24h": 7985, "30s": 3, "4h": 2837, "5m": 35, "6h": 7505 }, "txns": { "1h": 478, "1m": 9, "1s": 0, "24h": 7784, "30s": 3, "4h": 2717, "5m": 33, "6h": 7320 }, "volume_eth": { "1h": 20.0153, "1m": 0.128499, "1s": 0, "24h": 238.61, "30s": 0.0213115, "4h": 106.161, "5m": 0.784249, "6h": 224.652 }, "volume_usd": { "1h": 47225.3, "1m": 302.677, "1s": 0, "24h": 558877, "30s": 50.1989, "4h": 250135, "5m": 1851.23, "6h": 526344 } }, "symbol": "sockets", "total_supply": 1000000000, "type": "launchpad", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": null, "sourcify": null } }, "meta": { "block": 100406844, "block_age_ms": 1014, "block_ts": 1793225082000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 92, "pending": [], "safe_block": 100401329 } } ``` What this tells you - `price.ath_usd: 0.000226336`, set at `ath_ts: 1793215500000` (19:25 UTC on October 28, 2026). At that price the token was worth `ath_market_cap_usd: 226336`. - `price.usd` is 0.0000454884, so it trades 79.9% below its ATH (0.0000454884 ÷ 0.000226336 − 1). - `change_pct` tells the story of the day: `4h` is +10.4206 but `1h` is −56.2479. The token ran up, then lost more than half its price in the last hour. `5m` is −9.7099, so the fall hadn’t stopped. - `24h` and `6h` are the same, −5.58602: the token’s first trade was at `stats.all_time.first_trade_ts` 1793202994000, a little over six hours before this response, so both windows start from the same early price. - `ath_scope: "all_time"`: the ATH covers the token’s whole history. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20fresh%20Pons%20token%2C%2080%25%20below%20a%20peak%20set%20the%20same%20evening&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-all-time-high-and-price-change%2F%23sockets-ath%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/ohlcv-candles/) ### Seven days of decline, from daily candles How much has Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) moved over the past week? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/candles?interval=1d&limit=7 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/candles?interval=1d&limit=7" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/candles?interval=1d&limit=7"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/candles?interval=1d&limit=7", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 103 lines (arrays trimmed)** ```json { "data": { "bv": [ 127.848, 209.025, 29.3536, 25.2536, 74.2036, 0, 0 ], "c": [ 0.00000577044, 0.00000550534, 0.00000463439, 0.00000442385, 0.0000040974, 0.00000384983, 0.00000385494 ], "currency": "usd", "h": [ 0.00000672467, 0.00000577207, 0.00000557101, 0.00000463439, 0.00000442385, 0.0000040974, 0.00000389618 ], "interval": "1d", "l": [ 0.00000575059, 0.00000502958, 0.00000463439, 0.00000442385, 0.0000040974, 0.00000384983, 0.00000384983 ], "mc": [ 5770.44, 5505.34, 4634.39, 4423.85, 4097.4, 3849.83, 3854.94 ], "n": [ 14, 13, 11, 6, 13, 4, 2 ], "o": [ 0.000006348, 0.00000577044, 0.00000550534, 0.00000463439, 0.00000442385, 0.0000040974, 0.00000384983 ], "t": [ 1792627200000, 1792713600000, 1792800000000, 1792886400000, 1792972800000, 1793059200000, 1793145600000 ], "v": [ 350.792, 486.44, 316.039, 114.294, 283.74, 57.6385, 5.92732 ] }, "meta": { "block": 100409999, "block_age_ms": 971, "block_ts": 1793225405000, "chain": "robinhood", "finalized_block": 100401329, "from_ts": 1792627200000, "lag_ms": 1, "note": "default (usd) = the token's real markets merged plus its launch curve; ?pool=main its main market only (the default with currency=quote), ?pool= one pool, ?pool=all every pool. Candles open at the previous close (?continuous=false for first-trade opens); buckets without trades are omitted unless ?fill=true", "pools": [ "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3" ], "safe_block": 100405028, "to_ts": 1793225405000 } } ``` What this tells you - Seven daily candles from October 22 to October 28, 2026 (`t` 1792627200000 to 1793145600000). - The week opened at `o[0]` 0.000006348 and the latest close is `c[6]` 0.00000385494: a 7-day change of −39.3%. - Every day but the last closed below the day before, and the market cap at close (`mc`) went from 5,770.44 to 3,854.94. - The token is quiet: the last candle has `n[6]` 2 trades and `v[6]` $5.92732, and the last two candles had no buys at all (`bv` 0), only sells. - In CHARGE’s token profile, `price.ath_usd` is 0.0000707881 (set on October 15, 2026), so the token is about 94.5% below its ATH. [OHLCV candles reference](https://docs.crius.sh/reference/trades/ohlcv-candles/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Seven%20days%20of%20decline%2C%20from%20daily%20candles&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-all-time-high-and-price-change%2F%23charge-7d%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fcandles%3Finterval%3D1d%26limit%3D7%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `price.ath_usd` | The highest confirmed price, in USD. Never below the current price. | | `price.ath_ts` | When it was set (unix ms). | | `price.ath_market_cap_usd` | `ath_usd` × the current circulating supply. | | `price.ath_scope` | `all_time` when the index covers the chain from block 0, `since_index_start` otherwise. | | `price.change_pct.` | Change in percent, for `1s`, `30s`, `1m`, `5m`, `1h`, `4h`, `6h` and `24h`. `null` when there's no baseline price. | | `change_24h_pct` | In [batch prices](https://docs.crius.sh/guides/get-prices-for-many-tokens/): the same 24h change for up to 100 tokens per call. | ## How the ATH and changes are measured **The all-time high is a price the market held.** A token’s trades are grouped into 5-minute buckets. Each bucket’s price is the value-weighted median of its trades of $1 or more, so one trade at a wild price doesn’t decide it. A bucket counts on its own when its volume reaches 0.1% of the token’s busiest day (at least $100); a thinner bucket needs the bucket next to it to confirm the level. The ATH is the highest bucket that qualifies, and is never shown below the current price: if the token is at a new high right now, `ath_usd` is the current price. **Changes compare the current price with a baseline.** For each window, the baseline is the last trade before the window started, or the first trade inside it if the token is younger than the window. Both the current price and the baseline come from the token’s main market. **Longer periods come from candles.** Daily candles open at the previous close by default, so `c` of the latest candle divided by `o` of the first gives the change over the whole range. ## Use it in your app 1. **Read the profile once per page view** and show “x% below ATH” with the date from `ath_ts`. 2. **Show the windows that matter to your users.** Traders look at `5m` and `1h`; a portfolio app shows `24h`. 3. **Add 7d and 30d from daily candles**, cached for a few minutes: they change slowly. 4. **Use batch prices for lists.** `change_24h_pct` for 100 tokens in one call is cheaper than 100 profiles. ```js // ATH distance, 24h change and 7-day change for one token. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const base = "https://api.crius.sh/v1/robinhood"; const { data: t } = await (await fetch(`${base}/token/${token}`)).json(); const { data: d } = await (await fetch(`${base}/token/${token}/candles?interval=1d&limit=7`)).json(); const belowAth = (t.price.usd / t.price.ath_usd - 1) * 100; const change7d = (d.c.at(-1) / d.o[0] - 1) * 100; console.log(`${t.symbol}: ${belowAth.toFixed(1)}% vs ATH (set ${new Date(t.price.ath_ts).toISOString().slice(0, 10)})`); console.log(`24h ${t.price.change_pct["24h"]?.toFixed(2)}%, 7d ${change7d.toFixed(1)}%`); ``` Alert on new highs Polling profiles to spot new ATHs gets expensive across many tokens. Subscribe to trades over the WebSocket and compare each price with the `ath_usd` you stored: see [Build price alerts](https://docs.crius.sh/guides/build-price-alerts/). ## Frequently asked questions **How do I get the all-time high of a Robinhood Chain token?** Call `GET /v1/robinhood/token/{address}` and read `price.ath_usd` (the highest price), `price.ath_ts` (when, in unix ms) and `price.ath_market_cap_usd`. No API key is needed. **Why is the all-time high lower than the highest wick on the chart?** The ATH is a price the market actually held, not one trade. Crius takes the value-weighted median price of each 5-minute bucket, from trades of $1 or more, and a bucket only counts when it has enough volume for that token; a thin bucket needs the next one to confirm it. A single trade that spiked the price for a moment doesn't set the ATH. **How is the 24-hour price change calculated?** The current price against the price of the last trade before the window started. If the token is younger than the window, the first trade inside it is the baseline. Changes come from the token's main market, so trades in thin side pools don't move them. **How do I get the 7-day or 30-day price change?** `change_pct` stops at 24 hours. For longer windows, request daily candles (`/candles?interval=1d&limit=30`) and compare the latest close with the open or close of the first day you want. **Does the all-time high cover the token's whole history?** Yes when `ath_scope` is `all_time`: the index covers Robinhood Chain from block 0. If an index started later it says `since_index_start`, and the ATH only covers what was indexed. ## Related [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Market cap, FDV and supply** Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed. Read](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) [Guide **Price alerts** Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Read](https://docs.crius.sh/guides/build-price-alerts/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [API reference **Token profile API** Full profile of any ERC-20 on the chain: name, symbol, decimals, supply (total, burned, locked, circulating), creation and launchpad lifecycle, metadata and socials (with their source), price with cha Read](https://docs.crius.sh/reference/tokens/token-profile/) --- # Get a token's holders at a past block, time or market cap > Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder. Source: https://docs.crius.sh/guides/get-historical-holders/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/holders/snapshot?at=…` (Free plan, 5 credits). `at` takes `block:N`, `ts:MS`, `mcap:USD` or a label (`launch`, `graduation`, `ath`, `now`). It returns the holders at that block with `balance`, `pct`, `value_usd` at that moment's price, `cost_basis_usd`, `unrealized_pnl_usd` and `tags`; `compare_to=now` adds each holder's change since. [GET `/token/{address}/holders/snapshot`](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET `/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) [GET `/token/{address}/holders/cohort`](https://docs.crius.sh/reference/holders/holder-cohort/) A holder snapshot is the list of a token’s holders as it was at one moment in the past: a block, a time, the block where the market cap first crossed a level, or a lifecycle event such as graduation. Crius rebuilds every balance at that block from the token’s full transfer history and values it at the price of that moment, so you can answer “who held this before $50k?” or “what did the top of the list look like a week ago?” in one call. ## Choose the point in time `at` (and `from` / `to` on the cohort and history endpoints) accepts several forms: | Form | Meaning | | --- | --- | | `block:95000000` | an exact L2 block | | `ts:1792000000000` | the last block at or before that time (unix ms) | | `mcap:50000` | the block where market cap first crossed $50k (`mcap_crossing=first` or `last`) | | `launch`, `graduation`, `ath`, `now` | lifecycle labels | A point that never happened for the token (a market cap it never reached, `graduation` for a token that didn’t graduate) returns `404 point_not_found`; one that can’t be parsed returns `400 invalid_at`. See [Errors](https://docs.crius.sh/errors/). ## Get the holders one week ago Example [Free plan · 5 credits](https://docs.crius.sh/reference/holders/holder-snapshot/) ### CHARGE holders one week before capture: 203 holders, $6,033 total Who held Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) on 2026-10-21 at 22:04 UTC, and were they in profit? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=ts:1792620279327&limit=5 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=ts:1792620279327&limit=5" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=ts:1792620279327&limit=5", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=ts:1792620279327&limit=5", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 106 lines (arrays trimmed)** ```json { "data": { "distribution": { "top10_ex_infra_pct": 20.2394, "top10_incl_infra_pct": 88.256, "top10_pct": 20.2394 }, "history": "complete", "holders": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "balance": 599611856.72294939695548577, "cost_basis_usd": null, "label": "uniswap_v4_pool_manager", "pct": 59.9612, "rank": 1, "tags": [ "pool" ], "unrealized_pnl_usd": null, "value_eth": 1.4505, "value_usd": 3617.23 }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "balance": 81632653.061224486519511236, "cost_basis_usd": null, "label": "pons_v2_launch_locker", "pct": 8.16327, "rank": 2, "tags": [ "lp_locker" ], "unrealized_pnl_usd": null, "value_eth": 0.197474, "value_usd": 492.459 }, { "address": "0xcae68632857541d7b625f5af57149a77c80b15f7", "balance": 40394446.124537182821971423, "cost_basis_usd": 437.688, "label": null, "pct": 4.03944, "rank": 3, "tags": [ "smart_account", "fomo" ], "unrealized_pnl_usd": -194.003, "value_eth": 0.0977165, "value_usd": 243.684 }, { "address": "0xe683eb5c66b0c55c54ce45d46a3bf0a69d809c8f", "balance": 29879481.370714222341354462, "cost_basis_usd": 515.975, "label": null, "pct": 2.98795, "rank": 4, "tags": [ "smart_account" ], "unrealized_pnl_usd": -335.724, "value_eth": 0.0722802, "value_usd": 180.252 }, { "address": "0x000000000000000000000000000000000000dead", "balance": 29840058.774195638068253872, "cost_basis_usd": null, "label": "burn", "pct": 2.98401, "rank": 5, "tags": [ "burn" ], "unrealized_pnl_usd": null, "value_eth": 0.0721848, "value_usd": 180.014 } ], "holders_count": 203, "price_at_snapshot": { "eth": 0.00000000241906, "eth_usd": 2493.79, "usd": 0.00000603262 }, "snapshot": { "at": "ts:1792620279327", "block": 94616288, "ts": 1792620279800 }, "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "total_value_usd": 6032.62 }, "meta": { "block": 100406812, "block_age_ms": 701, "block_ts": 1793225079000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 38, "next_cursor": "5", "safe_block": 100401329 } } ``` What this tells you - `snapshot.at: "ts:1792620279327"` resolved to `snapshot.block: 94616288` (`snapshot.ts: 1792620279800`), the last block at or before that time. - `price_at_snapshot.usd` was 0.00000603262 with ETH at `eth_usd: 2493.79`. At that price every token held was worth `total_value_usd: 6032.62`. - `holders_count: 203` then, against 178 in the [live list](https://docs.crius.sh/guides/get-token-holders/#charge-holders) a week later. - `distribution.top10_pct: 20.2394` (the same as `top10_ex_infra_pct`) versus `top10_incl_infra_pct: 88.256`: counting the pool, the locker and the burn address would make the token look nearly 90% concentrated. - Rank 3, `0xcae68632857541d7b625f5af57149a77c80b15f7`, is tagged `smart_account` and `fomo` (a FOMO app wallet). It held 4.03944% worth $243.684 against a `cost_basis_usd` of 437.688: `unrealized_pnl_usd: -194.003` at that moment. - Infrastructure has `cost_basis_usd: null` and `unrealized_pnl_usd: null`: the PoolManager (`tags: ["pool"]`, 59.9612% then) never bought anything. - `meta.next_cursor: "5"`: pass `cursor=5` for the next page. [Holder snapshot reference](https://docs.crius.sh/reference/holders/holder-snapshot/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE%20holders%20one%20week%20before%20capture%3A%20203%20holders%2C%20%246%2C033%20total&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-historical-holders%2F%23snapshot-one-week%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%2Fsnapshot%3Fat%3Dts%3A1792620279327%26limit%3D5%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `snapshot.at`, `block`, `ts` | What you asked for, and the block and timestamp it resolved to. | | `price_at_snapshot.usd`, `eth`, `eth_usd` | The token's price at that block and the ETH/USD rate used for `value_eth`. | | `holders_count` | Addresses with a balance at that block. | | `total_value_usd` | Every balance at that block valued at `price_at_snapshot.usd`. | | `distribution.top10_pct` | Top-10 share without infrastructure (same as `top10_ex_infra_pct`). | | `distribution.top10_incl_infra_pct` | Top-10 share counting pools, lockers and burn addresses. | | `holders[].balance`, `pct`, `rank` | Balance, share of supply and rank at that block. | | `holders[].value_usd`, `value_eth` | The balance valued at that moment's price. | | `holders[].cost_basis_usd` | What the holder paid for that balance: its average buy price from trades up to the snapshot, times the balance. `null` when it never bought (infrastructure, tokens received by transfer). | | `holders[].unrealized_pnl_usd` | `value_usd` minus `cost_basis_usd` at that moment. | | `holders[].tags`, `label` | Wallet tags (`pool`, `lp_locker`, `burn`, `smart_account`, `fomo`…) and the known name of the address. | | `history` | `complete` when the token's whole transfer history is indexed. | Filters: `exclude=infra` drops pools, lockers and burn addresses from the list, `tag` keeps only holders with one tag (for example `tag=smart_account`), and `min_usd` / `min_pct` hide small holders. `limit` takes up to 500 per page. ## Compare then and now `compare_to=now` adds each holder’s balance change between the snapshot and now. It answers the question traders ask most: of the wallets that held at a given point, who is still in? You can also compare two past points, for example `at=launch&compare_to=graduation`. A quick read of the example without `compare_to`: `0xcae68632857541d7b625f5af57149a77c80b15f7` held 4.04% a week before capture. In the live wallets-only list a week later, the fifth-largest holder has 1.22147% and that wallet isn’t in the top five. So it now holds under 1.23%: it sold or moved more than two thirds of its position. `compare_to=now` would give the exact change instead of this inference. ## Use it in your app 1. **Pick the point in the form your users think in.** A chart click gives you a timestamp (`ts:`), a “before the pump” filter gives a market cap (`mcap:`), and “launch buyers” maps to `launch`. Read back `snapshot.block` to show what the point resolved to. 2. **Leave infrastructure out.** Add `exclude=infra` unless you want the pool and locker rows; `top10_pct` already excludes them either way. 3. **Show profit at that moment.** `cost_basis_usd` and `unrealized_pnl_usd` tell you who was in profit at the snapshot, which is often more useful than who was big. 4. **Budget for it.** Each call costs 5 credits on the Free plan or higher. A past snapshot never changes, so cache it by token and `snapshot.block`. ```python import os, requests token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" r = requests.get( f"https://api.crius.sh/v1/robinhood/token/{token}/holders/snapshot", params={"at": "mcap:50000", "exclude": "infra", "limit": 50}, headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) d = r.json()["data"] print(f"block {d['snapshot']['block']}: {d['holders_count']} holders, price ${d['price_at_snapshot']['usd']}") for h in d["holders"]: pnl = h["unrealized_pnl_usd"] print(h["rank"], h["address"], f"{h['pct']}%", "in profit" if pnl and pnl > 0 else "", h["tags"]) ``` Large tokens A past snapshot replays every transfer of the token. Tokens with more than 2M transfers (WETH, USDG, tokenized stocks) return `400 window_too_large` for past points; use `at=now` or the live [`/holders`](https://docs.crius.sh/reference/holders/live-holders/) list for them. ## Frequently asked questions **How do I see who held a token before it pumped?** Take a snapshot at the market cap before the run: `/holders/snapshot?at=mcap:50000&compare_to=now&exclude=infra`. `mcap:50000` resolves to the block where the market cap first crossed $50k, and `compare_to=now` shows, for each of those holders, how their balance changed since. **What does \`ts:\` resolve to?** The last block at or before that time, in unix milliseconds. In the example, `ts:1792620279327` resolved to block 94616288, whose timestamp is 1792620279800. The resolved block and its time are returned in `snapshot.block` and `snapshot.ts`, so you always know exactly which state you got. **Is the USD value historical or current?** Historical. `value_usd` and `total_value_usd` use the token's price at the snapshot block (`price_at_snapshot.usd`, from the last trade of $1 or more at or before it), and `value_eth` uses that moment's ETH/USD (`price_at_snapshot.eth_usd`). **Can I take a snapshot of WETH or USDG?** Not at a past block. A snapshot replays every transfer of the token up to that point, and tokens with more than 2M transfers (WETH, USDG, tokenized stocks) return `400 window_too_large`. `at=now` still works for them, as does the live [`/holders`](https://docs.crius.sh/reference/holders/live-holders/) list. **Which plan does the holder snapshot need?** The Free plan (a free API key), 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Guide **Diamond-hand holders** Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example. Read](https://docs.crius.sh/guides/find-diamond-hand-holders/) [Guide **Holder count history** Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example. Read](https://docs.crius.sh/guides/track-holder-count/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [API reference **Holder snapshot API** Holders as they were at a past point, valued at that moment's price. Read](https://docs.crius.sh/reference/holders/holder-snapshot/) --- # Get Robinhood Chain launchpad stats (launches, graduations, volume) > Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Source: https://docs.crius.sh/guides/get-launchpad-stats/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/launchpads` for every launchpad with `tokens_launched`, `graduated`, `graduation_rate_pct`, `median_blocks_to_graduate` and 24-hour launches, trades, traders, volume (split by quote currency) and fees. `GET /v1/robinhood/launchpads/{id}?days=30` adds a daily history and the top 10 tokens by 24h volume. Anonymous plan, 1 credit. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) The launchpads endpoint is a scoreboard for every Robinhood Chain launchpad Crius attributes: how many tokens each has launched, how many graduated and how fast, and what its tokens did in the last 24 hours (launches, trades, traders, volume by quote currency, fees). The per-launchpad call adds a daily history for up to 90 days and the ten tokens with the most 24-hour volume. ## Compare every launchpad in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/launchpads/launchpads/) ### Pons, Flap.sh and Bankr side by side How do Robinhood Chain launchpads compare on launches, graduations and volume? GET/v1/robinhood/launchpads **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 122 lines (arrays trimmed)** ```json { "data": [ { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 109888, "tax": 139840, "total": 249728 }, "graduated": 10479, "graduated_24h": 16, "graduation_rate_pct": 1.46306, "launches_24h": 1781, "median_blocks_to_graduate": 2490, "tokens_launched": 716241, "traders_24h": 54793, "trades_24h": 282607, "volume_by_quote_usd_24h": { "eth": 13311920, "other": 1629236, "stock": 3076503, "usdg": 7488610 }, "volume_usd_24h": 25506268 }, "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, { "contracts": { "launch_contracts": [ "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" ] }, "id": "flap", "name": "Flap.sh", "since_block": 4227932, "stats": { "fees_usd_24h": { "lp": 2011.32, "tax": 7332.7, "total": 9344.02 }, "graduated": 338, "graduated_24h": 1, "graduation_rate_pct": 0.0872587, "launches_24h": 1200, "median_blocks_to_graduate": 8533, "tokens_launched": 387354, "traders_24h": 3257, "trades_24h": 7870, "volume_by_quote_usd_24h": { "eth": 364111, "other": 16.2147, "stock": 5051.86, "usdg": 11553.7 }, "volume_usd_24h": 380733 }, "type": "config_driven", "website": "https://flap.sh" }, { "contracts": { "launch_contracts": [ "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" ] }, "id": "bankr", "name": "Bankr", "since_block": 1565844, "stats": { "fees_usd_24h": { "lp": 5006.22, "tax": 12930.7, "total": 17937 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 20, "median_blocks_to_graduate": null, "tokens_launched": 98672, "traders_24h": 1966, "trades_24h": 7282, "volume_by_quote_usd_24h": { "eth": 220967, "other": 25109.3, "stock": 262823, "usdg": 86535.8 }, "volume_usd_24h": 595435 }, "type": "config_driven", "website": "https://bankr.bot" } ], "meta": { "block": 100406698, "block_age_ms": 1356, "block_ts": 1793225067000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 202, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100401329 } } ``` What this tells you - Pons has `tokens_launched: 716241`, `graduated: 10479` and `graduation_rate_pct: 1.46306`. In 24 hours it had 1,781 launches, 16 graduations, 54,793 traders and `volume_usd_24h: 25506268`. - Pons volume by quote (`volume_by_quote_usd_24h`): $13.3 million against ETH, $7.5 million against USDG, $3.1 million against stock tokens and $1.6 million against other tokens. Close to half of Pons trading is not in ETH. - Flap.sh launched 1,200 tokens in 24 hours, nearly as many as Pons, but traded $380,733. Its `median_blocks_to_graduate` is 8,533 (about 14 minutes at ~100 ms blocks) against Pons’s 2,490 (about 4 minutes). - Bankr has `graduated: 0` and `median_blocks_to_graduate: null`: its tokens trade on Uniswap v4 from the first block and have nothing to graduate from. - `fees_usd_24h` splits fees into `lp` (LP fees) and `tax` (token and hook taxes measured from trades): $109,888 and $139,840 for Pons. - The sample is trimmed to three launchpads; the live response lists all six. [Launchpads reference](https://docs.crius.sh/reference/launchpads/launchpads/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Pons%2C%20Flap.sh%20and%20Bankr%20side%20by%20side&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-launchpad-stats%2F%23all-launchpads%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) All six, from each launchpad’s own response (`/launchpads/{id}?days=3`, captured minutes after the list above): | Launchpad | `id` | Launched | Graduated | Rate | Median blocks to graduate | Launches 24h | Volume 24h | | --- | --- | --- | --- | --- | --- | --- | --- | | [Pons](https://docs.crius.sh/launchpads/pons/) | `pons` | 716,247 | 10,480 | 1.46% | 2,491 | 1,781 | $25,862,841 | | [Long.xyz](https://docs.crius.sh/launchpads/long/) | `long` | 83,664 | 0 (no curve) | 0% | `null` | 505 | $10,785,197 | | [Bankr](https://docs.crius.sh/launchpads/bankr/) | `bankr` | 98,672 | 0 (no curve) | 0% | `null` | 20 | $596,260 | | [Flap.sh](https://docs.crius.sh/launchpads/flap/) | `flap` | 387,360 | 338 | 0.087% | 8,533 | 1,200 | $384,200 | | [Flywheel](https://docs.crius.sh/launchpads/flywheel/) | `flywheel` | 1,352 | 23 | 1.70% | 25,108 | 17 | $333,576 | | [King of the Markets](https://docs.crius.sh/launchpads/standard-reserve/) | `standard_reserve` | 2,193 | 22 | 1.00% | 2,835 | 1 | $104,674 | ## One launchpad over time Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Pons: daily history and top tokens How has Pons activity changed over the last 30 days, and which Pons tokens trade the most? GET/v1/robinhood/launchpads/pons **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/pons" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/pons"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/pons", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 350 lines (arrays trimmed)** ```json { "data": { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "history": { "days": 30, "points": [ { "date": "2026-09-29", "fees_usd": 1074278, "graduated": 114, "launches": 7338, "traders": 112239, "trades": 1067936, "volume_usd": 115862267 }, { "date": "2026-09-30", "fees_usd": 1089177, "graduated": 81, "launches": 6931, "traders": 111122, "trades": 998526, "volume_usd": 110420305 }, { "date": "2026-10-01", "fees_usd": 864962, "graduated": 56, "launches": 6854, "traders": 104155, "trades": 882190, "volume_usd": 90071904 } ] }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 109888, "tax": 139840, "total": 249728 }, "graduated": 10479, "graduated_24h": 16, "graduation_rate_pct": 1.46306, "launches_24h": 1781, "median_blocks_to_graduate": 2490, "tokens_launched": 716241, "traders_24h": 54793, "trades_24h": 282607, "volume_by_quote_usd_24h": { "eth": 13311920, "other": 1629236, "stock": 3076503, "usdg": 7488610 }, "volume_usd_24h": 25506268 }, "top_tokens_24h": [ { "address": "0xedbf91223639800bcd5756815caf908df3b890be", "buy_volume_usd": { "1h": 15830.9, "24h": 1500592, "5m": 3096.86, "6h": 512728 }, "buyers": { "1h": 56, "24h": 1899, "5m": 6, "6h": 741 }, "buys": { "1h": 87, "24h": 4648, "5m": 8, "6h": 1460 }, "change_pct": { "1h": -4.63632, "24h": 68.9098, "5m": -0.377007, "6h": 11.257 }, "created_block": 67325240, "created_ts": 1789845345000, "decimals": 18, "fdv_usd": 14150141, "holders": 4820, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/priors_trade", "website": "https://priors.trade/" }, "liquidity_usd": 950215, "logo": "https://api.crius.sh/v1/robinhood/logo/0xedbf91223639800bcd5756815caf908df3b890be.png?size=128", "market_cap_usd": 14150130, "name": "Priors Agents", "price_eth": 0.00000600731, "price_usd": 0.0141501, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 34341, "24h": 1399930, "5m": 1424.24, "6h": 482954 }, "sellers": { "1h": 77, "24h": 1885, "5m": 7, "6h": 756 }, "sells": { "1h": 131, "24h": 4983, "5m": 7, "6h": 1541 }, "status": "graduated", "symbol": "PRIORS", "traders": { "1h": 123, "24h": 2575, "5m": 13, "6h": 1056 }, "txns": { "1h": 166, "24h": 7128, "5m": 13, "6h": 2099 }, "volume_usd": { "1h": 50171.9, "24h": 2900521, "5m": 4521.11, "6h": 995683 } }, { "address": "0x94641b97010608c3827fb058074889f19868ff33", "buy_volume_usd": { "1h": 15428.5, "24h": 529088, "5m": 522.14, "6h": 86964.5 }, "buyers": { "1h": 48, "24h": 1374, "5m": 2, "6h": 231 }, "buys": { "1h": 96, "24h": 3350, "5m": 5, "6h": 619 }, "change_pct": { "1h": 5.0763, "24h": 27.4122, "5m": -2.06883, "6h": 10.1491 }, "created_block": 76051465, "created_ts": 1790724560500, "decimals": 18, "fdv_usd": 4999575, "holders": 7136, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/VraxVerify", "twitter": "https://x.com/RobinhoodApp/status/2105077426481222125", "website": "https://vraxthecommander.cat/" }, "liquidity_usd": 588651, "logo": "https://api.crius.sh/v1/robinhood/logo/0x94641b97010608c3827fb058074889f19868ff33.png?size=128", "market_cap_usd": 4999474, "name": "Commander Vrax", "price_eth": 0.00000212252, "price_usd": 0.00499957, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 11405.5, "24h": 479298, "5m": 932.723, "6h": 68311.5 }, "sellers": { "1h": 75, "24h": 1267, "5m": 5, "6h": 271 }, "sells": { "1h": 124, "24h": 3181, "5m": 8, "6h": 579 }, "status": "graduated", "symbol": "VRAX", "traders": { "1h": 101, "24h": 1864, "5m": 7, "6h": 405 }, "txns": { "1h": 126, "24h": 3835, "5m": 8, "6h": 624 }, "volume_usd": { "1h": 26834, "24h": 1008386, "5m": 1454.86, "6h": 155276 } }, { "address": "0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725", "buy_volume_usd": { "1h": 12125.4, "24h": 501001, "5m": 1197.63, "6h": 68293.2 }, "buyers": { "1h": 62, "24h": 1263, "5m": 7, "6h": 228 }, "buys": { "1h": 113, "24h": 3156, "5m": 13, "6h": 441 }, "change_pct": { "1h": 1.06701, "24h": 47.7982, "5m": 0.24043, "6h": -3.95272 }, "created_block": 47404695, "created_ts": 1787829863500, "decimals": 18, "fdv_usd": 7826578, "holders": 19015, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/MicroDuckNVDA", "website": "https://microduck.net/" }, "liquidity_usd": 641268, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725.png?size=128", "market_cap_usd": 7826568, "name": "microduck", "price_eth": 0.0000033227, "price_usd": 0.00782658, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 12482.3, "24h": 446200, "5m": 3118.41, "6h": 75926.1 }, "sellers": { "1h": 31, "24h": 1041, "5m": 7, "6h": 249 }, "sells": { "1h": 57, "24h": 2747, "5m": 10, "6h": 541 }, "status": "graduated", "symbol": "microduck", "traders": { "1h": 85, "24h": 1782, "5m": 14, "6h": 405 }, "txns": { "1h": 121, "24h": 4305, "5m": 18, "6h": 699 }, "volume_usd": { "1h": 24607.7, "24h": 947201, "5m": 4316.05, "6h": 144219 } } ], "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, "meta": { "block": 100406942, "block_age_ms": 1644, "block_ts": 1793225092000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 199, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100401329 } } ``` What this tells you - `history.days: 30` and one entry in `history.points` per UTC day with `launches`, `graduated`, `trades`, `traders`, `volume_usd` and `fees_usd`. The sample keeps the first three days. - On 2026-09-29 Pons had 7,338 launches, 114 graduations, 112,239 traders and $115,862,267 of volume. The 24-hour `stats` in the same response show 1,781 launches and $25.5 million: activity a month later was about a fifth of that day’s. - `top_tokens_24h` are full token-list rows. The top three, Priors Agents (`0xedbf91223639800bcd5756815caf908df3b890be`, $2,900,521), Commander Vrax (`0x94641b97010608c3827fb058074889f19868ff33`, $1,008,386) and microduck (`0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725`, $947,201), are all graduated and quoted in USDG. - `contracts` lists the launchpad’s contracts (factory, hook, LP locker, fee escrow, buyback vault, launch-and-buy helper); `since_block: 27027321` is where Crius starts counting. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Pons%3A%20daily%20history%20and%20top%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-launchpad-stats%2F%23one-launchpad%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fpons%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `tokens_launched`, `graduated` | Lifetime launches and graduations since `since_block` | | `graduation_rate_pct` | `graduated` ÷ `tokens_launched`, in percent | | `median_blocks_to_graduate` | Median L2 blocks from launch to graduation, over tokens that graduated; `null` with no graduations | | `launches_24h`, `graduated_24h` | Launches and graduations in the last 24 hours | | `trades_24h`, `traders_24h`, `volume_usd_24h` | Every trade of the launchpad's tokens in any pool, before and after graduation | | `volume_by_quote_usd_24h` | The same volume by what it traded against: `eth`, `usdg`, `stock` (tokenized stocks), `other` | | `fees_usd_24h` | `lp` (LP fees at each pool's fee; on v4, each swap's own fee), `tax` (token and hook taxes measured from trades), `total` | | `type` | `bonding_curve_to_v4` for Pons; `config_driven` for launchpads Crius reads from their launch and graduation events | | `history.points[]` | Per UTC day: `launches`, `graduated`, `trades`, `traders`, `volume_usd`, `fees_usd` (per-launchpad call only; `days` 1–90, default 30) | | `top_tokens_24h[]` | The 10 tokens with the most 24-hour volume, as token-list rows (per-launchpad call only) | Taxes not counted yet `fees_usd_24h.tax` doesn’t include taxes a hook takes in the quote currency on sells; those aren’t measured yet (`meta.notes` says so). For one token’s full fee breakdown, see [Get a token’s fees and creator rewards](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/). ## Use it in your app 1. **Use the list for a leaderboard.** One call to `/launchpads` returns everything a comparison table needs; refresh it every minute. 2. **Use the per-launchpad call for charts.** `/launchpads/{id}?days=30` gives the daily series for launches, graduations, volume, traders and fees, and the top tokens to show under the chart. 3. **Link the numbers to tokens.** The same `id` filters the token lists: `/tokens?list=new&launchpad=flap`, `/tokens?list=graduating&launchpad=pons`. 4. **Show volume by quote.** On Robinhood Chain a large share of launchpad trading is against USDG and stock tokens, not ETH; `volume_by_quote_usd_24h` makes that visible. ```python # Launchpad leaderboard: share of 24h volume, graduation rate, time to graduate. import requests lps = requests.get("https://api.crius.sh/v1/robinhood/launchpads", timeout=10).json()["data"] total = sum(lp["stats"]["volume_usd_24h"] for lp in lps) for lp in sorted(lps, key=lambda x: -x["stats"]["volume_usd_24h"]): s = lp["stats"] blocks = s["median_blocks_to_graduate"] minutes = f"{blocks * 0.1 / 60:.0f} min" if blocks else "no graduation" print( f"{lp['name']:<40} {s['volume_usd_24h'] / total:6.1%} of volume " f"{s['launches_24h']:>5} launches {s['graduation_rate_pct']:.2f}% graduate {minutes}" ) ``` ## Frequently asked questions **Which launchpad on Robinhood Chain has the most volume?** Pons, by a wide margin, in the samples on this page: $25.5 million of 24-hour volume across 282,607 trades, against $10.8 million for Long.xyz and under $1 million for each of the others. Call `GET https://api.crius.sh/v1/robinhood/launchpads` for today's numbers. **What is the graduation rate on Pons?** About 1.5%: `graduation_rate_pct: 1.46306`, or 10,479 graduations out of 716,241 Pons launches when the sample was captured. Flap.sh's rate was 0.087% (338 of 387,354). Bankr and Long.xyz tokens never graduate, because they trade on Uniswap v4 from launch. **How many tokens have been launched on Robinhood Chain launchpads?** About 1.29 million across the six launchpads Crius attributes, in the samples on this page: 716,247 on Pons, 387,360 on Flap.sh, 98,672 on Bankr, 83,664 on Long.xyz, 2,193 on King of the Markets and 1,352 on Flywheel. Tokens deployed without a launchpad aren't counted. **Does launchpad volume include trades after graduation?** Yes. `volume_usd_24h` and `trades_24h` count every trade of the launchpad's tokens in any pool, on the curve and after graduation (the response says so in `meta.notes`). A launchpad keeps getting credit for its tokens after they graduate. **Which launchpad ids can I use?** `pons`, `flap`, `bankr`, `long`, `flywheel` and `standard_reserve`. The same ids filter token lists (`/tokens?launchpad=flap`) and name the stream channels (`launches:flap`). ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) [Launchpad **Flap.sh** How Flap.sh launches tax and non-tax tokens on Robinhood Chain, graduates them to Uniswap v2 with burned LP, its contract addresses and the Crius API. Read](https://docs.crius.sh/launchpads/flap/) [Guide **Chain stats dashboard** Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Read](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Get OHLCV candles for Robinhood Chain tokens (OHLCV API) > Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Source: https://docs.crius.sh/guides/get-ohlcv-candles/ · Updated 2026-10-28 Short answer The Robinhood Chain OHLCV API is `GET /v1/robinhood/token/{address}/candles?interval=1h`. Candles come back in columnar arrays aligned by index: `t` (bucket start, unix ms), `o`, `h`, `l`, `c`, `v` (USD volume), `bv` (buy volume), `n` (trades) and `mc` (market cap at close). Intervals run from `1s` to `1d`, up to 1,500 candles per call. Anonymous plan, 2 credits per call with a key. [GET `/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) OHLCV candles are a token’s price history in fixed time buckets: the open, high, low and close of each bucket plus its volume. Crius builds them from every swap on Robinhood Chain, from 1-second to 1-day buckets, and returns them in columnar arrays (one array per field) that map directly onto charting libraries. Each candle also carries the buy volume, the number of trades and the market cap at its close, so one call can draw the price chart, the volume bars and a market-cap axis. This is the Crius OHLCV API for Robinhood Chain, on the anonymous plan. ## Get candles in one call Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/ohlcv-candles/) ### WETH hourly candles What did WETH (0x0bd7d308f8e1639fab988df18a8011f41eacad73) do over the last three hours? GET/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 68 lines (arrays trimmed)** ```json { "data": { "bv": [ 7719250, 3592353, 454055 ], "c": [ 2358.89, 2361.93, 2357.69 ], "currency": "usd", "h": [ 2389.5, 2369.36, 2363.53 ], "interval": "1h", "l": [ 2345.91, 2345.98, 2353.91 ], "mc": [ 90541111, 90657707, 90494986 ], "n": [ 21263, 23756, 3140 ], "o": [ 2369.35, 2358.89, 2361.93 ], "t": [ 1793217600000, 1793221200000, 1793224800000 ], "v": [ 15761872, 7055129, 1053224 ] }, "meta": { "block": 100406798, "block_age_ms": 1271, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "from_ts": 1793217600000, "lag_ms": 78, "note": "default (usd) = the token's real markets merged plus its launch curve; ?pool=main its main market only (the default with currency=quote), ?pool= one pool, ?pool=all every pool. Candles open at the previous close (?continuous=false for first-trade opens); buckets without trades are omitted unless ?fill=true", "pools": [ "0xa9188730fe85be88ad499d7d52b099e800fb0334", "0x69bfaf19c9f377bb306a89aed9f6b07e2c1a8d9a", "0xd42a491087a15e5afd51feb3606066cc152d2b09" ], "safe_block": 100401329, "to_ts": 1793225077000 } } ``` What this tells you - `t` holds the bucket starts: 1793217600000, 1793221200000 and 1793224800000 (20:00, 21:00 and 22:00 UTC on October 28, 2026). Index 0 of every array is the 20:00 candle. - The 20:00 hour opened at 2369.35, reached `h` 2389.5 and `l` 2345.91, and closed at 2358.89. The 21:00 candle opens at exactly that close: candles are continuous by default. - `v[0]` is $15,761,872 of volume across `n[0]` 21,263 trades. Buys were `bv[0]` $7,719,250, so sells were $8,042,622 (`v − bv`). - The last candle (22:00) was still open: `meta.to_ts` is 1793225077000, four minutes into the hour. - `meta.pools` lists the pools merged into these candles, and `mc` the market cap at each close (90,494,986 for the last). [OHLCV candles reference](https://docs.crius.sh/reference/trades/ohlcv-candles/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20WETH%20hourly%20candles&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-ohlcv-candles%2F%23weth-1h%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0bd7d308f8e1639fab988df18a8011f41eacad73%2Fcandles%3Finterval%3D1h%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/ohlcv-candles/) ### Daily candles for a tokenized stock, weekends included How did NVIDIA's tokenized stock (NVDA, 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec) trade day by day? GET/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/candles?interval=1d&limit=5 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/candles?interval=1d&limit=5" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/candles?interval=1d&limit=5"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/candles?interval=1d&limit=5", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 88 lines (arrays trimmed)** ```json { "data": { "bv": [ 1633483, 1256937, 5277227, 4605087, 5262971 ], "c": [ 212.244, 212.256, 216.74, 218.393, 214.214 ], "currency": "usd", "h": [ 212.611, 213.829, 217.895, 226.763, 227.916 ], "interval": "1d", "l": [ 209.923, 204.939, 210.307, 204.029, 204.947 ], "mc": [ 18767361, 18768439, 19164913, 19311033, 18941545 ], "n": [ 13157, 10513, 32278, 37391, 31375 ], "o": [ 211.41, 212.244, 212.256, 216.74, 218.393 ], "t": [ 1792800000000, 1792886400000, 1792972800000, 1793059200000, 1793145600000 ], "v": [ 3009687, 2370467, 9927098, 9083994, 11237635 ] }, "meta": { "block": 100409733, "block_age_ms": 281, "block_ts": 1793225379000, "chain": "robinhood", "finalized_block": 100401329, "from_ts": 1792800000000, "lag_ms": 24, "note": "default (usd) = the token's real markets merged plus its launch curve; ?pool=main its main market only (the default with currency=quote), ?pool= one pool, ?pool=all every pool. Candles open at the previous close (?continuous=false for first-trade opens); buckets without trades are omitted unless ?fill=true", "pools": [ "0xaa8039d8e39d2bbcae23762e71f5a12162875a61848f0d96914c827f61877ef6", "0x3bb34a44f1b2b5f32c034c38a53065a521a47b199700fa9bd19d60985ff24bf1", "0xb944cec30bd4175855215d767adc81f39e5f7e2b", "0x8b6a6416a5d1040efcfa6234da6aa1265dfe123e", "0xcbdfea90430a30ee4469c9902e120a77e7c7e4711d5643671c1d1957f2f1ce27" ], "safe_block": 100405028, "to_ts": 1793225378000 } } ``` What this tells you - Five daily candles, October 24 to October 28, 2026 (`t` from 1792800000000 to 1793145600000, midnight UTC). - The first two days are a Saturday and a Sunday, and the token still traded: 13,157 and 10,513 trades for $3,009,687 and $2,370,467 of volume. On-chain stock tokens trade all week, so a daily chart has no gaps. - Over the five days the close went from 212.244 to 214.214, but the range was wide: `h` 227.916 and `l` 204.947 on the last day. - The busiest day by volume was the last, `v[4]` $11,237,635 over 31,375 trades, while it was still open. [OHLCV candles reference](https://docs.crius.sh/reference/trades/ohlcv-candles/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Daily%20candles%20for%20a%20tokenized%20stock%2C%20weekends%20included&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-ohlcv-candles%2F%23nvda-1d%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%2Fcandles%3Finterval%3D1d%26limit%3D5%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `t` | Bucket start, unix milliseconds (UTC). | | `o`, `h`, `l`, `c` | Open, high, low, close in USD (or in the quote token with `currency=quote`). Each candle opens at the previous close unless `continuous=false`. | | `v` | Volume in USD. Every trade counts here, including those that don't set the price. | | `bv` | Buy volume in USD. Sell volume is `v − bv`. | | `n` | Number of trades in the bucket. | | `mc` | Market cap at the close. | | `interval`, `currency` | What you asked for, echoed back. | | `meta.pools` | The pools merged into the candles. | | `meta.from_ts`, `meta.to_ts` | The time range covered. | ## Which markets the candles use By default (`currency=usd`), candles merge the token’s **real markets**: every pool with at least $1,000 or 2% of the token’s liquidity, plus its launch curve for launchpad tokens. A $1 trade in a forgotten side pool can’t draw a wick. You can change that: | Parameter | Effect | | --- | --- | | `pool=main` | The main market only (the default with `currency=quote`) | | `pool=` | One pool | | `pool=all` | Every pool, thin ones included | | `currency=quote` | Prices in the pool’s quote token, such as ETH | | `continuous=false` | Each candle opens at its first trade instead of the previous close | | `fill=true` | Flat candles for buckets without trades | | `from_ts`, `to_ts` | A time window in unix ms | Some trades never set a candle’s price, though they still count in `v` and `n`: trades under $1, a buy and a sell of the same size in one pool and block, trades in minor pools far from the main market’s price, trades more than 5x away from the 10-minute median, isolated spikes, and the price ladder of a launch block. Dust trades (under 10,000 raw units on either side) never set a price either. ## Use it in your app 1. **Pick the interval from the time range.** `1m` or `5m` for a day, `1h` for a week, `1d` for months. One call returns up to 1,500 candles. 2. **Convert the columns to rows** for your chart library, and divide `t` by 1,000 if it expects seconds. 3. **Use `fill=true` for evenly spaced axes**, especially on quiet tokens and short intervals. 4. **Page back** by passing the first candle’s `t` minus 1 as `to_ts` on the next call: each call returns the latest `limit` candles before `to_ts`. 5. **Keep it live.** Poll the last candle, or subscribe to candles over the [WebSocket stream](https://docs.crius.sh/guides/stream-live-candles/). The [chart example](https://docs.crius.sh/examples/chart/) has a complete TradingView Lightweight Charts page. ```js // Hourly candles to row objects, ready for a chart library. const token = "0x0bd7d308f8e1639fab988df18a8011f41eacad73"; // WETH const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/candles?interval=1h&limit=48&fill=true`); const { data } = await res.json(); const rows = data.t.map((t, i) => ({ time: t / 1000, // seconds open: data.o[i], high: data.h[i], low: data.l[i], close: data.c[i], volume: data.v[i], buyVolume: data.bv[i], sellVolume: data.v[i] - data.bv[i], trades: data.n[i], marketCap: data.mc[i], })); const last = rows.at(-1); const buys = last.volume ? Math.round((100 * last.buyVolume) / last.volume) : 0; console.log(`last close $${last.close}, ${last.trades} trades, ${buys}% buys`); ``` Credits Candles cost 2 credits per call with a key, whatever the `limit`. Ask for the candles you’ll draw in one call instead of many small ones. ## Frequently asked questions **Is there a Robinhood Chain OHLCV API?** Yes. `GET https://api.crius.sh/v1/robinhood/token/{address}/candles` returns open, high, low, close and volume for any token on Robinhood Chain (chain id 4663), built from every swap on Uniswap v2, v3, v4 and launchpad curves. It's on the anonymous plan, so you can call it without a key; with a key it costs 2 credits per call. **How do I get historical OHLCV data for a Robinhood Chain token?** Call `/candles` with an `interval` and a time window in `from_ts` and `to_ts` (unix ms), or page back from the latest candle by passing the first candle's `t` minus 1 as `to_ts`. Each call returns up to 1,500 candles, and launchpad tokens include their bonding-curve history. **What is the best API for Robinhood Chain price charts?** One whose candles come from the chain itself, cover every token from its first trade, and don't let one bad trade draw a fake wick. Crius builds candles from every swap on Robinhood Chain, merges the token's real markets, and leaves thin side pools and outlier trades out of the price (they still count in volume). The candles endpoint is on the anonymous plan and drops straight into TradingView Lightweight Charts: see the [chart example](https://docs.crius.sh/examples/chart/). **What candle intervals are supported?** `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h` and `1d`. The default is `1m`. Each call returns up to 1,500 candles (500 by default); page back in time with `to_ts`. **Why are some time buckets missing?** Buckets with no trades are left out. Add `fill=true` to get flat candles for those buckets (open = high = low = close = the previous close), so the time axis is evenly spaced. **Why don't the candles match the trades I see on the tape?** Candles show the market price. Trades under $1, same-size round trips in one pool and block, trades far from the main market in minor pools, isolated spikes and launch-block ladders don't set the high or low, though they still count in `v` and `n`. For the exact tape, use [trades](https://docs.crius.sh/guides/get-token-trades/). **Can I get candles in ETH instead of USD?** Yes: `currency=quote` prices the candles in the main pool's quote token (ETH for most launchpad tokens). `pool=` charts one pool, `pool=all` every pool. ## Related [Docs **Chart example** Draw a live candlestick and volume chart for any Robinhood Chain token with the Crius candles endpoint and TradingView Lightweight Charts, with full source code. Read](https://docs.crius.sh/examples/chart/) [Guide **Stream live candles** Keep a Robinhood Chain candlestick chart live: load candles over REST, update the last bar from the Crius WebSocket, with a runnable Node.js relay. Read](https://docs.crius.sh/guides/stream-live-candles/) [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **All-time high and price change** Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change. Read](https://docs.crius.sh/guides/get-all-time-high-and-price-change/) [API reference **OHLCV candles API** Candles in columnar form (one array per field, aligned by index), which is compact and maps straight onto charting libraries. Read](https://docs.crius.sh/reference/trades/ohlcv-candles/) --- # Get prices for many Robinhood Chain tokens in one call > Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed. Source: https://docs.crius.sh/guides/get-prices-for-many-tokens/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/prices?tokens={address},{address}` (or `POST /v1/robinhood/prices` with `{"tokens": [...]}`) for up to 100 tokens. `data` is keyed by address, each with `usd`, `eth`, `change_24h_pct`, `liquidity_usd`, `confidence`, `symbol` and `logo`; unknown addresses go to `meta.missing`. For other fields, `POST /v1/robinhood/tokens/batch` returns just the profile fields you list. Both are on the anonymous plan, 1 credit per call with a key. [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) [POST `/prices`](https://docs.crius.sh/reference/tokens/batch-prices-post/) [POST `/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) When you need prices for a watchlist, a portfolio or a token screener, don’t send one request per token. The batch prices endpoint prices up to 100 Robinhood Chain tokens in one call, keyed by address, with the same on-chain pricing as the single [price endpoint](https://docs.crius.sh/guides/get-token-price/) plus the 24-hour change. If you need more than prices (market cap, liquidity, holder count), batch profiles return exactly the fields you ask for. ## Price a list of tokens in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-prices/) ### Two tokenized stocks and one wrong address What are NVDA (0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec) and TSLA (0x322f0929c4625ed5bad873c95208d54e1c003b2d) worth, and what if the list has an address that isn't a token? GET/v1/robinhood/prices?tokens=0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0x322f0929c4625ed5bad873c95208d54e1c003b2d,0x000000000000000000000000000000000000beef **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/prices?tokens=0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0x322f0929c4625ed5bad873c95208d54e1c003b2d,0x000000000000000000000000000000000000beef" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/prices?tokens=0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0x322f0929c4625ed5bad873c95208d54e1c003b2d,0x000000000000000000000000000000000000beef"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/prices?tokens=0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0x322f0929c4625ed5bad873c95208d54e1c003b2d,0x000000000000000000000000000000000000beef", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 36 lines (arrays trimmed)** ```json { "data": { "0x322f0929c4625ed5bad873c95208d54e1c003b2d": { "change_24h_pct": -0.959698, "confidence": "high", "eth": 0.171057, "liquidity_usd": 792587, "logo": null, "source_pool": "0x3ea70ce0b34473692549f97e630a1d82dc05cea94fa55f81b50f10c8c6d8186f", "symbol": "TSLA", "usd": 402.923 }, "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec": { "change_24h_pct": -1.49823, "confidence": "high", "eth": 0.0909845, "liquidity_usd": 1415590, "logo": null, "source_pool": "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3", "symbol": "NVDA", "usd": 214.313 } }, "meta": { "block": 100409724, "block_age_ms": 394, "block_ts": 1793225378000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 63, "missing": [ "0x000000000000000000000000000000000000beef" ], "safe_block": 100405028 } } ``` What this tells you - `data` is an object keyed by lowercase address, not an array: look tokens up by address, in any order. - NVDA: `usd: 214.313`, `change_24h_pct: -1.49823`. TSLA: `usd: 402.923`, `change_24h_pct: -0.959698`. Both have `confidence: "high"`. - TSLA’s price comes from a pool with `liquidity_usd: 792587`, NVDA’s from one with `1415590`: the 24h change and liquidity come in the same row, so you don’t need a second call. - `0x000000000000000000000000000000000000beef` isn’t a token, so it’s absent from `data` and listed in `meta.missing`. The status is still `200`. - `logo` is `null` for both stocks here; for tokens with a logo it’s an image URL you can show directly. [Batch prices reference](https://docs.crius.sh/reference/tokens/batch-prices/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Two%20tokenized%20stocks%20and%20one%20wrong%20address&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-prices-for-many-tokens%2F%23stocks-and-missing%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fprices%3Ftokens%3D0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%2C0x322f0929c4625ed5bad873c95208d54e1c003b2d%2C0x000000000000000000000000000000000000beef%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Get chosen profile fields for many tokens Batch prices cover price, change and liquidity. For anything else in the [token profile](https://docs.crius.sh/guides/get-token-data/), send `POST /v1/robinhood/tokens/batch` with a `fields` list of dot paths. Each token comes back trimmed to those fields, with the same nesting as the full profile. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-token-profiles/) ### Market cap and liquidity for WETH and CHARGE What are the symbol, price, 24h change, market cap and liquidity of WETH and Charge AI, without downloading two full profiles? POST/v1/robinhood/tokens/batch **cURL** ```bash curl -X POST "https://api.crius.sh/v1/robinhood/tokens/batch" \ -H "content-type: application/json" \ -d '{"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}' ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens/batch", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ], "fields": [ "symbol", "price.usd", "price.change_pct.24h", "market.market_cap_usd", "market.liquidity_usd" ] }), }); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.post( "https://api.crius.sh/v1/robinhood/tokens/batch", json={"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 40 lines (arrays trimmed)** ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "market": { "liquidity_usd": 73135530, "market_cap_usd": 90409474 }, "price": { "change_pct": { "24h": 0.286017 }, "usd": 2355.49 }, "symbol": "WETH" }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "market": { "liquidity_usd": 5611.8, "market_cap_usd": 3773.42 }, "price": { "change_pct": { "24h": -0.171971 }, "usd": 0.00000388948 }, "symbol": "CHARGE" } }, "meta": { "block": 100406780, "block_age_ms": 575, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 196, "missing": [], "safe_block": 100401329 } } ``` What this tells you - The body asked for `symbol`, `price.usd`, `price.change_pct.24h`, `market.market_cap_usd` and `market.liquidity_usd`, and that’s all each row contains. - WETH: `market.market_cap_usd: 90409474` and `market.liquidity_usd: 73135530`. CHARGE: `market.market_cap_usd: 3773.42` and `market.liquidity_usd: 5611.8`. - `market.liquidity_usd` adds up all the token’s pools, so for WETH it’s far above the `liquidity_usd` of its single price pool in a batch price row (9,953,382 in the [batch prices sample](https://docs.crius.sh/reference/tokens/batch-prices/)). - `price.change_pct.24h` is the same number as `change_24h_pct` in batch prices: -0.171971 for CHARGE. [Batch token profiles reference](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Market%20cap%20and%20liquidity%20for%20WETH%20and%20CHARGE&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-prices-for-many-tokens%2F%23batch-profiles%0ARequest%3A%20POST%20%2Fv1%2Frobinhood%2Ftokens%2Fbatch%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Which call to use | Call | Returns per token | Use it for | | --- | --- | --- | | `GET /prices?tokens=…` | `usd`, `eth`, `change_24h_pct`, `liquidity_usd`, `confidence`, `source_pool`, `symbol`, `logo` | Watchlists, tickers, portfolio totals. Cacheable. | | `POST /prices` | The same, with the list in a JSON body: `{"tokens": [...]}` | Long lists that don't fit in a URL. | | `POST /tokens/batch` | Only the `fields` you list (dot paths into the profile); an empty list returns full profiles | Screeners and tables that need market cap, holders or launch status. | All three take up to 100 tokens and cost 1 credit per call with a key. Addresses are accepted in any case and returned lowercase. ## Use it in your app 1. **Collect the addresses you show.** A portfolio’s holdings, a watchlist, or the rows on screen. 2. **Split into chunks of 100** and send one `POST /prices` per chunk. 3. **Merge the `data` objects** and look each token up by its lowercase address. 4. **Report `meta.missing`** instead of failing: show “no price” for those tokens. 5. **Refresh on a timer or on new blocks.** Prices change every block; for live updates without polling, subscribe to the [WebSocket stream](https://docs.crius.sh/reference/stream/). ```js // Price any number of tokens, 100 per request. async function getPrices(addresses) { const prices = {}; const missing = []; for (let i = 0; i < addresses.length; i += 100) { const res = await fetch("https://api.crius.sh/v1/robinhood/prices", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ tokens: addresses.slice(i, i + 100) }), }); const { data, meta } = await res.json(); Object.assign(prices, data); missing.push(...meta.missing); } return { prices, missing }; } const { prices, missing } = await getPrices([ "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "0x322f0929c4625ed5bad873c95208d54e1c003b2d", ]); for (const [addr, p] of Object.entries(prices)) { const change = p.change_24h_pct == null ? "n/a" : `${p.change_24h_pct.toFixed(2)}%`; console.log(`${p.symbol} $${p.usd} (${change} 24h, ${p.confidence})`); } if (missing.length) console.warn("no price for", missing); ``` Without a key, mind the rate limit Anonymous requests are limited to 2 per second per IP, so a loop of chunks can hit `429 rate_limited`. A free key raises the limit to 10 per second. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Frequently asked questions **How many tokens can I price in one request?** Up to 100 per call, for both batch prices and batch profiles. For a longer list, split it into chunks of 100. One batch call costs 1 credit with a key, however many tokens it carries. **What happens if one of the addresses is wrong?** The request still succeeds. Tokens Crius can't price are left out of `data` and listed in `meta.missing`, so one bad address in a portfolio doesn't break the whole call. **Should I use GET or POST for batch prices?** They return the same thing. GET is easy to cache and to test in a browser; use POST with a JSON body when the list would make the URL too long (100 addresses is about 4,300 characters). **How do I value a wallet's holdings on Robinhood Chain?** Price the wallet's tokens with one batch call and multiply each balance by `usd`. Skip or flag tokens with `confidence: "low"`: their price can't be realized at size. On the Starter plan, the [wallet profile](https://docs.crius.sh/reference/wallets/wallet-profile/) returns the holdings already valued. ## Related [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Get token data** Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Read](https://docs.crius.sh/guides/get-token-data/) [Guide **Token screener** Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code. Read](https://docs.crius.sh/guides/build-a-token-screener/) [Guide **Wallet token balances** Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices. Read](https://docs.crius.sh/guides/get-wallet-token-balances/) [Use case **Wallets & portfolios** What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens. Read](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) [API reference **Batch prices API** Prices for up to 100 tokens in one call. Pass a comma-separated list in tokens. Read](https://docs.crius.sh/reference/tokens/batch-prices/) --- # Get a token's full activity feed (trades, transfers, liquidity) > Get every event of a Robinhood Chain token in one feed, from trades and transfers to liquidity, burns, owner actions, locks and graduation, with real examples. Source: https://docs.crius.sh/guides/get-token-activity-feed/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/transactions`. It returns one newest-first feed of everything that happened to the token: `buy`, `sell`, `add_liquidity`, `remove_liquidity`, `transfer`, `mint`, `burn`, `owner_action`, `lock`, `fee_claim`, `launch` and `graduation`. Each row has `type`, `block`, `ts`, `tx`, `finality`, the sender (`actor`) and the decoded `method`. Filter with `type`, `wallet`, `min_usd`, `from`, `to` and `finality`. Free plan (API key needed), 2 credits per call. [GET `/token/{address}/transactions`](https://docs.crius.sh/reference/trades/activity-feed/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) The activity feed is a token’s full history as one timeline. Instead of stitching together swaps, ERC-20 transfers, LP events, locker events and contract calls yourself, you get them merged and decoded, newest first, with one cursor. Use it for a token page’s “Activity” tab, for auditing what a contract owner did, or for tracking liquidity being added and pulled. ## Get the latest activity in one call Example [Free plan · 2 credits](https://docs.crius.sh/reference/trades/activity-feed/) ### Charge AI's latest events: three sells, three ways of sending them What happened to Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) most recently, and who did it? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 90 lines (arrays trimmed)** ```json { "data": [ { "actor": "0xffb51d3cc36b1356d5b9418198adee9f29283c58", "actor_tags": [], "amount_base": 788818.58267172958349331, "amount_quote": 0.001303958643843039, "block": 100128111, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "100128111-7-34", "method": "dagSwapTo(uint256,address,(uint256,address,uint256,uint256,uint256),(address[],address[],uint256[],bytes[],uint256)[])", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0xffb51d3cc36b1356d5b9418198adee9f29283c58", "trader_tags": [], "ts": 1793196203320, "tx": "0x8d68dc0ee4294bf07b052c4684ccc7211e9944438fa23c0866ccadb1aa1a0999", "type": "sell", "value_usd": 3.04084 }, { "actor": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c", "actor_tags": [], "amount_base": 740848.926745217054477405, "amount_quote": 0.001227267922525477, "block": 99713565, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "99713565-9-26", "method": null, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c", "trader_tags": [], "ts": 1793152958500, "tx": "0x74cd5b3dd10ab859b6e6da32e9352880cce954a8702378879f078c76936dc489", "type": "sell", "value_usd": 2.88648 }, { "actor": "0x4337044e8b7a221d141fe622eb2460f050a6b6c2", "actor_tags": [], "amount_base": 3467283.726496635780002732, "amount_quote": 0.005777579700862946, "block": 99235194, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "99235194-5-13", "method": "handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[],address)", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0x4498f864313237eb18f593fecd47181979551376", "trader_tags": [ "smart_account", "fomo" ], "ts": 1793103300400, "tx": "0x504e29889e0ff0dd2a4a5e70f4e47d2fe0f9c48eed33604fad83a199efd10c94", "type": "sell", "value_usd": 13.3484 } ], "meta": { "block": 100406803, "block_age_ms": 823, "block_ts": 1793225078000, "chain": "robinhood", "finalized_block": 100397649, "history": "complete", "lag_ms": 80, "next_cursor": "99235194-13", "safe_block": 100401329 } } ``` What this tells you - All three rows are `type: "sell"` in the CHARGE/ETH Uniswap v4 pool, and all are `finality: "finalized"`: settled on Ethereum. - The newest sold 788,818.58 CHARGE for 0.001303958643843039 ETH (`value_usd: 3.04084`). Its `method` is `dagSwapTo(…)`, a router call, and `actor` equals `trader`: the wallet sent its own transaction. - The second has `method: null` (the function wasn’t one Crius can decode) and is again sent by the trader itself. - The third, $13.3484, is a smart-wallet trade: `actor` is the bundler 0x4337044e8b7a221d141fe622eb2460f050a6b6c2 calling `handleOps(…)`, and `trader` 0x4498f864313237eb18f593fecd47181979551376 has `trader_tags: ["smart_account", "fomo"]`. - `fees.token_tax.pct: 0` on each: sellers received everything the pool paid out. - `meta.history: "complete"`: the feed goes back to the token’s first block. Page with `meta.next_cursor` (`"99235194-13"`). [Activity feed reference](https://docs.crius.sh/reference/trades/activity-feed/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI's%20latest%20events%3A%20three%20sells%2C%20three%20ways%20of%20sending%20them&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-activity-feed%2F%23charge-feed%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ftransactions%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Event types and their fields Every row has `id`, `type`, `block`, `ts`, `tx`, `finality`, `actor` (the transaction sender), `actor_tags` and `method` (the decoded function the transaction called). The rest depends on the type: | `type` | What it is | Extra fields | | --- | --- | --- | | `buy`, `sell` | A swap in any pool or launch curve | `trader`, `trader_tags`, `pool`, `dex`, `amount_base`, `amount_quote`, `quote_symbol`, `value_usd`, `fees.token_tax.pct` | | `add_liquidity`, `remove_liquidity` | Liquidity added to or removed from a pool | `provider`, `pool`, `dex`, `amounts` (both tokens), `value_usd` | | `transfer`, `mint`, `burn` | ERC-20 movements. Mints come from `0x0`; burns go to `0x0` or a dead address | `from`, `to`, `amount`, `value_usd` | | `owner_action` | An event emitted by the token contract itself (ownership, trading switches, setters, upgrades) | `contract`, `event` (decoded) | | `lock` | An event from a locker or vesting contract that involves the token | `contract`, `contract_label`, `event` | | `fee_claim` | A fee claim or collect event involving the token | `contract`, `event` | | `launch`, `graduation` | The launchpad lifecycle | `launchpad`, `creator` | ## Filter the feed | Parameter | Example | Use | | --- | --- | --- | | `type` | `type=add_liquidity,remove_liquidity` | Only some event types (comma list) | | `wallet` | `wallet=0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca` | One wallet’s trades, liquidity changes and transfers, e.g. the creator’s | | `min_usd` | `min_usd=1000` | Skip small events | | `from`, `to` | `from=launch&to=graduation` | A range: `block:N`, `ts:MS`, `mcap:USD`, `launch`, `trading_open`, `graduation` or `ath` | | `finality` | `finality=safe` | Only events at that finality level or better | | `limit`, `cursor` | `limit=100` | Page size, and `meta.next_cursor` for the next page | `from=launch&to=graduation`, for example, gives you everything that happened while a launchpad token was on its bonding curve, and `type=owner_action` every change the token contract recorded (ownership, trading switches, settings). ## Use it in your app 1. **Get a free key** at [dashboard.crius.sh](https://dashboard.crius.sh) and send it in the `x-api-key` header. Each call costs 2 credits. 2. **Render rows by `type`.** Trades show side, amount and USD; liquidity rows show `amounts`; transfers show `from` → `to`. Use `actor_tags` and `trader_tags` to label bots, smart accounts and app wallets. 3. **Mark unsettled rows.** Rows with `finality: "latest"` are confirmed by the sequencer but not yet posted to Ethereum. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/). 4. **Page back with `cursor`**, or keep the newest `id` and poll for new rows. For real-time updates, use the [WebSocket stream](https://docs.crius.sh/guides/stream-trades-websocket/). ```js // Liquidity history of a token: every add and remove since launch. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const url = new URL(`https://api.crius.sh/v1/robinhood/token/${token}/transactions`); url.search = new URLSearchParams({ type: "add_liquidity,remove_liquidity", from: "launch", limit: "100" }); const res = await fetch(url, { headers: { "x-api-key": process.env.CRIUS_API_KEY } }); const { data, meta } = await res.json(); for (const e of data) { const sides = e.amounts.map((a) => `${a.amount} ${a.symbol}`).join(" + "); console.log(new Date(e.ts).toISOString(), e.type, sides, `$${e.value_usd}`, e.provider); } if (meta.next_cursor) console.log("more: cursor =", meta.next_cursor); ``` Plan needed The activity feed is on the Free plan: without a key it returns `403 plan_required` with `required_plan: "free"` (see [Errors](https://docs.crius.sh/errors/)). The swaps alone are available without a key from the [trade tape](https://docs.crius.sh/guides/get-token-trades/). ## Frequently asked questions **How do I see all transactions of a Robinhood Chain token?** Call `GET /v1/robinhood/token/{address}/transactions` with a free API key. It merges trades, transfers, liquidity changes, mints and burns, lock events, fee claims, the contract owner's actions and launchpad events into one list, newest first, and pages back to the token's first block with `cursor`. **What's the difference between the activity feed and the trade tape?** The [trade tape](https://docs.crius.sh/guides/get-token-trades/) (`/trades`) has swaps only, with full detail: price, gas, router (`via`), executor and signer. It's on the anonymous plan. The activity feed (`/transactions`) has every event type in one timeline, with less detail per trade, and needs a free key. **How do I find when a token's owner renounced ownership or changed taxes?** Filter the feed with `type=owner_action`. Those rows are events emitted by the token contract itself, decoded, so calls like `renounceOwnership`, `openTrading`, setters and upgrades show up with the block and transaction they happened in. **Why is the actor different from the trader?** `actor` is the address that sent the transaction. For trades through a smart-wallet app, that's a bundler or relayer, while `trader` is the wallet whose balance changed. In the example, `actor` 0x4337044e8b7a221d141fe622eb2460f050a6b6c2 sent an ERC-4337 bundle (`handleOps`) for the smart account 0x4498f864313237eb18f593fecd47181979551376. ## Related [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) [API reference **Activity feed API** One chronological feed of everything that happened to the token: buys and sells, liquidity adds and removes, plain transfers, mints and burns, LP lock events, fee claims, owner actions on the contract Read](https://docs.crius.sh/reference/trades/activity-feed/) --- # How to get Robinhood Chain token data (token profile API) > Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Source: https://docs.crius.sh/guides/get-token-data/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}`. One response carries the token's identity (`name`, `symbol`, `decimals`, `type`), supply, `price` with change and all-time high, `market` (market cap, FDV, liquidity), a `holders` summary, its `launch` and `liquidity` lock status, `metadata` (logo and links) and trade `stats` per window. It's on the anonymous plan: no key needed, 1 credit with one. [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [POST `/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) The token profile is the one call that tells you everything Crius knows about a Robinhood Chain token: what it is, how much of it exists, what it trades at, how big its market is, who holds it, where it launched, whether its liquidity is locked and how much it has traded. Send `GET /v1/robinhood/token/{address}` with any ERC-20 address and you get it all in a single JSON object, read at the block shown in `meta.block`. ## Get a token’s profile in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### A graduated Pons token: Charge AI (CHARGE) What is Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8), where did it launch, and how big is it? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 320 lines (arrays trimmed)** ```json { "data": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/bundles" }, "burned": 29840058.774195638068253872, "chain_id": 4663, "circulating_supply": 970159941.225804361931746128, "creation": { "attribution": "known_launchpad", "block": 88385886, "deployed_via": "pons_v2", "deployer": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "launchpad_name": "Pons", "tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793040659244, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1791988981764, "orders": [ { "payment_ts": 1791988981764, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": null, "header": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "icon": "https://cdn.dexscreener.com/cms/images/DjTh8_NirbFrIzjW?width=800&height=800&quality=95&format=auto", "links": [ { "label": "Website", "type": "website", "url": "https://chargeai.bid/" }, { "type": "twitter", "url": "https://x.com/chargeairh" } ] }, "url": "https://dexscreener.com/robinhood/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" }, "first_seen_block": 88385886, "history": "complete", "holders": { "burned_pct": 2.98401, "count": 179, "dev_holding": false, "dev_pct": 0, "locked_pct": 8.16327, "top10_pct": 13.436 }, "launch": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "creator_label": null, "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_state": null, "graduated_block": 88461321, "graduation_threshold": 4.2, "launched_block": 88385886, "launchpad": "pons", "launchpad_name": "Pons", "pair_token": "0x0000000000000000000000000000000000000000", "progress_pct": 100, "raised": null, "status": "graduated" }, "liquidity": { "locked_pct": 100, "lockers": [ "pons_v2_launch_locker" ], "next_unlock_ts": null, "permanent": true, "status": "locked" }, "locked": 81632653.061224486519511236, "market": { "fdv_usd": 3889.48, "liquidity_usd": 5611.8, "market_cap_usd": 3773.42, "pools_count": 10, "quote_liquidity_usd": 2805.9 }, "metadata": { "banner": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "description": "hf:charge-ai/charge-30b@9ff2ef1e98ea4d9745a70b33ea02b80dba26c582", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeairh", "website": "https://chargeai.bid/" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "logo_original": "https://api.surplusllm.com/api/launchpad/logos/bb4315cb9506ef872830b1dab25ffdb6694df1b8b8e32cc2c8d083208f26baab.png", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": { "source": "pons_launch", "url": "https://x.com/chargeairh" }, "website": { "source": "pons_launch", "url": "https://chargeai.bid/" } }, "source": "pons_launch", "sources": { "links": "pons_launch", "logo": "pons_launch" } }, "name": "Charge AI", "price": { "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "ath_ts": 1792055400000, "ath_usd": 0.0000707881, "change_pct": { "1h": 0.896103, "1m": 0.896103, "1s": 0.896103, "24h": -0.171971, "30s": 0.896103, "4h": 0.896103, "5m": 0.896103, "6h": 0.896103 }, "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "thin_liquidity": false, "usd": 0.00000388948 }, "security": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 143046, "buys": 2893, "first_trade_ts": 1791982835000, "sell_volume_usd": 137621, "sells": 2250, "since": "chain_start", "trades": 5143, "volume_usd": 280667 }, "avg_trade_usd": { "1h": null, "1m": null, "1s": null, "24h": 2.96366, "30s": null, "4h": null, "5m": null, "6h": null }, "buy_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "last_trade_ts": 1793196204000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "trades": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_eth": { "1h": 0, "1m": 0, "1s": 0, "24h": 0.00252958, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 } }, "symbol": "CHARGE", "total_supply": 1000000000, "type": "launchpad", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": null, "sourcify": null } }, "meta": { "block": 100406769, "block_age_ms": 400, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 38, "pending": [], "safe_block": 100401329 } } ``` What this tells you - **Identity.** `name: "Charge AI"`, `symbol: "CHARGE"`, `decimals: 18`, `type: "launchpad"`, `standard: "erc20"`. - **Launch.** `launch.launchpad: "pons"` and `launch.status: "graduated"`: it launched at block 88385886 and graduated at block 88461321 (`progress_pct: 100`). `creation.deployer` is the creator wallet `0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca`. - **Price.** `price.usd` is 0.00000388948 with `confidence: "medium"`, taken from the Uniswap v4 pool in `price.source_pool`. `price.ath_usd` is 0.0000707881, so the token trades about 94.5% below its all-time high. - **Market.** `market.market_cap_usd: 3773.42`, `market.fdv_usd: 3889.48`, `market.liquidity_usd: 5611.8` across `pools_count: 10` pools. - **Holders.** `holders.count: 179`, the top 10 hold `top10_pct: 13.436`%, and the developer holds nothing (`dev_holding: false`). - **Liquidity.** `liquidity.status: "locked"`, 100% in `pons_v2_launch_locker` with `permanent: true`: the launch liquidity can never be withdrawn. - **Activity.** `stats.all_time` counts 5,143 trades and $280,667 of volume, but `stats.trades.24h` is only 2: the token has gone quiet. - **Links.** `metadata.links.website` is `https://chargeai.bid/` and `metadata.links.twitter` is `https://x.com/chargeairh`, both from the Pons launch (`metadata.sources.links: "pons_launch"`). [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20graduated%20Pons%20token%3A%20Charge%20AI%20\(CHARGE\)&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-data%2F%23charge-profile%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### An address that isn't a token What happens when the address isn't an indexed token on Robinhood Chain? GET/v1/robinhood/token/0x000000000000000000000000000000000000beef **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x000000000000000000000000000000000000beef" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x000000000000000000000000000000000000beef"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x000000000000000000000000000000000000beef", ) body = r.json() print(body["data"]) ``` **Real response 404 Captured Oct 28, 2026 · 6 lines (arrays trimmed)** ```json { "error": { "code": "token_not_found", "message": "token 0x000000000000000000000000000000000000beef not indexed" } } ``` What this tells you - The status is `404` and `error.code` is `token_not_found`, with the message `token 0x000000000000000000000000000000000000beef not indexed`. - Treat it as “not a token on this chain” (a wallet, a contract that isn’t an ERC-20, or a typo), not as a temporary failure: retrying won’t change it. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20An%20address%20that%20isn't%20a%20token&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-data%2F%23not-found%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x000000000000000000000000000000000000beef%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the profile contains The profile is grouped into sections. Field names are stable, so you can read them without checking the shape first. | Section | Key fields | What it answers | | --- | --- | --- | | Identity | `name`, `symbol`, `decimals`, `type`, `standard` | What the token is. `type` is `launchpad`, `generic` or `stock`. | | Supply | `total_supply`, `burned`, `locked`, `circulating_supply` | How many tokens exist and how many were burned or locked. Amounts are in whole tokens. | | `price` | `usd`, `eth`, `change_pct`, `ath_usd`, `ath_ts`, `confidence`, `source_pool` | The live price, its change per window, the all-time high and how far to trust it. | | `market` | `market_cap_usd`, `fdv_usd`, `liquidity_usd`, `quote_liquidity_usd`, `pools_count` | How big the market is and how much liquidity backs it. | | `holders` | `count`, `top10_pct`, `dev_pct`, `dev_holding`, `burned_pct`, `locked_pct` | How spread out the supply is. | | `launch` and `creation` | `launchpad`, `status`, `progress_pct`, `graduated_block`, `deployer`, `factory` | Where and how the token was created. `launch` is `null` for tokens that didn't use a launchpad. | | `liquidity` | `status`, `locked_pct`, `lockers`, `next_unlock_ts`, `permanent` | Whether the liquidity can be pulled, and when. | | `stats` | `trades`, `buys`, `sells`, `traders`, `volume_usd` per window, plus `all_time` | How much it trades, from 1 second to 24 hours. | | `metadata` | `logo`, `banner`, `description`, `links`, `sources` | Logo and links for your UI, and where they came from. | Two sections are links rather than data: `security.see` and `bundles.see` point to the [security check](https://docs.crius.sh/guides/token-security-score/) and the launch-bundle analysis, which are heavier to compute. That keeps the profile fast enough to call on every page view. A few things differ by token type. Launchpad tokens such as CHARGE carry `launch` and a `liquidity` object with their launch locker. Tokens from other factories have `launch: null` and a `liquidity` summary with a `see` link to the [liquidity endpoint](https://docs.crius.sh/reference/security/liquidity-locks/). Tokenized stocks have `type: "stock"` and a `ui_multiplier`. On a token’s very first request, `meta.pending` lists sections that are still loading; it is empty (`[]`) in the example above. ## Use it in your app 1. **Fetch the profile when a user opens a token.** One request fills a token page: header (logo, name, links), price card, market stats and holder summary. No key is needed while you prototype. 2. **Handle `404 token_not_found`.** Show “not a token on Robinhood Chain” instead of retrying. 3. **Read optional sections defensively.** `launch` is `null` for non-launchpad tokens and `price` can be `null` for a token that has never had a market. 4. **Follow the links for detail.** Call `security.see` before you let users trade, and the [pools endpoint](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) when you need every market. 5. **Use lighter calls in loops.** For a price ticker, call [`/price`](https://docs.crius.sh/guides/get-token-price/) instead; for a list of tokens, use `POST /tokens/batch` with only the fields you show. ```js // Token page header from one call (no key needed). const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}`); if (res.status === 404) throw new Error("not a token on Robinhood Chain"); const { data, meta } = await res.json(); console.log(`${data.name} (${data.symbol}), ${data.type}`); console.log(`price $${data.price?.usd}, market cap $${data.market.market_cap_usd}`); console.log(`${data.holders.count} holders, top 10 hold ${data.holders.top10_pct}%`); if (data.launch) console.log(`${data.launch.launchpad_name}: ${data.launch.status}`); console.log(`liquidity ${data.liquidity?.status}, read at block ${meta.block}`); ``` Market cap on a quiet token A market cap is the price times the supply, and the price comes from one pool’s current state. On a token like CHARGE, with 2 trades in 24 hours and $2,805.9 of real quote liquidity (`market.quote_liquidity_usd`), the market cap says little about what holders could actually sell for. Show liquidity next to it. See [Market cap, FDV and supply](https://docs.crius.sh/guides/market-cap-fdv-and-supply/). ## Frequently asked questions **What is the best API for Robinhood Chain token data?** Pick one that indexes the chain itself, covers every token (not only listed ones) and tells you how fresh each answer is. The Crius API reads Robinhood Chain from its own archive nodes, decodes every block as it arrives and returns a full token profile in one call, with `meta.block` and `meta.lag_ms` on every response. The token profile is on the anonymous plan, so you can test it without signing up. **Does the token profile need an API key?** No. `/token/{address}` is on the anonymous plan, limited to 2 requests per second per IP. With a free key it costs 1 credit and your limit goes up to 10 requests per second. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). **Which tokens does it cover?** Every ERC-20 on Robinhood Chain: launchpad tokens (`type: "launchpad"`), tokens from other factories (`generic`), tokenized stocks (`stock`), and WETH and USDG. An address that isn't an indexed token returns `404` with the code `token_not_found`. **How do I get profiles for many tokens at once?** Use `POST /v1/robinhood/tokens/batch` with up to 100 addresses and a `fields` list of dot paths (`price.usd`, `market.market_cap_usd`, `holders.count`). It returns only those fields for each token. See [Get prices for many tokens](https://docs.crius.sh/guides/get-prices-for-many-tokens/). **Where do the logo and social links come from?** From the token's own metadata first (its launchpad launch, an on-chain metadata URI or its verified source), with its DexScreener profile filling gaps. `metadata.sources` says which one was used, and `metadata.links` always has all six keys (`null` when unknown). ## Related [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Market cap, FDV and supply** Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed. Read](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Token profile API** Full profile of any ERC-20 on the chain: name, symbol, decimals, supply (total, burned, locked, circulating), creation and launchpad lifecycle, metadata and socials (with their source), price with cha Read](https://docs.crius.sh/reference/tokens/token-profile/) --- # Get a Robinhood Chain token's fees, taxes and creator rewards > See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response. Source: https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/fees?window=24h` (`1h`, `24h`, `7d` or `all`). `totals_usd` adds up gas, LP fees, hook fees, creator tax, bonding-curve fees and token tax; `by_pool` splits them per pool; for Pons tokens `launchpad`, `receivers` and `claims` show the creator's fee wallet, pending fees and sweeps. Starter plan, 5 credits. [GET `/token/{address}/fees`](https://docs.crius.sh/reference/launchpads/fees-claims/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) Every trade of a Robinhood Chain token pays someone: the network (gas), liquidity providers (LP fees), the launchpad (curve and hook fees), the creator (creator tax) and sometimes the token itself (a transfer tax). The fees endpoint adds all of it up for one token over a window, splits it per pool, and for Pons tokens shows who receives the creator and protocol shares, what is waiting to be swept, and the sweeps that already happened. ## Get a token’s fees in one call Example [Starter plan · 5 credits](https://docs.crius.sh/reference/launchpads/fees-claims/) ### Charge AI: 2% creator tax and 1% hook fee on a graduated Pons token What fees did Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) pay in the last 24 hours, and who gets them? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 74 lines (arrays trimmed)** ```json { "data": { "by_pool": [ { "dex": "uniswap_v4", "lp_usd": 0, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "token_tax_usd": 0, "volume_usd": 5.92732 } ], "claims": [], "launchpad": { "bonding_curve": { "fee_a": 0, "fee_a_usd": 0, "fee_b": 0, "fee_b_usd": 0 }, "creator_tax_usd": 0.119245, "hook_fee_usd": 0.0596227, "pending": { "buyback": "0", "creator_tax": "1037358686757100", "fees": "518679343378549" }, "swept_usd": { "buyback": 0, "creator": 0, "protocol": 0 } }, "receivers": [ { "address": "0x14a6f00bad1f4e21e2af4e317383c3d550378996", "creator_tax_bps": 200, "role": "creator_fee_recipient" }, { "address": "0x31ea5b453a6cd60f36203830de046ff32dec2cdb", "role": "launchpad_protocol", "share_bps": 3000 }, { "address": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "role": "launchpad_fee_escrow" } ], "totals_usd": { "bonding_curve": 0, "creator": 0.119245, "gas": 0.0365916, "hook": 0.0596227, "lp": 0, "token_tax": 0, "total": 0.21546, "uniswap_protocol": null }, "window": "24h" }, "meta": { "block": 100406855, "block_age_ms": 1148, "block_ts": 1793225083000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "notes": [ "USD at the current ETH price", "uniswap_protocol: protocol fee switch not indexed yet (null)" ], "safe_block": 100401329 } } ``` What this tells you - `window: "24h"` (the default). Charge AI traded $5.93 in that window, all in its v4 pool (`by_pool[0].volume_usd: 5.92732`). It’s a quiet token, which makes the arithmetic easy to check. - `totals_usd.creator: 0.119245` is 2.01% of that volume and `totals_usd.hook: 0.0596227` is 1.01%: the token’s 200 bps creator tax and 100 bps hook fee. - `totals_usd.lp: 0`: the swaps paid no LP fee; the launchpad’s cut comes through the hook instead. `token_tax: 0`: the token contract itself takes no transfer tax. - `totals_usd.gas: 0.0365916`: what traders paid the network for these trades. `total: 0.21546` is the sum. - `launchpad.pending.creator_tax: "1037358686757100"` is in wei of the quote currency: 0.00104 ETH of creator tax collected by the hook and not yet swept. `swept_usd` and `claims` are empty: no sweep in this window. - `receivers`: the creator tax goes to `0x14a6f00bad1f4e21e2af4e317383c3d550378996` (`creator_fee_recipient`), not to the creator who launched the token (`0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca`). The launchpad protocol (`0x31ea5b453a6cd60f36203830de046ff32dec2cdb`) has `share_bps: 3000`, and fees wait in the Pons fee escrow `0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e`. - `totals_usd.uniswap_protocol` is `null`: the Uniswap protocol fee switch isn’t indexed yet (`meta.notes`). [Fees & claims reference](https://docs.crius.sh/reference/launchpads/fees-claims/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI%3A%202%25%20creator%20tax%20and%201%25%20hook%20fee%20on%20a%20graduated%20Pons%20token&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-fees-and-creator-rewards%2F%23pons-fees%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ffees%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What each total means | Field | What it counts | | --- | --- | | `totals_usd.gas` | Gas (L2 execution and L1 data) paid by the transactions that traded the token | | `totals_usd.lp` | LP fees at each pool's fee tier; on Uniswap v4, each swap's own fee | | `totals_usd.hook` | Pons hook fees (`HookFeeCollected` fee amounts) | | `totals_usd.creator` | Pons creator tax collected by the hook | | `totals_usd.bonding_curve` | Fees charged on the launchpad's bonding curve: `launchpad.bonding_curve.fee_a` and `fee_b`, in the quote currency and USD | | `totals_usd.token_tax` | Transfer tax taken by the token contract, measured from real trades | | `totals_usd.uniswap_protocol` | Uniswap protocol fees; `null` until indexed | | `by_pool[]` | Per pool: `pool`, `dex`, `volume_usd`, `lp_usd`, `token_tax_usd` | | `launchpad.pending` | Fees the Pons hook holds for the pool and hasn't swept yet, as raw integer strings: `fees`, `creator_tax`, `buyback` | | `launchpad.swept_usd`, `claims[]` | Sweeps in the window, split into `protocol`, `buyback` and `creator` | USD values use the current ETH price, not the price at the time of each trade. ## Where the rates come from The rates behind those totals are part of the launch. For a Pons token, the `fees` block of [`/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) (Free plan) reads them live from the Pons contracts. For Charge AI (the `launch` sample): | Field | Charge AI | Meaning | | --- | --- | --- | | `creator_tax_bps` | 200 | 2% creator tax on hook pool swaps, paid to `creator_fee_recipient` | | `hook_fee_bps` | 100 | 1% hook fee on the same swaps | | `protocol_fee_share_bps` | 3000 | The Pons protocol's share (30%), paid to `protocol_fee_recipient` `0x31ea5b453a6cd60f36203830de046ff32dec2cdb` | | `buyback_enabled` | `false` | No buyback for this token (`buyback_burn_bps: 5000` is configured, buyback vault `0x42df2a798f82289e177311362e8f5ccc45c1219c`) | | `snipe_tax.start_bps`, `snipe_tax.window_s` | 9900, 3 | A snipe tax starting at 99% for the first 3 seconds of trading | | `pending.creator_tax`, `pending.fees` | 0.0010373586867571, 0.000518679343378549 | The same pending amounts as `/fees`, in ETH | Other launchpads charge differently. Their fees reach `/fees` as LP fees, measured taxes and curve fees: - **Flap.sh**: a 1% fee on curve buys and sells (`bonding_curve.fee_a`); tax tokens add a buy and sell tax set at launch, charged on the curve too. See [Flap.sh](https://docs.crius.sh/launchpads/flap/). - **King of the Markets**: a 1% base fee on curve and pool trades, 30% of it to the creator (`fee_a`) and 70% to the protocol (`fee_b`), plus an optional creator tax of up to 5%. See [King of the Markets](https://docs.crius.sh/launchpads/standard-reserve/). - **Flywheel**: a 4% hook tax on every swap, split into holder rewards, burn, locked liquidity and platform. See [Flywheel](https://docs.crius.sh/launchpads/flywheel/). - **Bankr**: a 0.7% pool fee, 95% of it to the creator, plus a hook fee. See [Bankr](https://docs.crius.sh/launchpads/bankr/). ## Use it in your app 1. **Pick the window.** `24h` for a live dashboard, `7d` for a weekly report, `all` for a creator’s lifetime earnings. `all` is served from running totals, so it’s fast even for busy tokens. 2. **Show the effective rate, not only the dollars.** Divide each total by the summed `by_pool[].volume_usd`; that is what a trader really pays, and it should match the configured bps. 3. **Follow the fee recipient.** To see what a developer earned across launches, take `receivers[].address` where `role` is `creator_fee_recipient` and look it up with the [developer profile](https://docs.crius.sh/reference/wallets/developer-profile/). 4. **Convert pending amounts yourself.** `launchpad.pending` values are raw integers in the quote currency’s smallest unit (wei for ETH). ```js // Effective fee rates for one token over 7 days (Starter plan key). const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/fees?window=7d`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); const volume = data.by_pool.reduce((s, p) => s + p.volume_usd, 0); const pct = (x) => (volume > 0 && x != null ? ((x / volume) * 100).toFixed(2) + "%" : "n/a"); console.log(`volume $${volume.toFixed(2)}`); for (const k of ["creator", "hook", "lp", "bonding_curve", "token_tax", "gas"]) { console.log(`${k.padEnd(14)} $${(data.totals_usd[k] ?? 0).toFixed(4)} ${pct(data.totals_usd[k])}`); } const creator = data.receivers.find((r) => r.role === "creator_fee_recipient"); if (creator?.address) console.log(`creator fees go to ${creator.address}`); ``` Taxes without a paid plan If you only need what buyers and sellers pay, the anonymous [`/security`](https://docs.crius.sh/guides/check-token-taxes/) call returns the measured `tax.buy_pct` and `tax.sell_pct` for any token. `/fees` is for who receives the money. ## Frequently asked questions **How do I see how much a Robinhood Chain token's creator has earned?** Call `GET /v1/robinhood/token/{address}/fees?window=all`. `totals_usd.creator` is the creator tax paid on the token's trades in the window, `launchpad.pending.creator_tax` what is still waiting to be swept, and `claims` the sweeps that already happened. The creator's fee wallet is the `receivers` entry with `role: "creator_fee_recipient"`. **What is the Pons creator fee?** Charge AI, the sample token, pays a 2% creator tax (`creator_tax_bps: 200`) and a 1% hook fee (`hook_fee_bps: 100`) on its v4 pool swaps. The measured fees match: $0.119 of creator tax and $0.060 of hook fees on $5.93 of volume. Read a token's own rates from the `fees` block of `/token/{address}/launch`. **Why is the creator fee recipient different from the token's creator?** The wallet that launched a Pons token and the wallet that collects its creator tax are set separately. For Charge AI the creator is `0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca` and the fee recipient is `0x14a6f00bad1f4e21e2af4e317383c3d550378996`. When you study a developer's earnings, follow the fee recipient. **Does /fees work for tokens that aren't from Pons?** Yes. Gas, LP fees, measured token tax and bonding-curve fees are reported for any token, per pool. The `launchpad`, `receivers` and `claims` sections are read from Pons's contracts, so they describe Pons tokens. **What plan does the fees endpoint need?** Starter or above, 5 credits per call. The token's fee configuration (`/token/{address}/launch`) is on the Free plan, and measured buy and sell taxes are in the anonymous `/security` call. See [Plans, limits & credits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [API reference **Fees & claims API** Fees paid around a token over a window: gas (L2 and L1), LP fees, Uniswap protocol fees, hook fees and taxes, launchpad and creator fees and token tax, plus who claimed them and where they went. Read](https://docs.crius.sh/reference/launchpads/fees-claims/) [API reference **Launch lifecycle API** A launchpad token's lifecycle: creator, curve, bonding progress, raised amount, graduation block and the pool it graduated into. Read](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Docs **Plans, limits & credits** Crius API plans (Free, Starter, Pro, Business, Enterprise), monthly credits, requests per second, WebSocket limits, credit cost per endpoint and the rate-limit response headers. Read](https://docs.crius.sh/plans-and-limits/) --- # Get the holders of a Robinhood Chain token (token holders API) > Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Source: https://docs.crius.sh/guides/get-token-holders/ · Updated 2026-10-28 Short answer The Robinhood Chain token holders API is `GET /v1/robinhood/token/{address}/holders`, with a Free API key (2 credits). It returns the holder `count`, `distribution.top10_pct` (the top-10 share without pools, lockers and burn addresses) and up to 500 `holders[]` ranked by balance, each with `address`, `balance`, `pct`, `value_usd`, `value_eth` and a `label` for infrastructure. [GET `/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) [GET `/token/{address}/holders/snapshot`](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET `/token/{address}/bubblemap`](https://docs.crius.sh/reference/wallet-graph/bubble-map/) A token’s holders are the addresses with a non-zero balance, ranked by how much they hold. One call to the Crius API returns the current list for any Robinhood Chain token with each holder’s share of supply and USD value, the total holder count, and how concentrated the supply is in the ten largest real holders. Pools, lockers and burn addresses are labeled so you can tell them apart from wallets. It’s the Crius token holders API for Robinhood Chain, and it works for every ERC-20 on the chain, from launchpad tokens to tokenized stocks. ## Get the holder list in one call Example [Free plan · 2 credits](https://docs.crius.sh/reference/holders/live-holders/) ### Charge AI (CHARGE): 178 holders, top 10 hold 13.4% Who holds Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8), a Pons token that graduated to Uniswap v4, and how concentrated is it? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 67 lines (arrays trimmed)** ```json { "data": { "balances": "verified_onchain", "count": 178, "distribution": { "top10_pct": 13.436 }, "history": "complete", "holders": [ { "address": "0x1860e8b874ed7742ae5459af731687ecb576c9fd", "balance": 28729479.389247917189540117, "label": null, "pct": 2.87295, "rank": 1, "value_eth": 0.0474081, "value_usd": 111.806 }, { "address": "0x346f5777f5652bd561dcd830e638bc40d3e1cf3d", "balance": 25566954.227971953484331514, "label": null, "pct": 2.5567, "rank": 2, "value_eth": 0.0421894, "value_usd": 99.4981 }, { "address": "0xa975e46d6552fb0ef85f7e9f7b640a058dc368bd", "balance": 23260835.335709034922247096, "label": null, "pct": 2.32608, "rank": 3, "value_eth": 0.038384, "value_usd": 90.5235 }, { "address": "0xf4e322c50010e00878b8d6bbb2c495d90097e58f", "balance": 19090692.939108585371870819, "label": null, "pct": 1.90907, "rank": 4, "value_eth": 0.0315026, "value_usd": 74.2947 }, { "address": "0x8e6be350c1276d3276cead49859aa435d77ac9eb", "balance": 12214695.452807030766083489, "label": null, "pct": 1.22147, "rank": 5, "value_eth": 0.0201561, "value_usd": 47.5356 } ], "ledger_reliable": true }, "meta": { "block": 100436633, "block_age_ms": 414, "block_ts": 1793228150000, "chain": "robinhood", "finalized_block": 100427397, "lag_ms": 17, "safe_block": 100431079 } } ``` What this tells you - `count: 178` holders and `distribution.top10_pct: 13.436`: the ten largest real holders own about 13% of the supply, a spread-out token. - `exclude=infra` leaves the Uniswap v4 PoolManager, the Pons launch locker and the burn address out of the list, so rank 1 is already a real holder: `0x1860e8b874ed7742ae5459af731687ecb576c9fd`, with `pct: 2.87295`, worth `value_usd: 111.806` (`value_eth: 0.0474081`). Its `label` is `null`: an ordinary address. - Ranks 2 to 5 hold 2.5567%, 2.32608%, 1.90907% and 1.22147%. The top five add up to about 10.9%, so ranks 6 to 10 share the remaining 2.5% of the top-10 figure. - No single wallet holds 3% or more: the fifth-largest, `0x8e6be350c1276d3276cead49859aa435d77ac9eb`, is worth `value_usd: 47.5356`. - `balances: "verified_onchain"`, `ledger_reliable: true` and `history: "complete"`: the balances were checked against the token contract at `meta.block` 100436633, and the count covers the token’s whole history. [Live holders reference](https://docs.crius.sh/reference/holders/live-holders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI%20\(CHARGE\)%3A%20178%20holders%2C%20top%2010%20hold%2013.4%25&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-holders%2F%23charge-holders%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%3Flimit%3D5%26exclude%3Dinfra%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `count` | Addresses holding a balance now. `null` when the history isn't complete or the ledger isn't reliable for this token. | | `distribution.top10_pct` | Share of total supply held by the ten largest holders that aren't infrastructure (pools, lockers, burn addresses). | | `holders[].rank` | Position by balance, 1 = largest. | | `holders[].address` | The holder's address. | | `holders[].balance` | Token balance in whole tokens (decimals applied). | | `holders[].pct` | Share of total supply, in percent. | | `holders[].value_usd`, `value_eth` | What the balance is worth at the current price. | | `holders[].label` | What the address is when Crius knows it: a pool, the v4 PoolManager, a locker, the burn address, the dev. `null` for an ordinary wallet. | | `balances` | `verified_onchain` when balances were read from the token's `balanceOf`; `ledger` when they come from Transfer events only. | | `ledger_reliable` | `false` when more than a fifth of the top holders' event balances disagree with the chain (reflection or rebasing tokens). | | `history` | `complete` when every transfer since the token's creation is indexed, else `partial`. | The list is live: it reflects the block in `meta.block`. For holders at a past moment (a block, a time, or the block where the market cap first crossed $50k), use the [holder snapshot](https://docs.crius.sh/guides/get-historical-holders/). For how holders are classified (infrastructure, smart accounts, snipers, whales), see [Trader attribution & wallet tags](https://docs.crius.sh/concepts/attribution/). ## Reading concentration A high top-10 share is the classic warning sign: a few wallets that can dump on everyone else. Two things make the raw number misleading on Robinhood Chain, and the API handles both: - **Pooled and locked supply isn’t held by anyone.** A graduated launchpad token keeps most of its supply in the Uniswap v4 PoolManager and the launchpad’s locker. Counting those would make every token look 80% concentrated. `top10_pct` leaves them out. - **One person can own many wallets.** Ten wallets at 1% each might be one buyer. The holder list can’t see that; the [bubble map](https://docs.crius.sh/guides/read-a-bubble-map/) links holders that were funded by the same wallet or sent tokens to each other. ## Use it in your app 1. **Get a Free key.** `/holders` needs the Free plan or higher and costs 2 credits per call. Send the key in the `x-api-key` header. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). 2. **Ask for as many rows as you show.** `limit` takes 1 to 500. A token page usually needs 20 to 100; a concentration check needs only `distribution.top10_pct`, so `limit=10` is enough. 3. **Separate infrastructure from wallets.** Pass `exclude=infra` for a wallets-only list, or keep the rows and show `label` next to the address. Don’t add up `pct` across all rows to measure concentration: use `top10_pct`. 4. **Check the quality flags.** If `ledger_reliable` is `false` or `count` is `null`, show the list but don’t present the count as exact. ```js // Top holders of a token, with infrastructure marked. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/holders?limit=20`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); console.log(`${data.count ?? "?"} holders, top 10 hold ${data.distribution.top10_pct}% (block ${meta.block})`); for (const h of data.holders) { console.log(h.rank, h.address, `${h.pct}%`, `$${h.value_usd ?? "?"}`, h.label ?? "wallet"); } ``` Holders over time The live list answers “who holds it now”. For “who held it before the pump”, use the [holder snapshot](https://docs.crius.sh/guides/get-historical-holders/); for “who held through the whole run”, the [holder cohort](https://docs.crius.sh/guides/find-diamond-hand-holders/); and for the number of holders day by day, [holder count history](https://docs.crius.sh/guides/track-holder-count/). ## Frequently asked questions **Is there a Robinhood Chain token holders API?** Yes. The Crius API keeps a holder ledger for every ERC-20 on Robinhood Chain from block one. `GET /v1/robinhood/token/{address}/holders` returns the live list (Free plan), `/holders/snapshot` the holders at a past block, time or market cap, and `/holders/history` the holder count over time (Starter plan). **How do I get the holders of a Robinhood Chain token?** Send `GET https://api.crius.sh/v1/robinhood/token/{address}/holders` with your key in the `x-api-key` header. The response has the holder `count`, the top-10 concentration in `distribution.top10_pct` and the ranked list in `holders[]`. It works for every ERC-20 on Robinhood Chain (chain id 4663), not only launchpad tokens. **How many holders can I get in one call?** `limit` goes up to 500 (default 100). `/holders` has no cursor, so 500 is the deepest it goes. For a longer list, page through [`/holders/snapshot?at=now`](https://docs.crius.sh/reference/holders/holder-snapshot/) with `cursor` (500 per page, the next page is in `meta.next_cursor`); it costs 5 credits per page instead of 2. **Why is the biggest holder a pool or a locker?** Tokens waiting in a pool or locked in a launch locker sit at a contract address, so they show up as holders. Crius marks them with a `label` (`uniswap_v4_pool_manager`, `pons_v2_launch_locker`, `burn`…) and leaves them out of `distribution.top10_pct`, so concentration is measured over real holders only. **Are the balances accurate for reflection or rebasing tokens?** Each listed balance is checked against the token's own `balanceOf` at the indexed head (`balances: "verified_onchain"`), so tokens whose Transfer events don't match their balances can't inflate the list. If more than a fifth of the top holders disagree with the chain, `ledger_reliable` is `false` and `count` is `null` rather than a wrong number. **Do I need an API key for holders?** Yes, a Free key is enough. Without a key the call returns `403 plan_required` with `required_plan: "free"`. A Free key takes a minute at [dashboard.crius.sh](https://dashboard.crius.sh); see [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Historical holders** Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder. Read](https://docs.crius.sh/guides/get-historical-holders/) [Guide **Holder count history** Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example. Read](https://docs.crius.sh/guides/track-holder-count/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [Guide **Wallet token balances** Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices. Read](https://docs.crius.sh/guides/get-wallet-token-balances/) [API reference **Live holders API** The current holder list, ranked by balance, with each holder's share of supply, USD value and labels (pools, lockers, burn addresses, the dev). Read](https://docs.crius.sh/reference/holders/live-holders/) --- # Find every pool and the liquidity of a Robinhood Chain token (liquidity API) > Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Source: https://docs.crius.sh/guides/get-token-pools-and-liquidity/ · Updated 2026-10-28 Short answer The Robinhood Chain liquidity API is `GET /v1/robinhood/token/{address}/pools`. It lists every market the token trades in (Uniswap v2 pairs, v3 fee tiers, v4 pools with their hook, launchpad curves), ranked by `liquidity_usd`, with `amounts` of each side, `fee`, `hook`, `price_usd` and `is_price_pool` for the market the token's price comes from. `meta.total` counts all pools; page with `cursor`. For one pool in depth (reserves, TVL, LP lock, stats), call `GET /v1/robinhood/pool/{pool}`. Both are on the anonymous plan. [GET `/token/{address}/pools`](https://docs.crius.sh/reference/tokens/token-markets/) [GET `/pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) [GET `/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) A Robinhood Chain token usually trades in more than one place: the pool its launchpad created at graduation, Uniswap v3 fee tiers, v4 pools with different hooks, and side pools anyone can open. The pools endpoint lists all of them for one token, ranked by USD liquidity, so you can see where the real market is, how deep it is and which pools are noise. The pool detail endpoint then gives one pool in depth: reserves, TVL, hook, LP lock status and trade stats. Together they are the Crius liquidity API for Robinhood Chain, and both work without a key. ## List a token’s pools in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-markets/) ### Charge AI: one real market and two decoy pools Where does Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) trade, and how much liquidity is behind each market? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 123 lines (arrays trimmed)** ```json { "data": [ { "amounts": { "token0": 1.18969, "token1": 720478686 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461321, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 0, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "pons_v2_meme_hook" }, "is_price_pool": true, "liquidity_usd": 5604.57, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_usd": 0.00000388948, "quote": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "quote_liquidity_usd": 2802.29, "state": { "liquidity": 29277002188455996438188, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 1949728392666469411451966154432124, "tick": 202227 }, "swaps_indexed": 432, "tick_spacing": 200 }, { "amounts": { "token0": 3.1477, "token1": 115029 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461495, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 850000, "hook": null, "is_price_pool": false, "liquidity_usd": 6.29539, "pool": "0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3", "price_usd": 0.0000273644, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 3.1477, "state": { "liquidity": 601728037770030, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 15145615706034675540349663040887263187, "tick": 381391 }, "swaps_indexed": 3, "tick_spacing": 60 }, { "amounts": { "token0": 0.328859, "token1": 35779.5 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88466617, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 450000, "hook": null, "is_price_pool": false, "liquidity_usd": 0.657719, "pool": "0x1a184f0aa1978e7b543ee944a30df88dd34fcb667aa5a9142bb399ef582481b8", "price_usd": 0.00000919127, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 0.328859, "state": { "liquidity": 108473206521826, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 26133147987752847079481471382601445977, "tick": 392302 }, "swaps_indexed": 4, "tick_spacing": 4500 } ], "meta": { "block": 100406784, "block_age_ms": 826, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 11, "next_cursor": "3", "safe_block": 100401329, "total": 10 } } ``` What this tells you - `meta.total: 10`: CHARGE has 10 pools. This page shows the top 3; pass `meta.next_cursor` (`"3"`) as `cursor` for the rest. - The first pool, `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`, is the real market: Uniswap v4 against ETH, `liquidity_usd: 5604.57`, `is_price_pool: true`. It holds 1.18969 ETH and 720,478,686 CHARGE (`amounts`), and its `hook` is `pons_v2_meme_hook`. - Its `created_block` is 88461321, the same block as CHARGE’s graduation in the token profile: this is the pool Pons opened when the bonding curve completed. - The next two pools are USDG pools with no hook and fees of `850000` and `450000` (85% and 45%). They hold $6.29539 and $0.657719 and quote CHARGE at 0.0000273644 and 0.00000919127, several times the real price of 0.00000388948. Pools with a 25% fee or more never set the token’s price. [Token markets reference](https://docs.crius.sh/reference/tokens/token-markets/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI%3A%20one%20real%20market%20and%20two%20decoy%20pools&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-pools-and-liquidity%2F%23charge-pools%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fpools%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Look at one pool in depth Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/pools/pool-detail/) ### The CHARGE/ETH Uniswap v4 pool What's in CHARGE's main pool, who controls its liquidity, and how much has it traded? GET/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 207 lines (arrays trimmed)** ```json { "data": { "created_block": 88461321, "created_ts": 1791990423100, "currency0": { "address": "0x0000000000000000000000000000000000000000", "decimals": 18, "logo": null, "price_usd": 2355.49, "symbol": "ETH" }, "currency1": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "decimals": 18, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "price_usd": 0.00000388948, "symbol": "CHARGE" }, "dex": "uniswap_v4", "dynamic_fee": false, "factory": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "fee": 0, "fee_bps": 0, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "PonsV2MemeHook", "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ] }, "lp": { "locked_pct": 100, "locker": "pons_v2_launch_locker", "permanent": true, "status": "locked" }, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "pool_manager": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "state": { "initialized_ticks": 2, "last_block": 100128111, "liquidity": 29277002188455996438188, "price_0_in_1": 605604460, "price_1_in_0": 0.00000000165124, "real_quote_raised": null, "reserve0": 0, "reserve1": 0, "reserves": { "currency0": 1.18969, "currency1": 720478686, "kind": "real" }, "sqrt_price_x96": 1949728392666469411451966154432124, "tick": 202227 }, "stats": { "all_time": { "buy_volume_usd": 107700, "buys": 2159, "first_trade_ts": 1791990423000, "sell_volume_usd": 114903, "sells": 1767, "since": "chain_start", "trades": 3926, "volume_usd": 222603 }, "avg_trade_usd": { "1h": null, "1m": null, "1s": null, "24h": 2.96366, "30s": null, "4h": null, "5m": null, "6h": null }, "buy_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "last_trade_ts": 1793196204000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "trades": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_eth": { "1h": 0, "1m": 0, "1s": 0, "24h": 0.00252958, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 } }, "swaps_indexed": 432, "tick_spacing": 200, "tvl_usd": 5604.57 }, "meta": { "block": 100406786, "block_age_ms": 1080, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 48, "safe_block": 100401329 } } ``` What this tells you - `currency0` is native ETH (`price_usd: 2355.49`) and `currency1` is CHARGE (`price_usd: 0.00000388948`). `state.price_1_in_0: 0.00000000165124` is CHARGE’s price in ETH. - `state.reserves` has `kind: "real"`: 1.18969 ETH and 720,478,686 CHARGE that can actually be swapped. `tvl_usd: 5604.57`. - `fee: 0`: the pool itself charges no LP fee. The `hook` (`PonsV2MemeHook`) has the `afterSwap` and `afterSwapReturnDelta` permissions and the risk `can_modify_swap_amounts`: it can change what a swap pays out, so a fee can be taken inside the hook rather than through `fee`. - `lp.status: "locked"`, `locked_pct: 100`, `locker: "pons_v2_launch_locker"`, `permanent: true`: the liquidity can’t be removed. - `stats.all_time` shows 3,926 trades and $222,603 of volume in this pool, out of $280,667 for the token across all its markets. [Pool detail reference](https://docs.crius.sh/reference/pools/pool-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20CHARGE%2FETH%20Uniswap%20v4%20pool&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-pools-and-liquidity%2F%23charge-pool-detail%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fpool%2F0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `pool` | Pair address (Uniswap v2, v3) or 32-byte pool id (Uniswap v4). | | `dex` | `uniswap_v2`, `uniswap_v3`, `uniswap_v4` or a launchpad curve. | | `base`, `quote` | The token you asked about and what it's paired with (`address`, `symbol`, `logo`). Native ETH is `0x0000000000000000000000000000000000000000`. | | `amounts` | Each side's balance in whole tokens (`token0`, `token1`, in the pool's own order). | | `liquidity_usd`, `quote_liquidity_usd` | 2 × the quote side, and the quote side alone, from the pool's own state. | | `price_usd` | The token's price in this pool. It can differ a lot from the token's price in thin pools. | | `is_price_pool` | `true` for the pool the token's price comes from. | | `fee`, `dynamic_fee`, `tick_spacing` | The swap fee in millionths (`3000` = 0.3%, `850000` = 85%), whether a v4 hook sets it per swap, and the tick spacing. | | `hook` | The v4 hook's `address` and `name`, or `null`. | | `state` | Raw pool state: `liquidity`, `sqrt_price_x96`, `tick`, and `reserve0`/`reserve1` for v2 pairs. | | `created_block` | The block the pool was created. | The pool detail adds `tvl_usd`, `fee_bps`, `currency0` and `currency1` with decimals and USD prices, the hook’s `permissions` and `risk`, the `lp` lock summary, `state.reserves` and the same `stats` windows as the token profile. ## Use it in your app 1. **Call `/pools` to find the real market.** Take the row with `is_price_pool: true` for links to the pool and for swaps, and show the top rows as “markets”. 2. **Hide noise.** Rows with a tiny `liquidity_usd` or a `fee` of 250000 (25%) or more are rarely real markets; leave them out of totals and charts. 3. **Show real depth.** Display `quote_liquidity_usd` next to `liquidity_usd`, so users see what could actually be sold into. 4. **Drill into one pool** with `/pool/{pool}` for its hook, lock status and stats, and check the hook with the [hook risk guide](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) before trading v4 pools. ```python import requests token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" r = requests.get(f"https://api.crius.sh/v1/robinhood/token/{token}/pools", params={"limit": 50}, timeout=10) body = r.json() real = [p for p in body["data"] if p["fee"] < 250000 and p["liquidity_usd"] >= 100] for p in real: mark = "price pool" if p["is_price_pool"] else "" hook = p["hook"]["name"] if p["hook"] else "no hook" print(f'{p["dex"]} {p["base"]["symbol"]}/{p["quote"]["symbol"]} ${p["liquidity_usd"]:,.0f} {hook} {mark}') print(f'{len(real)} real markets out of {body["meta"]["total"]} pools') ``` Liquidity is not the same as locked liquidity A deep pool can still be emptied if its LP tokens or position sit in a wallet. The pool detail’s `lp` tells you whether this pool’s liquidity is locked; for every position, lock and unlock date, use [Liquidity & locks](https://docs.crius.sh/reference/security/liquidity-locks/). ## Frequently asked questions **Is there a Robinhood Chain liquidity API?** Yes. The Crius API reads liquidity from every Uniswap v2, v3 and v4 pool and launchpad curve on Robinhood Chain (chain id 4663). Per token, `GET /v1/robinhood/token/{address}/pools` returns each pool's `liquidity_usd` and `quote_liquidity_usd`; per pool, `GET /v1/robinhood/pool/{pool}` adds reserves, `tvl_usd` and the LP lock; chain-wide, `GET /v1/robinhood/stats` returns `liquidity.tvl_usd` and `liquidity.locked_lp_usd`. All three work without an API key. **How do I get the total liquidity of a Robinhood Chain token?** Read `market.liquidity_usd` (2 × the quote side) and `market.quote_liquidity_usd` from the token profile, `GET /v1/robinhood/token/{address}`: they add up all of the token's pools. To see how that total splits across pools, call `/token/{address}/pools`, where rows are ranked by `liquidity_usd`. **How do I find a token's liquidity pool on Robinhood Chain?** Call `GET /v1/robinhood/token/{address}/pools`. The first row is the pool with the most liquidity, and the row with `is_price_pool: true` is the one the token's price comes from. Each row's `pool` is a pair address (Uniswap v2 and v3) or a 32-byte pool id (Uniswap v4). **How much liquidity does a token have?** Two numbers matter. `liquidity_usd` is 2 × the quote side of a pool, the number DEX screeners show. `quote_liquidity_usd` is the ETH, WETH or USDG actually in the pool: the most sellers could take out. The token profile's `market.liquidity_usd` and `market.quote_liquidity_usd` add up all pools. **Why does a token have pools at very different prices?** Anyone can create a pool for any token, with any fee and starting price. Small side pools often sit far from the real price because almost nobody trades them. Crius never prices a token from a pool with a fee of 25% or more, and its candles leave out thin pools by default. **Is the liquidity locked?** The pool detail has an `lp` object with `status`, `locked_pct`, `locker` and `permanent`. For every LP position of the token, who holds it and when locks expire, use [Liquidity & locks](https://docs.crius.sh/reference/security/liquidity-locks/) (Free plan) or read [Check if liquidity is locked](https://docs.crius.sh/guides/check-liquidity-locked/). **Which DEXes does Crius index on Robinhood Chain?** Uniswap v2, v3 and v4 (including every v4 hook) and the launchpad bonding curves (Pons and others). See [Uniswap on Robinhood Chain](https://docs.crius.sh/concepts/uniswap/) and [Launchpads](https://docs.crius.sh/concepts/launchpads/). ## Related [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [Guide **DEX data** Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades. Read](https://docs.crius.sh/guides/robinhood-chain-dex-data/) [API reference **Token markets API** Every market the token trades in: Uniswap v2 pairs, v3 pools (all fee tiers), v4 pools (with their hook) and launchpad bonding curves, with liquidity and 24h activity. Read](https://docs.crius.sh/reference/tokens/token-markets/) --- # Get a Robinhood Chain token's live USD price > Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Source: https://docs.crius.sh/guides/get-token-price/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/price`. It returns `usd` and `eth` per whole token, the `source_pool` and `dex` the price comes from, that pool's `liquidity_usd`, and a `confidence` level (`high`, `medium`, `low`) with a `thin_liquidity` flag. It's the fastest Crius call and works without an API key (1 credit with one). [GET `/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) The price endpoint answers one question as fast as possible: what is this Robinhood Chain token worth right now, in USD and ETH. Crius finds the token’s deepest market (the pool with the most liquidity within 2% of the price), reads its current price, and converts the quote asset (ETH, WETH, USDG or another priced token) to USD through the deepest ETH/USDG pool. The response says which pool was used and how much liquidity backs it, so you know how far to trust the number. ## Get the price in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### A small meme token priced against ETH: medium confidence What is Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) worth right now? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "eth_usd": 2355.49, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "thin_liquidity": false, "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "usd": 0.00000388948 }, "meta": { "block": 100406772, "block_age_ms": 654, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 66, "safe_block": 100401329 } } ``` What this tells you - `usd: 0.00000388948` per whole CHARGE, and `eth: 0.00000000165124`. With `eth_usd: 2355.49`, the two agree: 0.00000000165124 × 2,355.49 ≈ 0.0000038895. - The price comes from a Uniswap v4 pool (`dex: "uniswap_v4"`, `source_pool: 0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`) quoted in native ETH (`quote: 0x0000000000000000000000000000000000000000`). - `liquidity_usd: 5604.57` is 2 × the quote side; `quote_liquidity_usd: 2802.29` is the ETH actually in the pool. - `confidence: "medium"` because the pool holds between $1,000 and $10,000. `thin_liquidity: false`: this is a real two-sided market. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20small%20meme%20token%20priced%20against%20ETH%3A%20medium%20confidence&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-price%2F%23charge-price%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### A tokenized stock priced against USDG: high confidence What does NVIDIA's tokenized stock (NVDA, 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec) trade at on Robinhood Chain? GET/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "high", "dex": "uniswap_v3", "eth": 0.0909845, "eth_usd": 2355.49, "liquidity_usd": 1415590, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_liquidity_usd": 707795, "source_pool": "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3", "symbol": "NVDA", "thin_liquidity": false, "token": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "usd": 214.313 }, "meta": { "block": 100409717, "block_age_ms": 717, "block_ts": 1793225377000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 108, "safe_block": 100405028 } } ``` What this tells you - `usd: 214.313` and `eth: 0.0909845` per NVDA token. - The deepest market is a Uniswap v3 pool against USDG (`dex: "uniswap_v3"`, `quote: 0x5fc5360d0400a0fd4f2af552add042d716f1d168`), so no ETH conversion is needed for the USD price. - `liquidity_usd: 1415590` (about $1.4 million) puts it well over $10,000: `confidence: "high"`. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20tokenized%20stock%20priced%20against%20USDG%3A%20high%20confidence&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-price%2F%23nvda-price%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `usd`, `eth` | Price of one whole token (already divided by `decimals`), in USD and in ETH. | | `eth_usd` | The ETH/USD rate used, from the deepest ETH/USDG pool. | | `source_pool`, `dex`, `quote` | The pool the price comes from (a pair address, or a 32-byte pool id on Uniswap v4), its DEX, and its quote asset. | | `liquidity_usd` | 2 × the quote side of that pool, the convention DEX screeners use. | | `quote_liquidity_usd` | The real quote amount in that pool: what sellers could actually take out. | | `confidence` | `high`: the pool holds $10,000 or more. `medium`: $1,000 to $10,000. `low`: under $1,000, or a thin price. | | `thin_liquidity` | `true` when no pool holds at least $50: the price comes from the deepest thin pool (a fresh single-sided launch pool, for example). | | `token`, `symbol` | The token you asked for, lowercase, and its symbol. | ## How the source pool is chosen A token can trade in many pools: Uniswap v2 pairs, v3 fee tiers, v4 pools with hooks and launchpad bonding curves. Crius ranks them by how much can actually be traded near the price (depth within ±2%), not by headline TVL, and skips pools that can’t set a fair price: - **Decoy pools.** A pool with a fee of 25% or more never sets a price, because nobody really trades there. - **One-sided pools.** A pool with only a bid near the price, or one implying a fully diluted value far beyond its liquidity, is only a last-resort fallback. - **Dust pools.** Pools under $50 only count when the token has nothing else, and then `thin_liquidity` is `true`. When the deepest market is quoted in another token (a meme paired with a tokenized stock, for example), that token’s own USD price is used, and the reported liquidity can’t exceed that token’s own market. [Find every pool of a token](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) to see the alternatives, with `is_price_pool` marking the one used here. ## Use it in your app 1. **Call `/price` in hot loops.** It’s the smallest response, so use it for tickers, portfolio valuation and bot checks rather than the full profile. 2. **Gate on `confidence`.** Show a warning, or skip automated trades, when `confidence` is `low` or `thin_liquidity` is `true`. A $100 trade can move a thin pool’s price a long way. 3. **Size against `quote_liquidity_usd`.** It’s the real amount on the other side of the pool, half of `liquidity_usd`. 4. **Batch when you have many tokens.** Up to 100 tokens per call with [batch prices](https://docs.crius.sh/guides/get-prices-for-many-tokens/), instead of one request each. ```python import requests token = "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" # NVDA tokenized stock r = requests.get(f"https://api.crius.sh/v1/robinhood/token/{token}/price", timeout=10) r.raise_for_status() p = r.json()["data"] if p["thin_liquidity"] or p["confidence"] == "low": print(f"{p['symbol']}: ${p['usd']} (unreliable, ${p['quote_liquidity_usd']} in the pool)") else: print(f"{p['symbol']}: ${p['usd']} ({p['confidence']} confidence, {p['dex']})") ``` Need the 24h change too? `/price` returns the price only. The [batch prices](https://docs.crius.sh/reference/tokens/batch-prices/) response adds `change_24h_pct` per token, and the [token profile](https://docs.crius.sh/guides/get-token-data/) has `price.change_pct` for every window from 1 second to 24 hours plus the all-time high. See [All-time high and price change](https://docs.crius.sh/guides/get-all-time-high-and-price-change/). ## Frequently asked questions **How do I get the price of a Robinhood Chain token?** Send `GET https://api.crius.sh/v1/robinhood/token/{address}/price` with the token's contract address. `data.usd` is the USD price of one whole token and `data.eth` the price in ETH. No API key is needed to start. **What is the best API for Robinhood Chain token prices?** One that prices tokens from on-chain markets as each block arrives and tells you how reliable each price is. The Crius `/price` endpoint reads the token's deepest pool on Robinhood Chain, converts through the deepest ETH/USDG pool, and returns the pool, its liquidity and a `confidence` level with every price. It covers every token with a market, including new launchpad tokens and tokenized stocks. **How often does the price update?** Every block. Robinhood Chain produces a block about every 100 ms and Crius applies each one as it arrives; `meta.block` and `meta.lag_ms` tell you which block the price reflects and how far behind the head it is. For a push feed instead of polling, use the [WebSocket stream](https://docs.crius.sh/reference/stream/). **Why does the price differ from the last trade?** The price is read from the source pool's current state, not from the last trade. A trade moves the pool, so the next price reflects where the pool sits after it. Trades in small side pools can print at very different prices; they don't set the token's price. **Is the price of a tokenized stock the real stock price?** It's the market price of the token on Robinhood Chain, read from its own on-chain pools; Crius doesn't mix in off-chain stock quotes. Because it's set by trades on chain, it keeps moving when stock exchanges are closed: NVDA's token traded over $3 million on Saturday, October 24, 2026 (see the daily candles in [OHLCV candles](https://docs.crius.sh/guides/get-ohlcv-candles/)). ## Related [Guide **Prices for many tokens** Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed. Read](https://docs.crius.sh/guides/get-prices-for-many-tokens/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Guide **All-time high and price change** Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change. Read](https://docs.crius.sh/guides/get-all-time-high-and-price-change/) [Guide **Price alerts** Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Read](https://docs.crius.sh/guides/build-price-alerts/) [API reference **Token price API** The fastest call: USD and ETH price, the pool it came from, that pool's liquidity and a confidence level. Read](https://docs.crius.sh/reference/tokens/token-price/) --- # Get every trade of a Robinhood Chain token (trade tape) > Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Source: https://docs.crius.sh/guides/get-token-trades/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/trades`. Trades come newest first, each with `type` (`buy` or `sell`), `amount_base`, `amount_quote`, `value_usd`, `price_usd`, `pool`, `dex`, gas and token tax under `fees`, its `finality`, and the `trader` whose balance changed, with the router (`via`), `executor` and `signer` reported separately. Filter by `side`, `trader`, `min_usd`, `from_ts`/`to_ts` and `app`; page with `cursor`. Anonymous plan, 2 credits per call with a key. [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET `/token/{address}/transactions`](https://docs.crius.sh/reference/trades/activity-feed/) The trade tape is a token’s list of swaps, newest first: every buy and sell on Uniswap v2, v3, v4 and the launchpad curves, as it happened on Robinhood Chain. What makes it more useful than raw swap logs is attribution. On chain, the address that calls a pool is usually a router, an aggregator, a relayer or an ERC-4337 bundler. Crius reports the wallet whose balance actually changed as the `trader`, and lists the infrastructure separately, so trade counts, PnL and copy-trading use real people. ## Get the latest trades in one call Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### WETH's latest trades: a relayer, a router and an aggregator What are the latest trades of WETH (0x0bd7d308f8e1639fab988df18a8011f41eacad73) on Robinhood Chain? GET/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 144 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 0.241346083005198446, "amount_quote": 569.019791, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 239930, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000503853, "total_eth": 0.00000503853, "usd": 0.0118753 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-6-44", "market_cap_usd_at_trade": 90494155, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00034, "price_usd": 2357.69, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "signer_label": null, "trader": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "trader_app": null, "trader_label": "fomo_relayer_3", "ts": 1793225076000, "tx": "0x5b474612139f91cb226cf9e5097244dbb896a86834d8adbd263641c96d67b9f7", "tx_index": 6, "type": "buy", "value_eth": 0.241428, "value_usd": 569.02, "via": [] }, { "amount_base": 0.021222351350879784, "amount_quote": 50.025498, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 455557, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000095667, "total_eth": 0.0000095667, "usd": 0.0225477 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-1-12", "market_cap_usd_at_trade": 90475571, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00013, "price_usd": 2357.21, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x800539138ff0510191277f6b5c58fb94ae700064", "signer_label": null, "trader": "0x800539138ff0510191277f6b5c58fb94ae700064", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0x0bde8abf03edce0f2ba13a3398ec2575b177c3f2d85eef77c25c7899a9949311", "tx_index": 1, "type": "sell", "value_eth": 0.0212252, "value_usd": 50.0255, "via": [ "uniswap_universal_router" ] }, { "amount_base": 0.011210844980975568, "amount_quote": 26.431588, "block": 100406782, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020904, "gas_used": 315171, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000658833, "total_eth": 0.00000658833, "usd": 0.015528 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406782-10-32", "market_cap_usd_at_trade": 90493695, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00033, "price_usd": 2357.68, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "signer_label": null, "trader": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0xa3a9ddaaa96d7cc4d300eb5ae37d174755cee56aec3e5e15ae7c3adf437a113b", "tx_index": 10, "type": "buy", "value_eth": 0.0112146, "value_usd": 26.4316, "via": [ "gmgn_swap_router" ] } ], "meta": { "block": 100406789, "block_age_ms": 367, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "next_cursor": "100406782-32", "safe_block": 100401329 } } ``` What this tells you - The newest trade is a `buy` of 0.241346083005198446 WETH for 569.019791 USDG (`value_usd: 569.02`, `price_usd: 2357.69`) in the Uniswap v3 pool `0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca`. Its trader has `trader_label: "fomo_relayer_3"`. - The second, a $50.0255 sell, went through `via: ["uniswap_universal_router"]`, and the third, a $26.4316 buy, through `via: ["gmgn_swap_router"]`. In both, `trader` is the wallet that signed. - Gas is tiny: `fees.gas.usd` is 0.0118753 for the first trade (239,930 gas at 0.021 gwei), and `l1_eth: 0`. - `fees.token_tax.pct` is `null` (no tax measured on these trades), `executor` is `null` (each trader sent its own transaction) and `finality` is `latest`: the trades are confirmed by the sequencer but not yet posted to Ethereum. - `market_cap_usd_at_trade: 90494155` and `eth_usd_at_trade: 2356.9` freeze the context of each trade. [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20WETH's%20latest%20trades%3A%20a%20relayer%2C%20a%20router%20and%20an%20aggregator&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-trades%2F%23weth-trades%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0bd7d308f8e1639fab988df18a8011f41eacad73%2Ftrades%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### Large sells of a meme token, made from smart wallets Who sold $500 or more of sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a), and through what? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/trades?side=sell&min\_usd=500&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/trades?side=sell&min_usd=500&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/trades?side=sell&min_usd=500&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/trades?side=sell&min_usd=500&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 146 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 27042336.484925271015012074, "amount_quote": 0.424551321259576653, "block": 100407338, "dex": "uniswap_v4", "eth_usd_at_trade": 2355.49, "executor": "0x4337fa4d86d4b6a2634900effb713bf6fb685835", "fees": { "gas": { "gas_price_gwei": 0.02645, "gas_used": 683901, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000180892, "total_eth": 0.0000180892, "usd": 0.0426089 }, "token_tax": { "pct": 0 } }, "finality": "latest", "id": "100407338-6-25", "market_cap_usd_at_trade": 36980.1, "pool": "0xe1cb1474a4c240a1e0bca5fb5c56f04a7d90789891fb59b68a142ca4071404e1", "price_eth": 0.0000000156995, "price_usd": 0.0000369801, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x4337fa4d86d4b6a2634900effb713bf6fb685835", "signer_label": null, "trader": "0xa4109b8d391723d8f6bcfc5d75e6996f61062f76", "trader_app": "fomo", "trader_label": null, "ts": 1793225136000, "tx": "0x8e45c6a46af96d27e33af204debb6989bab832e71e6648088d9b0735c07c8c25", "tx_index": 6, "type": "sell", "value_eth": 0.424551, "value_usd": 1000.03, "via": [ "erc4337_entrypoint" ] }, { "amount_base": 24863647.628256999490426667, "amount_quote": 0.807194970469008325, "block": 100393824, "dex": "uniswap_v4", "eth_usd_at_trade": 2356.69, "executor": "0x4337038429b76948ee97eb2d8115513277c3abf5", "fees": { "gas": { "gas_price_gwei": 0.020944, "gas_used": 697736, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000146134, "total_eth": 0.0000146134, "usd": 0.0344392 }, "token_tax": { "pct": null } }, "finality": "finalized", "id": "100393824-2-9", "market_cap_usd_at_trade": 76509.6, "pool": "0xe1cb1474a4c240a1e0bca5fb5c56f04a7d90789891fb59b68a142ca4071404e1", "price_eth": 0.0000000324649, "price_usd": 0.0000765096, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x4337038429b76948ee97eb2d8115513277c3abf5", "signer_label": null, "trader": "0xf154aa93e313b103fb4cb0183581823adeb70423", "trader_app": "fomo", "trader_label": null, "ts": 1793223744000, "tx": "0x4d9178482bc7fa7e7cd6bc3ebaf9d9e0732ce2a1d0b6a93388da4117c15bd21e", "tx_index": 2, "type": "sell", "value_eth": 0.807195, "value_usd": 1902.31, "via": [ "erc4337_entrypoint" ] }, { "amount_base": 7314055.699273110048450567, "amount_quote": 0.306578636376103123, "block": 100393715, "dex": "uniswap_v4", "eth_usd_at_trade": 2356.69, "executor": "0x4337043aedb812f09b4eb3682be2cd510d38217c", "fees": { "gas": { "gas_price_gwei": 0.02082, "gas_used": 424961, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000884769, "total_eth": 0.00000884769, "usd": 0.0208512 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "100393715-9-13", "market_cap_usd_at_trade": 98783.8, "pool": "0xe1cb1474a4c240a1e0bca5fb5c56f04a7d90789891fb59b68a142ca4071404e1", "price_eth": 0.0000000419164, "price_usd": 0.0000987838, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x4337043aedb812f09b4eb3682be2cd510d38217c", "signer_label": null, "trader": "0xbdc0206e3d049a0a66c5daac48d59eff637464bb", "trader_app": "fomo", "trader_label": null, "ts": 1793223733000, "tx": "0x8d48a051e84b1dea750e3b5a031c245ea37aed457bd4d18505ec3edba9bc16c0", "tx_index": 9, "type": "sell", "value_eth": 0.306579, "value_usd": 722.51, "via": [ "erc4337_entrypoint" ] } ], "meta": { "block": 100409745, "block_age_ms": 651, "block_ts": 1793225380000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 155, "next_cursor": "100393715-13", "safe_block": 100405028 } } ``` What this tells you - Three sells of $1,000.03, $1,902.31 and $722.51, all in the Uniswap v4 pool `0xe1cb1474a4c240a1e0bca5fb5c56f04a7d90789891fb59b68a142ca4071404e1` against ETH. - All three were made from FOMO app smart wallets: `trader_app: "fomo"`, `via: ["erc4337_entrypoint"]`, and `signer` (repeated in `executor`) is an ERC-4337 bundler such as `0x4337fa4d86d4b6a2634900effb713bf6fb685835`. The `trader` (for example `0xa4109b8d391723d8f6bcfc5d75e6996f61062f76`) is the smart wallet that actually sold. - `market_cap_usd_at_trade` fell from 98,783.8 to 76,509.6 in the 11 seconds between the two older sells, and was 36,980.1 at the newest, about 23 minutes later. - `fees.token_tax.pct` is 0 on two of them (no tax taken) and `null` on the other, where it wasn’t measured. [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Large%20sells%20of%20a%20meme%20token%2C%20made%20from%20smart%20wallets&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-token-trades%2F%23sockets-large-sells%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%2Ftrades%3Fside%3Dsell%26min_usd%3D500%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `id` | A stable trade id: block, transaction index and log index. | | `type` | `buy` or `sell`, from the trader's side. | | `amount_base`, `amount_quote` | Tokens traded and quote paid or received, in whole units. `quote` and `quote_symbol` name the quote asset. | | `value_usd`, `value_eth` | The trade's value when it happened. | | `price_usd`, `price_eth` | The token's price in this trade. | | `eth_usd_at_trade`, `market_cap_usd_at_trade` | ETH/USD and the token's market cap at that block. | | `trader`, `trader_label`, `trader_app` | The wallet whose balance changed, its label if known, and the app for app wallets (`fomo`). | | `via`, `signer`, `signer_label`, `executor` | Routers on the path, the transaction sender and its label, and `executor`: the sender when it traded on someone else's behalf, `null` when the trader sent it. | | `fees.gas` | `gas_used`, `gas_price_gwei`, `l2_eth`, `l1_eth`, `total_eth` and `usd`. | | `fees.token_tax.pct` | Token tax measured on this trade, in percent; `null` when not measured. | | `pool`, `dex`, `block`, `tx`, `tx_index`, `ts` | Where and when. | | `finality` | `latest`, `safe` or `finalized`. See [Finality](https://docs.crius.sh/concepts/finality/). | One transaction can contain several trades, for example a route through two pools, so don’t use `tx` as a unique key: use `id`. ## Filter the tape | Parameter | Example | Use | | --- | --- | --- | | `side` | `side=sell` | Only buys or only sells | | `min_usd` | `min_usd=500` | Whale watching: skip small trades | | `trader` | `trader=0xa4109b8d391723d8f6bcfc5d75e6996f61062f76` | One wallet’s trades in this token | | `app` | `app=fomo` | Only trades made through an app | | `from_ts`, `to_ts` | `from_ts=1793217600000` | A time window, unix ms | | `limit`, `cursor` | `limit=500` | Up to 500 per page; `meta.next_cursor` for the next | ## Use it in your app 1. **Show the tape on a token page** with `limit=50`, coloring `type` and linking `trader` to a wallet page. 2. **Label infrastructure, not traders.** Show `trader_app` or `via` as a small badge (“via FOMO”, “via Universal Router”) instead of the router as the buyer. 3. **Page back with `cursor`** to load older trades, or set `from_ts` and `to_ts` for a window. 4. **Stream new trades** over the [WebSocket](https://docs.crius.sh/guides/stream-trades-websocket/) instead of polling a busy token. ```python import requests token = "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" # sockets params = {"side": "sell", "min_usd": 500, "limit": 100} r = requests.get(f"https://api.crius.sh/v1/robinhood/token/{token}/trades", params=params, timeout=10) body = r.json() for t in body["data"]: how = t["trader_app"] or ", ".join(t["via"]) or "direct" print(f'{t["ts"]} {t["type"]} ${t["value_usd"]:,.2f} by {t["trader"]} ({how}), mcap ${t["market_cap_usd_at_trade"]:,.0f}') print("next page cursor:", body["meta"].get("next_cursor")) ``` Tape or candles? The tape has every trade, including dust and outliers. [Candles](https://docs.crius.sh/guides/get-ohlcv-candles/) leave those out of the price (not the volume), so a high on the tape can be above the candle high. Use the tape for exact history and the candles for charts. ## Frequently asked questions **How do I get the latest trades of a Robinhood Chain token?** Send `GET https://api.crius.sh/v1/robinhood/token/{address}/trades?limit=50`. The newest trade comes first. No API key is needed; for every new trade as it happens, use the [WebSocket stream](https://docs.crius.sh/guides/stream-trades-websocket/). **Who is the trader when a trade goes through a router or a smart wallet?** Crius attributes every trade to the address whose token balance actually changed. Routers and aggregators are listed in `via` and the transaction sender in `signer`; `executor` repeats the sender when it isn't the trader (a relayer or bundler sent the trade for someone else) and is `null` otherwise. For an ERC-4337 smart-wallet trade, `trader` is the smart wallet and `signer` is the bundler. **How is the USD value of a trade computed?** When the trade is indexed: the quote amount times the quote's USD price at that block, from on-chain markets. `eth_usd_at_trade` is that block's ETH/USD rate. Values from the chain's first days (before about June 24, 2026) are estimates, because the WETH/USDG pool was new and thin. **Can I get only large trades, or one wallet's trades?** Yes. `min_usd=1000` keeps trades of $1,000 or more, `side=buy` or `side=sell` one side, and `trader={wallet}` one wallet's trades in this token. For a wallet's trades across all tokens, use [wallet trades](https://docs.crius.sh/guides/get-wallet-trade-history/) (Starter plan). **How far back does the trade history go?** To the token's first trade. Page back with `meta.next_cursor`, or jump to a period with `from_ts` and `to_ts` (unix ms). Each page holds up to 500 trades. ## Related [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) [Guide **Token activity feed** Get every event of a Robinhood Chain token in one feed, from trades and transfers to liquidity, burns, owner actions, locks and graduation, with real examples. Read](https://docs.crius.sh/guides/get-token-activity-feed/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Wallet trade history** List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time. Read](https://docs.crius.sh/guides/get-wallet-trade-history/) [Guide **DEX data** Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades. Read](https://docs.crius.sh/guides/robinhood-chain-dex-data/) --- # Find a token's top traders and their PnL > Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Source: https://docs.crius.sh/guides/get-top-traders-pnl/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/traders?sort=pnl&window=all` (Free plan, 5 credits). Each trader has `pnl_usd`, `realized_pnl_usd`, `unrealized_pnl_usd`, `roi_pct`, `buys`, `sells`, `bought_usd`, `sold_usd`, `gas_spent_usd`, `holding_time_s` and `tags` (`dev`, `sniper`, `whale`, `smart_account`, `fomo`…). PnL uses average cost with USD at trade time. [GET `/token/{address}/traders`](https://docs.crius.sh/reference/holders/top-traders/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET `/wallet/{address}`](https://docs.crius.sh/reference/wallets/wallet-profile/) A token’s top traders are the wallets that made the most from trading it. Crius adds up every buy and sell each wallet made in the token, attributed to the real trader behind routers, bots and smart accounts, and ranks them by profit, volume, number of buys or return. Each trader comes with its realized and unrealized PnL, what it paid and received in USD and ETH, gas spent, how long it held, and tags that say whether it was the dev, a sniper or a whale. ## Get the leaderboard in one call Example [Free plan · 5 credits](https://docs.crius.sh/reference/holders/top-traders/) ### CHARGE's top three traders: $1,302.88, $994.45 and $838 Who made the most trading Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8), and how? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 91 lines (arrays trimmed)** ```json { "data": [ { "address": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "avg_buy_usd": 0.00000842823, "avg_sell_usd": 0.0000532304, "balance": 0, "bought": 29080767.335830362668108408, "bought_eth": 0.099, "bought_usd": 245.099, "buys": 1, "cost_basis": "complete", "first_trade_ts": 1791983208000, "gas_spent_usd": 0.0875722, "holding_time_s": 118676, "last_trade_ts": 1792101884000, "pnl_usd": 1302.88, "rank": 1, "realized_pnl_usd": 1302.88, "roi_pct": 531.573, "sells": 7, "sold": 29080767.335830362668108408, "sold_eth": 0.635695, "sold_usd": 1547.98, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x7c79ad74d36dea424d08a5d326271bf03da81f6a", "avg_buy_usd": 0.00000790248, "avg_sell_usd": 0.0000343631, "balance": 0, "bought": 46475393.982901663958413733, "bought_eth": 0.1485, "bought_usd": 367.271, "buys": 2, "cost_basis": "complete", "first_trade_ts": 1791983183000, "gas_spent_usd": 0.0712204, "holding_time_s": 125872, "last_trade_ts": 1792109055000, "pnl_usd": 994.45, "rank": 2, "realized_pnl_usd": 994.45, "roi_pct": 270.767, "sells": 4, "sold": 37582304.39247174197236032, "sold_eth": 0.528147, "sold_usd": 1291.44, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x83055f3e7be4e289733bbc8c7bd42a6443177f07", "avg_buy_usd": 0.000023621, "avg_sell_usd": 0.0000471805, "balance": 0, "bought": 35569497.20243776424709037, "bought_eth": 0.3465, "bought_usd": 840.189, "buys": 3, "cost_basis": "complete", "first_trade_ts": 1791988168000, "gas_spent_usd": 0.0631376, "holding_time_s": 4039, "last_trade_ts": 1791992207000, "pnl_usd": 838, "rank": 3, "realized_pnl_usd": 838, "roi_pct": 99.7395, "sells": 3, "sold": 35569497.20243776424709037, "sold_eth": 0.691944, "sold_usd": 1678.19, "tags": [], "unrealized_pnl_usd": 0 } ], "meta": { "block": 100406823, "block_age_ms": 829, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 64, "next_cursor": "3", "pnl_method": "average cost; USD at trade time; unrealized at current price", "safe_block": 100401329, "window": "all" } } ``` What this tells you - `meta.window: "all"` and `meta.pnl_method: "average cost; USD at trade time; unrealized at current price"`: the defaults rank by total PnL over the token’s whole history. - Rank 1, `0x9e38fedc40987c19396cc20ea59eb2b1b7928881`: one buy of 0.099 ETH (`bought_usd: 245.099`), seven sells for `sold_usd: 1547.98`, `pnl_usd: 1302.88`, `roi_pct: 531.573`. `balance: 0`, so it’s all realized. It held for `holding_time_s: 118676` (about 33 hours, first to last trade) and paid `gas_spent_usd: 0.0875722`. - Rank 3, `0x83055f3e7be4e289733bbc8c7bd42a6443177f07`, doubled its money (`roi_pct: 99.7395`) in `holding_time_s: 4039`, about 67 minutes. Three buys, three sells, $840.189 in and $1,678.19 out. - Rank 2, `0x7c79ad74d36dea424d08a5d326271bf03da81f6a`, bought 46,475,393 tokens and sold only 37,582,304, yet `balance` is 0: the rest left the wallet by transfer. Those tokens count neither as a sale nor as a loss, so its PnL is the realized profit on what it sold, `994.45`. - All three have `tags: []` (no dev, sniper or whale tag) and `cost_basis: "complete"`. Ranks 1 and 2 first traded about six minutes after CHARGE was created on Pons (2026-10-14 13:00 UTC): early, but not snipers. [Top traders reference](https://docs.crius.sh/reference/holders/top-traders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20top%20three%20traders%3A%20%241%2C302.88%2C%20%24994.45%20and%20%24838&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-top-traders-pnl%2F%23charge-top-traders%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ftraders%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How the PnL is computed For each trader and token, using the USD value of every trade at the time it happened: - **Average buy price** = `bought_usd` ÷ tokens bought (`avg_buy_usd`). - **Realized PnL** = `sold_usd` − tokens sold × average buy price. - **Unrealized PnL** = current value of the balance − its cost at the average buy price. - **`pnl_usd`** = realized + unrealized. **`roi_pct`** = `pnl_usd` ÷ `bought_usd` × 100. Check it on rank 1: 1,547.98 − 245.099 = 1,302.88, and 1,302.88 ÷ 245.099 = 531.57%. Gas isn’t subtracted from PnL; it’s in `gas_spent_usd` so you can net it out yourself. [How PnL works](https://docs.crius.sh/concepts/pnl/) covers the edge cases. ## What the fields mean | Field | Meaning | | --- | --- | | `rank`, `address`, `tags` | Position in the ranking, the trader, and its wallet tags. | | `buys`, `sells` | Number of trades on each side in the window. | | `bought`, `sold`, `balance` | Tokens bought, sold, and held now. | | `bought_usd`, `sold_usd`, `bought_eth`, `sold_eth` | What the buys cost and the sells returned, in USD at trade time and in ETH (ETH- and WETH-quoted trades). | | `avg_buy_usd`, `avg_sell_usd` | Average price per token on each side. | | `realized_pnl_usd`, `unrealized_pnl_usd`, `pnl_usd` | PnL on what was sold, on what's still held, and the total. | | `roi_pct` | `pnl_usd` as a percentage of `bought_usd`. | | `cost_basis` | `complete`, or `unknown (sold tokens received by transfer)` when PnL can't be computed. | | `gas_spent_usd` | Gas (L2 + L1) of the trader's trades in this token; `null` for tokens with more than 2M trades in the window. | | `first_trade_ts`, `last_trade_ts`, `holding_time_s` | First and last trade, and how long the position was open: until now if it still holds, else first to last trade. | ## Filter and sort - `sort`: `pnl` (default), `realized_pnl`, `volume`, `buys`, `roi`. - `window`: `1h`, `24h`, `7d` or `all` (default). Only trades in the window count. - `tag`: only traders with any of these tags, for example `tag=smart_account` or `tag=fomo`. - `exclude`: leave out tags, for example `exclude=dev,sniper,exchange` for outside traders only. - `include_contracts=true`: add program contracts (bots, vaults, routers), which are left out by default. Smart accounts are wallets and always included unless excluded. - `limit` (up to 500, default 50) and `cursor` (`meta.next_cursor`) to page. The ranking is computed over the 3,000 traders with the most volume in the window. ## Use it in your app 1. **Get a Free key.** `/traders` needs the Free plan and costs 5 credits per call. Send it in the `x-api-key` header. 2. **Pick the question.** “Who won?” is `sort=pnl`. “Who’s winning today?” is `window=24h`. “Who’s actually trading it?” is `sort=volume`. Copy-trading lists usually add `exclude=dev,sniper`. 3. **Show how, not just how much.** `buys`, `sells`, `holding_time_s` and `roi_pct` tell a sniper’s quick flip apart from a patient position. 4. **Drill into one trader.** The [trade tape](https://docs.crius.sh/reference/trades/trade-tape/) with `trader=
` lists that wallet’s trades in the token, and the [wallet profile](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) its PnL across every token. ```js // Top 10 outside traders of a token by PnL over the last 7 days. const token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"; const q = new URLSearchParams({ sort: "pnl", window: "7d", exclude: "dev,sniper,exchange", limit: "10" }); const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/traders?${q}`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); for (const t of data) { const hours = (t.holding_time_s / 3600).toFixed(1); console.log(t.rank, t.address, `PnL $${t.pnl_usd ?? "?"}`, `ROI ${t.roi_pct ?? "?"}%`, `${t.buys}/${t.sells}`, `${hours} h`, t.tags.join(",")); } ``` ## Frequently asked questions **How do I find the top traders of a Robinhood Chain token?** Call `/v1/robinhood/token/{address}/traders?sort=pnl&window=all`. Traders come back ranked by total PnL (realized plus unrealized). Use `window=24h` or `7d` for recent winners and `sort=volume` for the biggest traders whatever their result. **How is a trader's PnL calculated?** Average cost, in USD at the time of each trade. Realized PnL is what the trader got for its sells minus what those tokens cost at its average buy price. Unrealized PnL is the current value of what it still holds minus their cost. `pnl_usd` is the sum. Gas isn't subtracted: it's reported separately in `gas_spent_usd`. **How do I see only outside traders, without the dev and snipers?** Add `exclude=dev,sniper,exchange`. To look at one group only, use `tag`, for example `tag=smart_account` for EIP-7702 wallets or `tag=fomo` for FOMO app wallets. Program contracts (bots, vaults, routers) are left out by default; `include_contracts=true` adds them back. **Why is a trader's PnL \`null\`?** It sold more tokens than it bought, so part of what it sold came from a transfer and has no known cost. `cost_basis` then says `unknown (sold tokens received by transfer)`, and `pnl_usd`, `realized_pnl_usd`, `unrealized_pnl_usd` and `roi_pct` are `null`. They sort last when you rank by PnL or ROI. **Which plan does the top traders endpoint need?** The Free plan (a free API key), 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Wallet holdings & PnL** Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Read](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) [Guide **Wallet trade history** List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time. Read](https://docs.crius.sh/guides/get-wallet-trade-history/) [Guide **Diamond-hand holders** Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example. Read](https://docs.crius.sh/guides/find-diamond-hand-holders/) [Concept **PnL** How the Crius API computes realized and unrealized PnL, ROI, cost basis and win rate for Robinhood Chain traders and wallets, worked through on real trades. Read](https://docs.crius.sh/concepts/pnl/) [API reference **Top traders API** Traders of the token ranked by PnL, realized PnL, volume, buys or ROI over a window (1h, 24h, 7d, all), with wallet tags: dev, sniper, whale, smart\_account (EIP-7702 wallets), the app for app wallets Read](https://docs.crius.sh/reference/holders/top-traders/) --- # Get a wallet's holdings and PnL on Robinhood Chain > Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Source: https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/wallet/{address}?window=30d` (Starter plan, 5 credits). It returns `holdings[]` (token, `balance`, `value_usd`, `price_confidence`, per-token `pnl`), `native_balance` in ETH, and a `pnl` summary over the window (`realized_usd`, `unrealized_usd`, `total_usd`, `win_rate_pct`, `trades`, `volume_usd`, `gas_spent_usd`), plus `account_type` and `profile.tags`. [GET `/wallet/{address}`](https://docs.crius.sh/reference/wallets/wallet-profile/) [GET `/wallet/{address}/trades`](https://docs.crius.sh/reference/wallets/wallet-trades/) [GET `/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/) A wallet profile is everything a Robinhood Chain address holds and has earned: its tokens with their USD value, its ETH balance, its realized and unrealized PnL over a window, its win rate and gas spent, and what kind of account it is. Crius reads the balances on-chain at one block and computes PnL from every trade attributed to the wallet, so a portfolio app or a wallet-scoring tool gets the whole picture in one call. ## Get the profile in one call Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-profile/) ### CHARGE's creator: 0.71 ETH, two fake USDG tokens, no trades What does the wallet that launched Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) hold, and has it traded in the last 30 days? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 84 lines (arrays trimmed)** ```json { "data": { "account_type": "smart_account", "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "delegate": "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b", "holdings": [ { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500064, "value_usd": 0.0117789 }, { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0x06993ae1230d3755b54f25022028daa66772bc3d", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500061, "value_usd": 0.0117789 } ], "holdings_truncated": false, "holdings_value_usd": 0.0235578, "is_contract": false, "label": null, "native_balance": 0.71473787532832551, "native_value_usd": 1683.56, "pnl": { "avg_hold_time_s": null, "best_trade": null, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 0.198772, "realized_usd": 0, "tokens_traded": 0, "tokens_with_known_cost": 0, "total_usd": 0, "trades": 0, "unrealized_usd": 0, "volume_usd": 0, "win_rate_pct": null, "window": "30d", "worst_trade": null }, "profile": { "first_seen_block": 91351250, "first_seen_ts": 1792283372000, "fresh": false, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "block": 87601233, "label": "bridge:Relay solver", "ts": 1791903516300 }, "history": "complete", "tags": [ "dev", "smart_account" ], "tx_count": 14, "wallet_age_days": 10.8994 } }, "meta": { "balances_block": 100406864, "block": 100406864, "block_age_ms": 1301, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 59, "safe_block": 100401329 } } ``` What this tells you - `account_type: "smart_account"` with `delegate: "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b"`: an EIP-7702 wallet whose code delegates to that contract. `is_contract` is `false` and `profile.tags` is `["dev", "smart_account"]`: it created a launchpad token. - `native_balance: 0.71473787532832551` ETH, worth `native_value_usd: 1683.56`. That’s nearly all of its value. - Both holdings say `symbol: "USDG"`, but neither is USDG. Real USDG is `0x5fc5360d0400a0fd4f2af552add042d716f1d168`; these are `0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775` and `0x06993ae1230d3755b54f25022028daa66772bc3d`. 25 of each are worth `value_usd: 0.0117789` at `price_confidence: "low"`, and `pnl` is `null`: they were sent to the wallet, not bought. Always identify tokens by address. - `pnl.window: "30d"` (the default): `trades: 0`, `tokens_traded: 0`, `total_usd: 0` and `win_rate_pct: null`. It still paid `gas_spent_usd: 0.198772`, because `gas_scope` is “all transactions sent by the wallet in the window”, not only trades. - `profile.funded_by` is `0xd782268f600403843484b70710daee6846fc0db8`, labeled `bridge:Relay solver`, with 0.008148386337868892 ETH: the wallet’s first ETH came over the Relay bridge. `profile.tx_count: 14`. - `meta.balances_block: 100406864`: the ETH and token balances were read on-chain at that block. [Wallet profile reference](https://docs.crius.sh/reference/wallets/wallet-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20creator%3A%200.71%20ETH%2C%20two%20fake%20USDG%20tokens%2C%20no%20trades&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-pnl-and-holdings%2F%23creator-wallet%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How PnL is calculated Per token, using the USD value of each trade when it happened (average cost): - **Realized** = USD received from sells − tokens sold × average buy price. - **Unrealized** = balance × current price − cost of the balance at the average buy price. - The `pnl` summary adds both over every token traded in the `window` (`1d`, `7d`, `30d` by default, or `all`). An unrealized loss in practice, from the [holder snapshot](https://docs.crius.sh/guides/get-historical-holders/): `0xe683eb5c66b0c55c54ce45d46a3bf0a69d809c8f` held 29,879,481 CHARGE that cost it `cost_basis_usd: 515.975` and were worth `value_usd: 180.252` at that moment: an unrealized PnL of −$335.724. Tokens a wallet sold more of than it bought (some arrived by transfer) have no known cost: they’re left out of the totals and the win rate, and `tokens_with_known_cost` says how many were counted. The details and edge cases are in [How PnL works](https://docs.crius.sh/concepts/pnl/). ## What the fields mean | Field | Meaning | | --- | --- | | `account_type`, `delegate` | `eoa`, `smart_account` (EIP-7702, with the contract it delegates to) or `contract`. | | `label` | Known name of the address (an exchange, a bridge, an app wallet), or `null`. | | `native_balance`, `native_value_usd` | ETH balance and its USD value. | | `holdings[]` | Tokens with a balance, most valuable first (up to 200): `token` (address, symbol, logo), `balance`, `value_usd`, `value_eth`, `price_confidence`, `pnl`. | | `holdings[].price_confidence` | How far to trust `value_usd`: `high`, `medium` (price pool under $10k liquidity), `low` (thin pool) or `none` (no price). | | `holdings_value_usd`, `holdings_truncated` | Total value of the token holdings; `true` when the address touched too many tokens to price them all. | | `pnl.realized_usd`, `unrealized_usd`, `total_usd` | PnL over the window. | | `pnl.win_rate_pct` | Share of tokens with known cost that ended in profit. | | `pnl.trades`, `tokens_traded`, `tokens_with_known_cost`, `volume_usd` | Activity in the window. | | `pnl.best_trade`, `worst_trade`, `avg_hold_time_s` | The tokens with the highest and lowest PnL, and the average time from first to last trade per token. | | `pnl.gas_spent_usd`, `gas_scope` | Gas paid in the window, for every transaction the wallet sent. | | `profile.tags` | `dev` (created a launchpad token), `fresh` (under a day old), `smart_account`, `contract`, or the app for app wallets (`fomo`). | | `profile.funded_by` | The wallet's first funder: `address`, `label`, `amount_eth`, `block`, `ts`. | | `profile.tx_count`, `history` | Transactions sent, and whether the whole history is indexed. | ## Use it in your app 1. **Get a Starter key.** `/wallet/{address}` needs the Starter plan and costs 5 credits per call. Send it in the `x-api-key` header. 2. **Hide spam.** Add `min_value_usd=1` (or more) so airdropped lookalike tokens don’t clutter the portfolio, and match tokens by `token.address`, never by symbol. 3. **Pick the window your users expect.** `window=7d` for a weekly card, `all` for lifetime PnL. Show `tokens_with_known_cost` next to the win rate so readers know what it’s based on. 4. **Go deeper when needed.** Each trade is in [wallet trades](https://docs.crius.sh/guides/get-wallet-trade-history/), and who funded the wallet in [connected wallets](https://docs.crius.sh/guides/find-connected-wallets/). ```python import os, requests wallet = "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" r = requests.get( f"https://api.crius.sh/v1/robinhood/wallet/{wallet}", params={"window": "7d", "min_value_usd": 1}, headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) d = r.json()["data"] p = d["pnl"] print(f"{d['account_type']} {d['profile']['tags']}: {d['native_balance']} ETH (${d['native_value_usd']})") print(f"{p['window']} PnL ${p['total_usd']} on {p['trades']} trades, win rate {p['win_rate_pct']}%") for h in d["holdings"]: print(h["token"]["symbol"], h["token"]["address"], h["balance"], f"${h['value_usd']}", h["price_confidence"]) ``` ## Frequently asked questions **How is wallet PnL calculated?** Per token, with average cost in USD at the time of each trade. Realized PnL is what the sells returned minus the cost of the tokens sold at the wallet's average buy price; unrealized PnL is the current value of what it still holds minus its cost. The `pnl` summary adds these up over the tokens traded in the `window`. Gas is reported separately in `gas_spent_usd`, not subtracted. **How do I get every token a wallet holds?** `/wallet/{address}` lists up to 200 holdings with a balance, most valuable first, each checked against the token's `balanceOf`. Add `min_value_usd=1` to hide dust and spam tokens. The ETH balance is separate, in `native_balance` and `native_value_usd`. **What does \`win\_rate\_pct\` mean?** The share of tokens traded in the window that ended in profit (realized plus unrealized PnL above zero), counting only tokens whose cost is known (`tokens_with_known_cost`). It's per token, not per trade. It's `null` when the wallet traded nothing in the window. **Why does a holding have \`pnl: null\`?** The wallet never bought that token, or sold more than it bought: it arrived by transfer or airdrop, so there is no cost to measure against. That's typical of spam tokens sent to active wallets. **Which plan does the wallet profile need?** The Starter plan or higher, 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Wallet trade history** List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time. Read](https://docs.crius.sh/guides/get-wallet-trade-history/) [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Wallet token balances** Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices. Read](https://docs.crius.sh/guides/get-wallet-token-balances/) [Concept **PnL** How the Crius API computes realized and unrealized PnL, ROI, cost basis and win rate for Robinhood Chain traders and wallets, worked through on real trades. Read](https://docs.crius.sh/concepts/pnl/) [Use case **Wallets & portfolios** What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens. Read](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) [API reference **Wallet profile API** Holdings with USD value, realized and unrealized PnL over a window (1d, 7d, 30d, all), win rate and wallet tags. Read](https://docs.crius.sh/reference/wallets/wallet-profile/) --- # Get wallet token balances on Robinhood Chain (balances API) > Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices. Source: https://docs.crius.sh/guides/get-wallet-token-balances/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/wallet/{address}?min_value_usd=1` (Starter plan, 5 credits). It returns the ETH balance (`native_balance`, `native_value_usd`) and up to 200 `holdings[]`, most valuable first, each with `token.address`, `balance` in whole tokens, `value_usd`, `value_eth` and `price_confidence`, read on-chain at `meta.balances_block`. For one token's balances across all wallets use `/token/{address}/holders` (Free plan); to revalue balances you already have, `GET /v1/robinhood/prices?tokens=...` (anonymous, up to 100 tokens). [GET `/wallet/{address}`](https://docs.crius.sh/reference/wallets/wallet-profile/) [GET `/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) [GET `/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) A wallet’s token balances are how much of each ERC-20 it holds right now, plus its native ETH. The Crius balances API answers that for any Robinhood Chain address in one call: it finds every token the wallet has ever received, reads the balances on-chain at one block, prices them in USD from on-chain pools and returns them most valuable first. You don’t need a token list or one `balanceOf` call per token. This page is about balances; for the same call’s profit and loss numbers, see [wallet holdings and PnL](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/). ## Get a wallet’s balances in one call Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-profile/) ### A trader holding $49,722 of USDG and five tokenized stocks What does 0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7 hold on Robinhood Chain, and what is it worth? Hide anything under $1. GET/v1/robinhood/wallet/0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7?min\_value\_usd=1 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7?min_value_usd=1" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7?min_value_usd=1", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7?min_value_usd=1", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 143 lines (arrays trimmed)** ```json { "data": { "account_type": "eoa", "address": "0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7", "delegate": null, "holdings": [ { "balance": 49721.880472, "pnl": null, "price_confidence": "high", "token": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "value_eth": 21.0906, "value_usd": 49721.9 }, { "balance": 18.405208788009058717, "pnl": null, "price_confidence": "high", "token": { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "logo": null, "symbol": "NVDA" }, "value_eth": 1.67342, "value_usd": 3945.15 }, { "balance": 4.10654992139340626, "pnl": null, "price_confidence": "high", "token": { "address": "0xd5f3879160bc7c32ebb4dc785f8a4f505888de68", "logo": null, "symbol": "QQQ" }, "value_eth": 1.25568, "value_usd": 2960.33 }, { "balance": 8.496965059200292092, "pnl": null, "price_confidence": "high", "token": { "address": "0xb0992820e760d836549ba69bc7598b4af75dee03", "logo": null, "symbol": "ORCL" }, "value_eth": 0.509659, "value_usd": 1201.54 }, { "balance": 6.004187798458070634, "pnl": null, "price_confidence": "high", "token": { "address": "0x5e81213613b6b86eab4c6c50d718d34359459786", "logo": null, "symbol": "TTWO" }, "value_eth": 0.504464, "value_usd": 1189.29 }, { "balance": 1.117684815247203549, "pnl": { "avg_entry_usd": 126.473, "realized_usd": 147.475, "unrealized_usd": 721.987 }, "price_confidence": "high", "token": { "address": "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", "logo": null, "symbol": "SPY" }, "value_eth": 0.366205, "value_usd": 863.344 } ], "holdings_truncated": false, "holdings_value_usd": 70914, "is_contract": false, "label": null, "native_balance": 17.143712569865815681, "native_value_usd": 40417, "pnl": { "avg_hold_time_s": 20739, "best_trade": { "logo": "https://api.crius.sh/v1/robinhood/logo/0x448168b7c3736fb55c552dce72d5f1f5b30d77cb.png?size=128", "pnl_usd": 2326.69, "symbol": "Suited", "token": "0x448168b7c3736fb55c552dce72d5f1f5b30d77cb" }, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 147.202, "realized_usd": 73090.6, "tokens_traded": 2067, "tokens_with_known_cost": 2052, "total_usd": 75466.3, "trades": 15076, "unrealized_usd": 2375.68, "volume_usd": 2801387, "win_rate_pct": 42.3002, "window": "30d", "worst_trade": { "logo": "https://api.crius.sh/v1/robinhood/logo/0x90e8fa19ae1a01431da01c6f80b3bc5cebb19438.png?size=128", "pnl_usd": -428.531, "symbol": "TMF", "token": "0x90e8fa19ae1a01431da01c6f80b3bc5cebb19438" } }, "profile": { "first_seen_block": 91379092, "first_seen_ts": 1792286196200, "fresh": false, "funded_by": { "address": "0x07ae8551be970cb1cca11dd7a11f47ae82e70e67", "amount_eth": 20.297518745318700439, "block": 54422474, "label": null, "ts": 1788540817400 }, "history": "complete", "tags": [], "tx_count": 170001, "wallet_age_days": 10.9215 } }, "meta": { "balances_block": 100452982, "block": 100452982, "block_age_ms": 993, "block_ts": 1793229813000, "chain": "robinhood", "finalized_block": 100442370, "lag_ms": 53, "safe_block": 100446224 } } ``` What this tells you - `native_balance: 17.143712569865815681` ETH, worth `native_value_usd: 40417`. ETH is never in `holdings[]`: add it yourself for a total. - The largest holding is USDG (`0x5fc5360d0400a0fd4f2af552add042d716f1d168`, the real one): `balance: 49721.880472`, `value_usd: 49721.9`. Its `value_eth: 21.0906` is the same value expressed in ETH. - Then five tokenized stocks, each with `price_confidence: "high"`: 18.405208788009058717 NVDA ($3,945.15), 4.10654992139340626 QQQ ($2,960.33), 8.496965059200292092 ORCL ($1,201.54), 6.004187798458070634 TTWO ($1,189.29) and 1.117684815247203549 SPY ($863.344). Balances keep full precision, so fractional stock tokens are exact. - `holdings_value_usd: 70914` totals every holding worth $1 or more. The six rows shown add up to about $59,882, so the rest is in smaller holdings further down the list. With `native_value_usd`, the wallet is worth about $111,331. - `holdings_truncated: false`: every token the wallet touched was priced. - `meta.balances_block: 100452982`: the ETH and token balances were all read at that block, so they are consistent with each other. [Wallet profile reference](https://docs.crius.sh/reference/wallets/wallet-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20trader%20holding%20%2449%2C722%20of%20USDG%20and%20five%20tokenized%20stocks&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-token-balances%2F%23active-wallet%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7%3Fmin_value_usd%3D1%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-profile/) ### A wallet whose only tokens are lookalikes CHARGE's creator (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) shows two USDG balances. Are they real? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 84 lines (arrays trimmed)** ```json { "data": { "account_type": "smart_account", "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "delegate": "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b", "holdings": [ { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500064, "value_usd": 0.0117789 }, { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0x06993ae1230d3755b54f25022028daa66772bc3d", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500061, "value_usd": 0.0117789 } ], "holdings_truncated": false, "holdings_value_usd": 0.0235578, "is_contract": false, "label": null, "native_balance": 0.71473787532832551, "native_value_usd": 1683.56, "pnl": { "avg_hold_time_s": null, "best_trade": null, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 0.198772, "realized_usd": 0, "tokens_traded": 0, "tokens_with_known_cost": 0, "total_usd": 0, "trades": 0, "unrealized_usd": 0, "volume_usd": 0, "win_rate_pct": null, "window": "30d", "worst_trade": null }, "profile": { "first_seen_block": 91351250, "first_seen_ts": 1792283372000, "fresh": false, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "block": 87601233, "label": "bridge:Relay solver", "ts": 1791903516300 }, "history": "complete", "tags": [ "dev", "smart_account" ], "tx_count": 14, "wallet_age_days": 10.8994 } }, "meta": { "balances_block": 100406864, "block": 100406864, "block_age_ms": 1301, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 59, "safe_block": 100401329 } } ``` What this tells you - Both holdings say `symbol: "USDG"` with `balance: 25`, but their addresses are `0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775` and `0x06993ae1230d3755b54f25022028daa66772bc3d`, not USDG’s `0x5fc5360d0400a0fd4f2af552add042d716f1d168`. - Each is valued at `value_usd: 0.0117789` with `price_confidence: "low"`: 25 “dollars” worth about one cent. This request has no `min_value_usd`, so they show up; with `min_value_usd=1` they would be hidden. - The real value is the ETH: `native_balance: 0.71473787532832551`, `native_value_usd: 1683.56`, against `holdings_value_usd: 0.0235578`. [Wallet profile reference](https://docs.crius.sh/reference/wallets/wallet-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20wallet%20whose%20only%20tokens%20are%20lookalikes&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-token-balances%2F%23lookalike-balances%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Value balances you already have Balances change only when the wallet moves tokens; prices change every block. If you already store a wallet’s balances (from an earlier `/wallet` call or your own indexer), refresh their value with batch prices instead of calling `/wallet` again. It’s on the anonymous plan and takes up to 100 tokens per call. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-prices/) ### Prices for the six holdings above, in one call What are USDG, NVDA, QQQ, ORCL, TTWO and SPY worth right now, so I can revalue the wallet's balances? GET/v1/robinhood/prices?tokens=0x5fc5360d0400a0fd4f2af552add042d716f1d168,0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0xd5f3879160bc7c32ebb4dc785f8a4f505888de68,0xb0992820e760d836549ba69bc7598b4af75dee03,0x5e81213613b6b86eab4c6c50d718d34359459786,0x117cc2133c37b721f49de2a7a74833232b3b4c0c **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/prices?tokens=0x5fc5360d0400a0fd4f2af552add042d716f1d168,0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0xd5f3879160bc7c32ebb4dc785f8a4f505888de68,0xb0992820e760d836549ba69bc7598b4af75dee03,0x5e81213613b6b86eab4c6c50d718d34359459786,0x117cc2133c37b721f49de2a7a74833232b3b4c0c" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/prices?tokens=0x5fc5360d0400a0fd4f2af552add042d716f1d168,0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0xd5f3879160bc7c32ebb4dc785f8a4f505888de68,0xb0992820e760d836549ba69bc7598b4af75dee03,0x5e81213613b6b86eab4c6c50d718d34359459786,0x117cc2133c37b721f49de2a7a74833232b3b4c0c"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/prices?tokens=0x5fc5360d0400a0fd4f2af552add042d716f1d168,0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec,0xd5f3879160bc7c32ebb4dc785f8a4f505888de68,0xb0992820e760d836549ba69bc7598b4af75dee03,0x5e81213613b6b86eab4c6c50d718d34359459786,0x117cc2133c37b721f49de2a7a74833232b3b4c0c", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 74 lines (arrays trimmed)** ```json { "data": { "0x117cc2133c37b721f49de2a7a74833232b3b4c0c": { "change_24h_pct": 0.732612, "confidence": "high", "eth": 0.327526, "liquidity_usd": 3065474, "logo": null, "source_pool": "0xfe2a80bb5618fd14984b92ca6d45bf5ba67443ddb1435e28b2e48df2fc1526cd", "symbol": "SPY", "usd": 772.439 }, "0x5e81213613b6b86eab4c6c50d718d34359459786": { "change_24h_pct": -2.69804, "confidence": "high", "eth": 0.0839878, "liquidity_usd": 71756.6, "logo": null, "source_pool": "0xc9dad63b6fb9afe1fe888ebc7b023c587c58b9498f5bd17166226c0995dbc4eb", "symbol": "TTWO", "usd": 198.077 }, "0x5fc5360d0400a0fd4f2af552add042d716f1d168": { "change_24h_pct": null, "confidence": "high", "eth": 0.000424015, "liquidity_usd": 10302570, "logo": null, "source_pool": "0xbac3aa3b91584a53a579b3c999a56756e954e59247e497bad1d25a4334bde551", "symbol": "USDG", "usd": 1 }, "0xb0992820e760d836549ba69bc7598b4af75dee03": { "change_24h_pct": 8.82982, "confidence": "high", "eth": 0.0599593, "liquidity_usd": 222938, "logo": null, "source_pool": "0xc2ce4784e1e72cf0221b51b30c8aaadf6c0b12863cf03ab3687854fb7b1d850a", "symbol": "ORCL", "usd": 141.408 }, "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec": { "change_24h_pct": -1.46967, "confidence": "high", "eth": 0.0908873, "liquidity_usd": 1420235, "logo": null, "source_pool": "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3", "symbol": "NVDA", "usd": 214.349 }, "0xd5f3879160bc7c32ebb4dc785f8a4f505888de68": { "change_24h_pct": 0.126576, "confidence": "high", "eth": 0.305663, "liquidity_usd": 1425197, "logo": null, "source_pool": "0x8493982435e4273028008cd181c84c0d6a548f96792fdb5acddcbb6a8c82d305", "symbol": "QQQ", "usd": 720.879 } }, "meta": { "block": 100454103, "block_age_ms": 745, "block_ts": 1793229926000, "chain": "robinhood", "finalized_block": 100442370, "lag_ms": 45, "missing": [], "safe_block": 100446224 } } ``` What this tells you - `data` is keyed by token address: `usd: 214.349` for NVDA, `720.879` for QQQ, `141.408` for ORCL, `198.077` for TTWO, `772.439` for SPY and `1` for USDG, all with `confidence: "high"`. - Balance × `usd` gives the value: 1.117684815247203549 SPY × 772.439 = $863.34, the same as the wallet call’s `value_usd: 863.344` (this capture is about two minutes later, at `meta.block` 100454103). - `change_24h_pct` lets you show a daily move per holding: ORCL is up 8.82982%, TTWO down 2.69804%. USDG’s is `null`. - `meta.missing: []`: every requested token had a price. Unknown addresses would be listed there instead of in `data`. [Batch prices reference](https://docs.crius.sh/reference/tokens/batch-prices/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Prices%20for%20the%20six%20holdings%20above%2C%20in%20one%20call&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-token-balances%2F%23revalue-balances%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fprices%3Ftokens%3D0x5fc5360d0400a0fd4f2af552add042d716f1d168%2C0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%2C0xd5f3879160bc7c32ebb4dc785f8a4f505888de68%2C0xb0992820e760d836549ba69bc7598b4af75dee03%2C0x5e81213613b6b86eab4c6c50d718d34359459786%2C0x117cc2133c37b721f49de2a7a74833232b3b4c0c%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Balances of one token across wallets The `/wallet` call answers “what does this wallet hold”. The opposite question, “who holds this token, and how much”, is the [holders](https://docs.crius.sh/guides/get-token-holders/) endpoint: `GET /v1/robinhood/token/{address}/holders` ranks up to 500 wallets by balance. In the captured `holders` sample for Charge AI (`0x7b8892cea949bc60d494681d1bc3ea96071ab0b8`, request `?limit=5&exclude=infra`), the largest real holder `0x1860e8b874ed7742ae5459af731687ecb576c9fd` has `balance: 28729479.389247917189540117` CHARGE, `pct: 2.87295` of supply, worth `value_usd: 111.806`. Use it when you track one token (an airdrop list, a holder leaderboard) and `/wallet` when you track one address. | Question | Call | Plan, credits | | --- | --- | --- | | Every token one wallet holds, with USD value | `GET /wallet/{address}?min_value_usd=1` | Starter, 5 | | Current prices for balances you already know | `GET /prices?tokens=...` or `POST /prices` | Anonymous, 1 | | Every wallet holding one token, by balance | `GET /token/{address}/holders?limit=500` | Free, 2 | | One token's holders at a past block or time | `GET /token/{address}/holders/snapshot?at=...` | Free, 5 | ## What the balance fields mean | Field | Meaning | | --- | --- | | `native_balance`, `native_value_usd` | ETH balance in ETH, and its USD value. Not part of `holdings[]` or `holdings_value_usd`. | | `holdings[].token` | `address`, `symbol` and `logo`. Identify tokens by `address`: symbols are not unique. | | `holdings[].balance` | Balance in whole tokens (the token's decimals already applied), as an exact decimal. | | `holdings[].value_usd`, `value_eth` | Balance × the token's current price, in USD and in ETH. | | `holdings[].price_confidence` | `high`, `medium`, `low` or `none`: how far to trust `value_usd`. See [token prices](https://docs.crius.sh/concepts/token-prices/). | | `holdings_value_usd` | Total `value_usd` of the holdings that pass `min_value_usd`. | | `holdings_truncated` | `true` when the address touched too many tokens to price them all (pool and router contracts). | | `meta.balances_block` | The block every balance was read at. | `holdings[]` is sorted by `value_usd`, highest first, and holds at most 200 rows. `min_value_usd` drops every row worth less than the threshold, and that includes tokens with no price at all, so leave it out if you need unpriced tokens too. ## Use it in your app 1. **Get a Starter key.** `/wallet/{address}` needs the Starter plan and costs 5 credits per call; send the key in the `x-api-key` header. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). 2. **Load balances once per wallet.** Call `/wallet/{address}?min_value_usd=1` when the user opens a portfolio, and store `holdings[].token.address` and `balance`. 3. **Refresh value cheaply.** Every few seconds, send the stored addresses to `/prices` (up to 100 per call) and multiply. Call `/wallet` again only when the wallet sends or receives tokens. 4. **Show trust, not only numbers.** Grey out holdings with `price_confidence` `low` or `none`, and never treat a token as USDG or a stock because of its symbol. ```js // Wallet balances with a total, then a cheap revaluation from batch prices. const wallet = "0x2a4d34cd09a36f59ae3bedc0880cd5da929321d7"; const headers = { "x-api-key": process.env.CRIUS_API_KEY }; const { data, meta } = await (await fetch( `https://api.crius.sh/v1/robinhood/wallet/${wallet}?min_value_usd=1`, { headers })).json(); console.log(`block ${meta.balances_block}: ${data.native_balance} ETH ($${data.native_value_usd})`); for (const h of data.holdings) { console.log(h.token.symbol, h.token.address, h.balance, `$${h.value_usd}`, h.price_confidence); } console.log(`total $${data.native_value_usd + data.holdings_value_usd}`); // Later: revalue the same balances without another /wallet call. const tokens = data.holdings.map((h) => h.token.address).join(","); const prices = (await (await fetch(`https://api.crius.sh/v1/robinhood/prices?tokens=${tokens}`)).json()).data; const now = data.holdings.reduce((sum, h) => sum + Number(h.balance) * (prices[h.token.address]?.usd ?? 0), 0); console.log(`token holdings now $${now.toFixed(2)}`); ``` Balances and PnL come from the same call The `/wallet` response also has a `pnl` summary (realized and unrealized PnL, win rate, gas) and per-holding `pnl`; in the first example only SPY has one (`avg_entry_usd: 126.473`, `unrealized_usd: 721.987`). [Get a wallet’s holdings and PnL](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) explains those fields, and [wallet trade history](https://docs.crius.sh/guides/get-wallet-trade-history/) lists every trade behind them. ## Frequently asked questions **Is there a Robinhood Chain balances API?** Yes. `GET https://api.crius.sh/v1/robinhood/wallet/{address}` returns a wallet's ETH balance and every token it holds with a balance and USD value, in one call, without you having to know which tokens to ask for. It needs a Starter key (5 credits per call). Crius finds the tokens from the wallet's transfer history and reads the balances on-chain at one block. **How do I get all token balances of a wallet on Robinhood Chain?** Call `/wallet/{address}?min_value_usd=1`. `holdings[]` lists up to 200 tokens with a balance, most valuable first: `token.address`, `token.symbol`, `balance` (decimals already applied), `value_usd` and `price_confidence`. The ETH balance is separate, in `native_balance`. `holdings_value_usd` is the total of the token holdings. **Are the balances read from the chain?** Yes. The most valuable holdings are checked against each token's own `balanceOf`, and the ETH balance is read with `eth_getBalance`, both at the block in `meta.balances_block`. Tokens whose `balanceOf` returns 0 are left out, even if their Transfer events say otherwise. **How do I get the balance of one token for many wallets?** Turn the question around: `GET /v1/robinhood/token/{address}/holders?limit=500` lists the token's holders ranked by balance, with `balance`, `pct` of supply and `value_usd` for each (Free plan, 2 credits). For a past block or time, use the [holder snapshot](https://docs.crius.sh/guides/get-historical-holders/). **Does the balances call include tokenized stocks and USDG?** Yes. Tokenized stocks (NVDA, QQQ, SPY and others) and USDG are ERC-20 tokens on Robinhood Chain, so they appear in `holdings[]` like any other token, valued from their on-chain pools. Real USDG is `0x5fc5360d0400a0fd4f2af552add042d716f1d168`: match by address, because anyone can deploy a token called USDG. ## Related [Guide **Wallet holdings & PnL** Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Read](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) [Guide **Prices for many tokens** Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed. Read](https://docs.crius.sh/guides/get-prices-for-many-tokens/) [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Use case **Wallets & portfolios** What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens. Read](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) [Concept **Token prices** How the Crius API prices Robinhood Chain tokens from on-chain pools, how the price pool is picked, and what confidence and thin\_liquidity mean. Read](https://docs.crius.sh/concepts/token-prices/) [API reference **Wallet profile API** Holdings with USD value, realized and unrealized PnL over a window (1d, 7d, 30d, all), win rate and wallet tags. Read](https://docs.crius.sh/reference/wallets/wallet-profile/) --- # Get a wallet's trade history > List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time. Source: https://docs.crius.sh/guides/get-wallet-trade-history/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/wallet/{address}/trades` (Starter plan, 5 credits). It returns the wallet's trades across all tokens, newest first, in the trade tape's shape plus the `token`: `type`, `value_usd`, `amount_base`, `price_usd`, `market_cap_usd_at_trade`, `dex`, `fees`, `tx`. Filter with `token`, `side`, `min_usd`, `from_ts` / `to_ts`, and page with `cursor`. [GET `/wallet/{address}/trades`](https://docs.crius.sh/reference/wallets/wallet-trades/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET `/wallet/{address}`](https://docs.crius.sh/reference/wallets/wallet-profile/) A wallet’s trade history is every buy and sell it made, across every token on Robinhood Chain, newest first. Each trade carries what was swapped, its value in USD and ETH at that moment, the market cap at the time, the DEX or launchpad curve, the gas paid and any token tax. Trades made through routers, bots and smart accounts are attributed to the wallet that owns the funds, so the history is the user’s real activity, not their router’s. ## Get a wallet’s trades Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-trades/) ### A token creator with no trades Did the wallet that launched Charge AI (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) ever buy or sell a token? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 13 lines (arrays trimmed)** ```json { "data": [], "meta": { "block": 100406866, "block_age_ms": 557, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 110, "next_cursor": null, "safe_block": 100401329 } } ``` What this tells you - `data: []` and `meta.next_cursor: null`: this wallet has never made a trade, on any token. - Launching a token isn’t a trade. The wallet created CHARGE on Pons but never bought any of it, which matches its [developer profile](https://docs.crius.sh/guides/check-developer-history/) (`dev_sold_pct: null`: it never held the token) and its [wallet profile](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) (`pnl.trades: 0`). - An empty history for a dev wallet is a good sign in one way: it didn’t buy its own launch to dump later. [Wallet trades reference](https://docs.crius.sh/reference/wallets/wallet-trades/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20token%20creator%20with%20no%20trades&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-trade-history%2F%23creator-no-trades%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%2Ftrades%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) The same trade objects are on the token’s trade tape, which has a `trader` filter and is on the anonymous plan. Here is one active wallet’s full history in one token: Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### One buy on the Pons curve, seven sells on Uniswap v4 How did 0x9e38fedc40987c19396cc20ea59eb2b1b7928881, CHARGE's most profitable trader, trade it? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/trades?trader=0x9e38fedc40987c19396cc20ea59eb2b1b7928881&limit=10 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/trades?trader=0x9e38fedc40987c19396cc20ea59eb2b1b7928881&limit=10" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/trades?trader=0x9e38fedc40987c19396cc20ea59eb2b1b7928881&limit=10"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/trades?trader=0x9e38fedc40987c19396cc20ea59eb2b1b7928881&limit=10", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 350 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 3450501.202444715882983567, "amount_quote": 0.059489677910557273, "block": 89567489, "dex": "uniswap_v4", "eth_usd_at_trade": 2461.46, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.02114, "gas_used": 211923, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000448005, "total_eth": 0.00000448005, "usd": 0.0110275 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "89567489-3-3", "market_cap_usd_at_trade": 41171.4, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000172409, "price_usd": 0.0000424378, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1792101884000, "tx": "0xa2cde4fc974766f588279983c6453169163b5332c8b964d33b09a9c53ced8818", "tx_index": 3, "type": "sell", "value_eth": 0.0594897, "value_usd": 146.432, "via": [] }, { "amount_base": 3450501.202444715882983566, "amount_quote": 0.076326432685469697, "block": 88527989, "dex": "uniswap_v4", "eth_usd_at_trade": 2444.46, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021216, "gas_used": 216578, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000459492, "total_eth": 0.00000459492, "usd": 0.0112321 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88527989-3-21", "market_cap_usd_at_trade": 52459, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000221204, "price_usd": 0.0000540725, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791997126000, "tx": "0x734c18c4b65ea2795c480651c6b7c2b64209d437a5cc92ba9d06cc0c9c12f282", "tx_index": 3, "type": "sell", "value_eth": 0.0763264, "value_usd": 186.577, "via": [] }, { "amount_base": 2300334.134963143921989044, "amount_quote": 0.071658341178558314, "block": 88475945, "dex": "uniswap_v4", "eth_usd_at_trade": 2438.29, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020702, "gas_used": 216676, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000448563, "total_eth": 0.00000448563, "usd": 0.0109373 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88475945-1-0", "market_cap_usd_at_trade": 73689.3, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000311513, "price_usd": 0.0000759559, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791991894000, "tx": "0x99d7a94b290cea9a6e8cb9c2f63f5199a1d3250364700b6aebe2eeb1db298040", "tx_index": 1, "type": "sell", "value_eth": 0.0716583, "value_usd": 174.724, "via": [] }, { "amount_base": 3067112.179950858562652058, "amount_quote": 0.086696054744512961, "block": 88475346, "dex": "uniswap_v4", "eth_usd_at_trade": 2437.39, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020702, "gas_used": 216654, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000448517, "total_eth": 0.00000448517, "usd": 0.0109321 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88475346-6-9", "market_cap_usd_at_trade": 66840.2, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000282663, "price_usd": 0.0000688961, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791991834000, "tx": "0x95c675f803e40c2ea0c3a84340eb5dbd19452983bfcc4817bdd81191922045b6", "tx_index": 6, "type": "sell", "value_eth": 0.0866961, "value_usd": 211.312, "via": [] }, { "amount_base": 4089482.906601144750202745, "amount_quote": 0.096224110593702316, "block": 88466730, "dex": "uniswap_v4", "eth_usd_at_trade": 2432.02, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020974, "gas_used": 216560, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000454213, "total_eth": 0.00000454213, "usd": 0.0110465 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88466730-5-3", "market_cap_usd_at_trade": 55516.9, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000235297, "price_usd": 0.0000572245, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791990966000, "tx": "0x0a036198703d4f8f88ef8e7e2a789a9788ef1affce207e519dd7d9f50dc483a7", "tx_index": 5, "type": "sell", "value_eth": 0.0962241, "value_usd": 234.019, "via": [] }, { "amount_base": 5452643.875468193000270326, "amount_quote": 0.103891242720784518, "block": 88461897, "dex": "uniswap_v4", "eth_usd_at_trade": 2422.69, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020708, "gas_used": 216676, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000448693, "total_eth": 0.00000448693, "usd": 0.0108705 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88461897-9-21", "market_cap_usd_at_trade": 44783.1, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000190534, "price_usd": 0.0000461605, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791990481000, "tx": "0x9fa0531f936d1350e415a003c9127f6b4d9300caff0b353e761bee6ee312555b", "tx_index": 9, "type": "sell", "value_eth": 0.103891, "value_usd": 251.697, "via": [] }, { "amount_base": 7270191.833957590667027102, "amount_quote": 0.141409557571563841, "block": 88461530, "dex": "uniswap_v4", "eth_usd_at_trade": 2427.14, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.02065, "gas_used": 216714, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000447514, "total_eth": 0.00000447514, "usd": 0.0108618 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88461530-5-12", "market_cap_usd_at_trade": 45800.6, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_eth": 0.0000000194506, "price_usd": 0.0000472093, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791990444000, "tx": "0x5b7b4db274b6818846f101c1c371a5eb0bc53801f0830c691063a3fd9a3b9723", "tx_index": 5, "type": "sell", "value_eth": 0.14141, "value_usd": 343.221, "via": [] }, { "amount_base": 29080767.335830362668108408, "amount_quote": 0.099, "block": 88389602, "dex": "pons_curve", "eth_usd_at_trade": 2475.75, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.02029, "gas_used": 277378, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.000005628, "total_eth": 0.000005628, "usd": 0.0139335 }, "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "88389602-19-29", "market_cap_usd_at_trade": 8176.73, "pool": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "price_eth": 0.00000000340431, "price_usd": 0.00000842823, "quote": "0x0000000000000000000000000000000000000000", "quote_symbol": "ETH", "signer": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "signer_label": null, "trader": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "trader_app": null, "trader_label": null, "ts": 1791983208000, "tx": "0x1f6f1367f5ae6f2fec73bdc63ba88762bd73e32b20c19f029bffdd5b5ce8deb5", "tx_index": 19, "type": "buy", "value_eth": 0.099, "value_usd": 245.099, "via": [] } ], "meta": { "block": 100408989, "block_age_ms": 371, "block_ts": 1793225306000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 48, "next_cursor": null, "safe_block": 100401329 } } ``` What this tells you - Eight trades, newest first. The last item is the only buy: `type: "buy"`, `dex: "pons_curve"`, 0.099 ETH (`value_usd: 245.099`) for 29,080,767 CHARGE at `market_cap_usd_at_trade: 8176.73`, on 2026-10-14 at 13:06 UTC, six minutes after launch. - The seven sells are on `dex: "uniswap_v4"`, in pool `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`, after the token graduated. They sold at market caps between 41171.4 and 73689.3; the largest was `value_usd: 343.221`. - The seven `value_usd` add up to 1,547.98, exactly the `sold_usd` of this wallet in [CHARGE’s top traders](https://docs.crius.sh/guides/get-top-traders-pnl/#charge-top-traders). The trade list is the evidence behind the PnL. - `trader` and `signer` are the same address with `executor: null`: the wallet sent its own transactions, without a bot or relayer. - `fees.token_tax.pct: 0` on every trade, and gas of about a cent each (`fees.gas.usd: 0.0139335` on the buy). - `finality: "finalized"`: Ethereum has finalized the batches these trades were posted in (see [Finality](https://docs.crius.sh/concepts/finality/)). [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20One%20buy%20on%20the%20Pons%20curve%2C%20seven%20sells%20on%20Uniswap%20v4&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fget-wallet-trade-history%2F%23top-trader-history%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ftrades%3Ftrader%3D0x9e38fedc40987c19396cc20ea59eb2b1b7928881%26limit%3D10%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the fields mean | Field | Meaning | | --- | --- | | `id` | Unique trade id: block, transaction index, log index. | | `type` | `buy` or `sell`, from the wallet's side. | | `token` | (wallet trades) the token traded: address, symbol, logo. | | `amount_base`, `amount_quote`, `quote`, `quote_symbol` | Tokens traded, and what they were paid with (ETH, WETH, USDG…). | | `value_usd`, `value_eth`, `eth_usd_at_trade` | Value of the trade at the time it happened. | | `price_usd`, `price_eth`, `market_cap_usd_at_trade` | The token's price and market cap at that trade. | | `dex`, `pool`, `via` | Where it traded (`pons_curve`, `uniswap_v4`, `uniswap_v3`…), the pool, and routers it went through. | | `trader`, `signer`, `executor`, `trader_label`, `trader_app` | Who traded, who sent the transaction, and the relayer or bundler when there was one. | | `fees.gas` | Gas in ETH (L2 and L1 parts) and USD. | | `fees.token_tax.pct` | Token tax actually taken on this trade. | | `block`, `ts`, `tx`, `finality` | When and where it happened, and whether it's `latest`, `safe` or `finalized`. | Filters on `/wallet/{address}/trades`: `token` (one token’s trades), `side` (`buy` or `sell`), `min_usd`, `from_ts` and `to_ts` (unix ms), `limit` (up to 500, default 50) and `cursor` (`meta.next_cursor`). ## Use it in your app 1. **Get a Starter key** for `/wallet/{address}/trades` (5 credits per call). For one token only, the token trade tape with `trader=` works without a key. 2. **Page through history.** Ask for `limit=500` and pass `meta.next_cursor` as `cursor` until it’s `null`. For updates, fetch with `from_ts` set to the newest `ts` you have and skip `id`s you’ve already stored. 3. **Group by token for a portfolio view.** Sum `value_usd` per `token.address` and `type`: buys are cost, sells are proceeds. The [wallet profile](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) already does this as PnL. 4. **Show the context.** `market_cap_usd_at_trade` (“bought at $8k market cap”) and `dex` (“on the Pons curve”) make a trade history readable. ```js // Every trade of a wallet, all pages. async function walletTrades(wallet) { const out = []; let cursor = null; do { const q = new URLSearchParams({ limit: "500", ...(cursor && { cursor }) }); const res = await fetch(`https://api.crius.sh/v1/robinhood/wallet/${wallet}/trades?${q}`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); out.push(...data); cursor = meta.next_cursor; } while (cursor); return out; } const trades = await walletTrades("0x9e38fedc40987c19396cc20ea59eb2b1b7928881"); for (const t of trades) console.log(new Date(t.ts).toISOString(), t.type, t.token.symbol, `$${t.value_usd}`, t.dex); ``` ## Frequently asked questions **How do I get all the trades of a wallet on Robinhood Chain?** Call `/v1/robinhood/wallet/{address}/trades?limit=500` and follow `meta.next_cursor` until it's `null`. Trades come newest first, across every token and DEX the wallet used, each with the USD value at the time of the trade. **How do I get a wallet's trades in one token without a paid plan?** Use the token's trade tape with the `trader` filter: `/v1/robinhood/token/{token}/trades?trader={wallet}`. It's on the anonymous plan (2 credits with a key) and returns the same trade objects. Use `/wallet/{address}/trades` when you need every token at once. **Does a trade through a router or a trading bot show up under my wallet?** Yes. Crius attributes each swap to the wallet whose balance changed, not to the router, aggregator, Relay solver or ERC-4337 bundler that sent it. The sender is reported separately as `signer` and `executor`. See [Trader attribution](https://docs.crius.sh/concepts/attribution/). **Why does a wallet return no trades?** It hasn't bought or sold any token on a DEX or launchpad curve. Launching a token, receiving an airdrop or sending a transfer isn't a trade. An address the index has never seen also returns an empty list rather than an error. **Which plan does wallet trades need?** The Starter plan or higher, 5 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Wallet holdings & PnL** Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Read](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Concept **Trader attribution & wallet tags** How Crius attributes Robinhood Chain trades to the real trader behind routers, aggregators, bundlers and bot contracts, and what each wallet tag means. Read](https://docs.crius.sh/concepts/attribution/) [API reference **Wallet trades API** Every trade the wallet made across all tokens, newest first, in the same shape as the trade tape plus the token. Read](https://docs.crius.sh/reference/wallets/wallet-trades/) --- # Market cap, FDV and circulating supply of a Robinhood Chain token (token supply API) > Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed. Source: https://docs.crius.sh/guides/market-cap-fdv-and-supply/ · Updated 2026-10-28 Short answer The Robinhood Chain token supply API is `GET /v1/robinhood/token/{address}`: it returns `total_supply`, `burned`, `locked` and `circulating_supply`. `market.market_cap_usd` is the price × `circulating_supply` (total supply minus tokens held by `0x0000000000000000000000000000000000000000` or `0x000000000000000000000000000000000000dEaD`), `market.fdv_usd` is the price × `total_supply`, and `burned`, `locked` and `circulating_supply` are in whole tokens. Locked tokens still count as circulating. No API key needed; 1 credit with one. [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [POST `/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) A token’s market cap is its price times the number of tokens that are really out there; its fully diluted value (FDV) is the price times every token that exists. On Robinhood Chain, Crius computes both from on-chain data every block: the supply comes from the token contract, burned tokens from the balances of `0x0` and the dead address, and the price from the token’s deepest pool. The token profile returns all of them together with the supply numbers behind them, so you can show, or recompute, exactly how the market cap was reached. It doubles as a token supply API for Robinhood Chain: total, burned, locked and circulating supply for any ERC-20 on the chain. ## Get market cap, FDV and supply in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### A token with 10% burned: market cap below FDV What are the market cap, FDV and circulating supply of Pizza (PIZZA, 0xd086f891229cd123aadfcae7c4b40150a80fd9d7)? GET/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 302 lines (arrays trimmed)** ```json { "data": { "address": "0xd086f891229cd123aadfcae7c4b40150a80fd9d7", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7/bundles" }, "burned": 100000000.000000001009329493, "chain_id": 4663, "circulating_supply": 899999999.999999998990670507, "creation": { "attribution": "unattributed_factory", "block": 100319502, "deployed_via": "factory", "deployer": "0x154189eb359a452b92760b9608d9e15ea0177d59", "factory": "0xf1542dd2d46394c16372fb00f2c339b53cef2ce5", "source": "trace", "tx": "0x4cb1f738f66fd042b97cd5fce3731935d1427a902d4d4800b8dda5c338e0af65" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793225331283, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1793217378951, "orders": [ { "payment_ts": 1793217378951, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": "Pizza", "header": null, "icon": "https://cdn.dexscreener.com/cms/images/qj93WyGHzUsGRx3e?width=64&height=64&fit=crop&quality=95&format=auto", "links": [ { "label": "Website", "url": "https://xdcoinsol.lol" }, { "type": "twitter", "url": "https://x.com/search?q=0xd086f891229cd123aadfcae7c4b40150a80fd9d7&src=typed_query&f=live" } ] }, "url": "https://dexscreener.com/robinhood/0xd086f891229cd123aadfcae7c4b40150a80fd9d7" }, "first_seen_block": 100319502, "history": "complete", "holders": { "burned_pct": 10, "count": 2853, "dev_holding": null, "dev_pct": null, "locked_pct": 0, "top10_pct": 12.9544 }, "launch": null, "liquidity": { "see": "/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7/liquidity", "status": "unlocked", "summary": { "burned_pct": 0, "locked_pct": 0, "next_unlock_ts": 1793361420000, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 94.2014, "weighting": "by pool liquidity_usd" } }, "locked": 0, "market": { "fdv_usd": 2518314, "liquidity_usd": 650032, "market_cap_usd": 2266483, "pools_count": 51, "quote_liquidity_usd": 325016 }, "metadata": { "banner": null, "description": "Pizza", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/search?q=0xd086f891229cd123aadfcae7c4b40150a80fd9d7&src=typed_query&f=live", "website": "https://xdcoinsol.lol" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd086f891229cd123aadfcae7c4b40150a80fd9d7.png?size=128", "logo_original": "https://k1k4tkfsqlxro5el.public.blob.vercel-storage.com/tokens/image-C95LxbDL1ZajGol5HuEwia5ny1BaOu.png", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "source": "metadata_uri", "sources": { "links": "dexscreener", "logo": "metadata_uri" } }, "name": "Pizza", "price": { "ath_market_cap_usd": 2760203, "ath_scope": "all_time", "ath_ts": 1793225100000, "ath_usd": 0.00306689, "change_pct": { "1h": 192.682, "1m": -9.69938, "1s": -0.040642, "24h": 30458, "30s": -2.96295, "4h": 30458, "5m": -14.2022, "6h": 30458 }, "confidence": "high", "dex": "uniswap_v4", "eth": 0.00000106912, "liquidity_usd": 539903, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_liquidity_usd": 269952, "source_pool": "0xdf3fbf9be296615d5ee32ccb4c2884599a93dd5dc91ad2b779dda99c7ce53bdd", "thin_liquidity": false, "usd": 0.00251831 }, "security": { "see": "/v1/robinhood/token/0xd086f891229cd123aadfcae7c4b40150a80fd9d7/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 1872170, "buys": 11684, "first_trade_ts": 1793216059000, "sell_volume_usd": 1611777, "sells": 18793, "since": "chain_start", "trades": 30477, "volume_usd": 3483946 }, "avg_trade_usd": { "1h": 114.313, "1m": 89.4092, "1s": 75.2817, "24h": 114.314, "30s": 63.2566, "4h": 114.314, "5m": 101.439, "6h": 114.314 }, "buy_volume_usd": { "1h": 941354, "1m": 5515.3, "1s": 0, "24h": 1872170, "30s": 3835.81, "4h": 1872170, "5m": 115097, "6h": 1872170 }, "buyers": { "1h": 3115, "1m": 116, "1s": 0, "24h": 5229, "30s": 72, "4h": 5229, "5m": 713, "6h": 5229 }, "buys": { "1h": 6090, "1m": 153, "1s": 0, "24h": 11684, "30s": 98, "4h": 11684, "5m": 1050, "6h": 11684 }, "last_trade_ts": 1793225381000, "sell_volume_usd": { "1h": 824898, "1m": 31857.7, "1s": 75.2817, "24h": 1611777, "30s": 11029.5, "4h": 1611777, "5m": 163554, "6h": 1611777 }, "sellers": { "1h": 2283, "1m": 170, "1s": 1, "24h": 4014, "30s": 95, "4h": 4014, "5m": 773, "6h": 4014 }, "sells": { "1h": 9361, "1m": 265, "1s": 1, "24h": 18793, "30s": 137, "4h": 18793, "5m": 1697, "6h": 18793 }, "traders": { "1h": 3659, "1m": 244, "1s": 1, "24h": 5494, "30s": 147, "4h": 5494, "5m": 1158, "6h": 5494 }, "trades": { "1h": 15451, "1m": 418, "1s": 1, "24h": 30477, "30s": 235, "4h": 30477, "5m": 2747, "6h": 30477 }, "txns": { "1h": 9751, "1m": 258, "1s": 1, "24h": 19208, "30s": 138, "4h": 19208, "5m": 1756, "6h": 19208 }, "volume_eth": { "1h": 748.475, "1m": 15.8663, "1s": 0.0319601, "24h": 1476.31, "30s": 6.31091, "4h": 1476.31, "5m": 118.299, "6h": 1476.31 }, "volume_usd": { "1h": 1766253, "1m": 37373, "1s": 75.2817, "24h": 3483946, "30s": 14865.3, "4h": 3483946, "5m": 278652, "6h": 3483946 } }, "symbol": "PIZZA", "total_supply": 1000000000, "type": "generic", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": false, "sourcify": "none" } }, "meta": { "block": 100409753, "block_age_ms": 326, "block_ts": 1793225381000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 50, "pending": [], "safe_block": 100405028 } } ``` What this tells you - `total_supply: 1000000000` and `burned: 100000000.0`, so `circulating_supply: 900000000.0`. `holders.burned_pct` confirms 10%. - `price.usd: 0.00251831`, so `market.market_cap_usd` is 0.00251831 × 900,000,000 = `2266483`, and `market.fdv_usd` is 0.00251831 × 1,000,000,000 = `2518314`. - `locked: 0`: no tokens sit in a locker. - The market cap is about 7 times the real quote liquidity across its 51 pools (`market.quote_liquidity_usd: 325016`): holders could not all sell at this price. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20token%20with%2010%25%20burned%3A%20market%20cap%20below%20FDV&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fmarket-cap-fdv-and-supply%2F%23pizza-supply%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xd086f891229cd123aadfcae7c4b40150a80fd9d7%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### A tokenized stock: market cap of the on-chain supply only What is the market cap of NVIDIA's tokenized stock (NVDA, 0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec) on Robinhood Chain? GET/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 276 lines (arrays trimmed)** ```json { "data": { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/bundles" }, "burned": 0.572430377652470782, "chain_id": 4663, "circulating_supply": 88422.910266912347529218, "creation": { "attribution": "unattributed_factory", "block": 45898, "deployed_via": "factory", "deployer": "0x5516b3451d4d6c9f63353fe7bc9537477ecce000", "factory": "0x4783c67b63de2b358ac5951a7d41f47a38f3c046", "source": "trace", "tx": "0xcdb797c54ff55ef4008f254c486cc52d7393a65a6e6fb622c44b0260eecb755f" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793149717505, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": false, "dex_paid_ts": null, "orders": [], "profile": { "description": null, "header": null, "icon": null, "links": [] }, "url": "https://dexscreener.com/robinhood/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" }, "first_seen_block": 153563, "history": "complete", "holders": { "burned_pct": 0.000647374, "count": 192281, "dev_holding": null, "dev_pct": null, "locked_pct": 0.0166825, "top10_pct": 23.0847 }, "launch": null, "liquidity": null, "locked": 14.751287401999318562, "market": { "fdv_usd": 18950318, "liquidity_usd": 5692665, "market_cap_usd": 18950195, "pools_count": 81958, "quote_liquidity_usd": 2846332 }, "metadata": { "banner": null, "description": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "logo": null, "logo_original": null, "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "source": null, "sources": { "links": null, "logo": null } }, "name": "NVIDIA • Robinhood Token", "price": { "ath_market_cap_usd": 21464337, "ath_scope": "all_time", "ath_ts": 1791294900000, "ath_usd": 242.746, "change_pct": { "1h": 0.203956, "1m": 0.00180098, "1s": 0.0463156, "24h": -1.49823, "30s": 0.0223516, "4h": -1.14254, "5m": -0.24523, "6h": -1.39827 }, "confidence": "high", "dex": "uniswap_v3", "eth": 0.0909845, "liquidity_usd": 1415590, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_liquidity_usd": 707795, "source_pool": "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3", "thin_liquidity": false, "usd": 214.313 }, "security": { "see": "/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 1052251075, "buys": 3363555, "first_trade_ts": 1783018515000, "sell_volume_usd": 1052701444, "sells": 3313729, "since": "chain_start", "trades": 6677284, "volume_usd": 2104952519 }, "avg_trade_usd": { "1h": 314.702, "1m": 702.205, "1s": null, "24h": 328.961, "30s": 284.331, "4h": 415.672, "5m": 432.074, "6h": 396.236 }, "buy_volume_usd": { "1h": 284731, "1m": 668.352, "1s": 0, "24h": 5466708, "30s": 0, "4h": 2370859, "5m": 4796.08, "6h": 2762624 }, "buyers": { "1h": 237, "1m": 6, "1s": 0, "24h": 1993, "30s": 0, "4h": 615, "5m": 25, "6h": 786 }, "buys": { "1h": 837, "1m": 7, "1s": 0, "24h": 16501, "30s": 0, "4h": 5633, "5m": 49, "6h": 6855 }, "last_trade_ts": 1793225374000, "sell_volume_usd": { "1h": 208093, "1m": 18291.2, "1s": 0, "24h": 6093982, "30s": 1137.32, "4h": 2875339, "5m": 67360.3, "6h": 3390131 }, "sellers": { "1h": 229, "1m": 9, "1s": 0, "24h": 2643, "30s": 4, "4h": 855, "5m": 29, "6h": 1098 }, "sells": { "1h": 729, "1m": 20, "1s": 0, "24h": 18642, "30s": 4, "4h": 6988, "5m": 118, "6h": 8673 }, "traders": { "1h": 328, "1m": 13, "1s": 0, "24h": 3513, "30s": 4, "4h": 1119, "5m": 43, "6h": 1417 }, "trades": { "1h": 1566, "1m": 27, "1s": 0, "24h": 35143, "30s": 4, "4h": 12621, "5m": 167, "6h": 15528 }, "txns": { "1h": 1459, "1m": 26, "1s": 0, "24h": 33046, "30s": 4, "4h": 11704, "5m": 158, "6h": 14478 }, "volume_eth": { "1h": 208.755, "1m": 8.04908, "1s": 0, "24h": 4920.79, "30s": 0.482839, "4h": 2225.28, "5m": 30.6332, "6h": 2613.33 }, "volume_usd": { "1h": 492824, "1m": 18959.5, "1s": 0, "24h": 11560689, "30s": 1137.32, "4h": 5246198, "5m": 72156.3, "6h": 6152755 } }, "symbol": "NVDA", "total_supply": 88423.48269729, "type": "stock", "ui_multiplier": 1.00077515916, "verification": { "compiler": "0.8.33+commit.64118f21", "contract_name": "BeaconProxy", "implementation": null, "is_proxy": false, "sourcify": "match" } }, "meta": { "block": 100409760, "block_age_ms": 1092, "block_ts": 1793225381000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 129, "pending": [], "safe_block": 100405028 } } ``` What this tells you - `type: "stock"`, `total_supply: 88423.48269729`: only about 88,423 NVDA tokens exist on chain. - `burned: 0.5724303776524707` leaves `circulating_supply: 88422.91026691235`, so `market.market_cap_usd: 18950195` sits just under `market.fdv_usd: 18950318`. - `ui_multiplier: 1.00077515916` is the display multiplier the stock token applies to balances for splits and dividends. Other token types have `ui_multiplier: null`. - The token is widely held: `holders.count: 192281`, with the top 10 holding `top10_pct: 23.0847`%. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20tokenized%20stock%3A%20market%20cap%20of%20the%20on-chain%20supply%20only&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fmarket-cap-fdv-and-supply%2F%23nvda-supply%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How each number is computed | Field | Definition | | --- | --- | | `total_supply` | The token contract's total supply, in whole tokens (already divided by `decimals`). | | `burned` | Tokens held by `0x0000000000000000000000000000000000000000` or `0x000000000000000000000000000000000000dEaD`. | | `locked` | Tokens held by known locker contracts. Reported for information: still counted as circulating. | | `circulating_supply` | `total_supply` − `burned`. Unsold tokens in a launchpad bonding curve are included. | | `market.market_cap_usd` | `price.usd` × `circulating_supply`. | | `market.fdv_usd` | `price.usd` × `total_supply`. | | `market.liquidity_usd`, `market.quote_liquidity_usd` | All the token's pools added up: 2 × the quote side, and the quote side alone. | | `holders.burned_pct`, `holders.locked_pct` | `burned` and `locked` as a percentage of the total supply. | | `price.ath_market_cap_usd` | The all-time-high price × today's circulating supply. | Locked tokens are the main judgment call. Charge AI, for example, has `locked: 81632653.061224486519511236` (8.16327% of supply) in its Pons launch locker, and Crius still counts those tokens in its `circulating_supply` of 970,159,941.23. If you want a “free float” number, subtract `locked` yourself. Market cap also exists at other points in time: every trade on the [trade tape](https://docs.crius.sh/guides/get-token-trades/) carries `market_cap_usd_at_trade`, and every [candle](https://docs.crius.sh/guides/get-ohlcv-candles/) has `mc`, the market cap at its close. ## Use it in your app 1. **Show market cap and FDV side by side** when `burned` is above zero, and only one when they match. 2. **Put liquidity next to market cap.** A ratio of market cap to `market.quote_liquidity_usd` far above 10 means the price can’t absorb much selling. 3. **Label tokenized stocks.** For `type: "stock"`, call it “on-chain market cap” so users don’t compare it with the company’s. 4. **Fetch many tokens at once** with `POST /tokens/batch` and `fields: ["symbol", "market.market_cap_usd", "market.fdv_usd", "circulating_supply"]`. ```python import requests token = "0xd086f891229cd123aadfcae7c4b40150a80fd9d7" # PIZZA d = requests.get(f"https://api.crius.sh/v1/robinhood/token/{token}", timeout=10).json()["data"] m = d["market"] print(f"{d['symbol']}: market cap ${m['market_cap_usd']:,.0f}, FDV ${m['fdv_usd']:,.0f}") print(f"supply {d['total_supply']:,.0f}, burned {d['burned']:,.0f}, circulating {d['circulating_supply']:,.0f}") free_float = d["circulating_supply"] - d["locked"] print(f"free float (circulating minus locked): {free_float:,.0f}") if m["quote_liquidity_usd"] and m["market_cap_usd"] / m["quote_liquidity_usd"] > 10: print("thin: market cap is more than 10x the real liquidity") ``` Market cap can be manufactured A token with a large supply and a pool seeded at a high price shows a huge market cap with almost no money behind it. In a `top_market_cap` list captured for these docs, the second-largest token, Let’s End AI (ENDAI, `0xc882f10529a5518ee3393af5a80e9ff00d38d44b`), shows a market cap of $890,862,106 and is a [honeypot](https://docs.crius.sh/guides/detect-honeypot/): nobody can sell it. Always read `market.quote_liquidity_usd` and run the [security check](https://docs.crius.sh/guides/token-security-score/) before trusting a market cap. ## Frequently asked questions **Is there a Robinhood Chain token supply API?** Yes. The token profile, `GET /v1/robinhood/token/{address}`, returns `total_supply`, `burned`, `locked` and `circulating_supply` in whole tokens for any ERC-20 on Robinhood Chain, with `market.market_cap_usd` and `market.fdv_usd` computed from them. No API key is needed. For many tokens at once, `POST /v1/robinhood/tokens/batch` with a `fields` list returns only the supply fields you ask for. **How do I get the circulating supply of a Robinhood Chain token?** Read `circulating_supply` from `GET /v1/robinhood/token/{address}`. It's `total_supply` minus `burned` (tokens held by the zero address and the dead address). Locked tokens stay in it; subtract `locked` yourself for a free-float number. **How is market cap calculated for Robinhood Chain tokens?** Crius multiplies the live USD price by the circulating supply: the total supply minus tokens held by `0x0000000000000000000000000000000000000000` or `0x000000000000000000000000000000000000dEaD`. Unsold tokens still in a bonding curve are included. The price comes from the token's deepest on-chain pool. **What's the difference between market cap and FDV?** FDV (fully diluted value) uses the total supply, burned tokens included; market cap leaves burned tokens out. They're equal when nothing has been burned. In the example, PIZZA has 10% of its supply burned, so its market cap ($2,266,483) is 90% of its FDV ($2,518,314). **Are locked tokens part of the circulating supply?** Yes. Only burned tokens are subtracted. Tokens held by known locker contracts are reported in `locked` (and `holders.locked_pct`) so you can subtract them yourself if you prefer a stricter definition. **Why is a tokenized stock's market cap so much smaller than the company's?** Because it counts only the tokens that exist on Robinhood Chain. NVDA's token has a total supply of 88,423.48 tokens, so at $214.313 its on-chain market cap is about $18.95 million, a tiny fraction of NVIDIA's own value. **Can I filter tokens by market cap?** Yes. `GET /v1/robinhood/tokens?list=top_market_cap&min_market_cap_usd=100000` lists tokens above a market cap. See [Find tokens by market cap](https://docs.crius.sh/guides/find-tokens-by-market-cap/). ## Related [Guide **Get token data** Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Read](https://docs.crius.sh/guides/get-token-data/) [Guide **Find tokens by market cap** Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses. Read](https://docs.crius.sh/guides/find-tokens-by-market-cap/) [Guide **All-time high and price change** Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change. Read](https://docs.crius.sh/guides/get-all-time-high-and-price-change/) [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [API reference **Token profile API** Full profile of any ERC-20 on the chain: name, symbol, decimals, supply (total, burned, locked, circulating), creation and launchpad lifecycle, metadata and socials (with their source), price with cha Read](https://docs.crius.sh/reference/tokens/token-profile/) --- # Move from raw RPC calls to the Crius API on Robinhood Chain > Replace eth_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs. Source: https://docs.crius.sh/guides/migrate-from-rpc-to-crius/ · Updated 2026-10-28 Short answer Keep your RPC for writes (`eth_sendRawTransaction`, gas, nonces) and your own contracts. Replace the reads you index yourself: Swap logs with `GET /token/{address}/trades`, slot0 and reserve math with `/pool/{pool}` or `/token/{address}/price`, Transfer replays with `/holders`, ERC-20 metadata calls with `/token/{address}` or `/tokens/batch`, and `eth_subscribe` logs with the WebSocket stream. [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET `/pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) [GET `/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) [GET `/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) [POST `/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) A Robinhood Chain RPC node answers one question about raw chain state at a time: a block, a log range, a contract call. Market data (prices, trades, candles, holders) is built on top of millions of those answers: decoding every DEX’s events, routing prices to USD, finding the real trader behind routers, replaying transfers, handling reorgs. The Crius API is that work already done, from block 0. This guide maps the RPC reads apps usually build themselves onto single Crius calls, and says which RPC calls to keep. ## What to replace, and what to keep | What you do over RPC | What it takes | Crius call | Credits | | --- | --- | --- | --- | | `eth_getLogs` for Swap events, then decode and price them | ABIs for Uniswap v2, v3, v4 and each launch curve, pool-to-token maps, decimals, a USD route, block-range caps | `/token/{address}/trades` | 2 | | Aggregate swaps into OHLCV | Storage, bucketing, spike filtering | `/token/{address}/candles` | 2 | | `eth_call` slot0 / getReserves, then price math | Per pool type; v4 needs the PoolManager and pool id | `/pool/{pool}`, `/token/{address}/price` | 1 | | Replay `Transfer` logs (or `balanceOf` scans) for holders | Every transfer since the token's first block, kept current | `/token/{address}/holders` (Free plan) | 2 | | `name`, `symbol`, `decimals`, `totalSupply` calls | Four calls per token, plus metadata and logos | `/token/{address}`, `/tokens/batch` (100 per call) | 1 | | `owner()`, tax and limit getters, a simulated sell | Per contract; simulation infrastructure | `/token/{address}/security` | 1 | | `eth_subscribe` to logs | No replay after a disconnect; reorgs are yours to undo | WebSocket stream: `trades:`, `pools:new`, `launches:all` | 1 per connection | Keep the RPC for `eth_sendRawTransaction`, `eth_estimateGas`, nonces, `eth_call` against your own contracts and simulations of your own transactions. Crius is read-only. Endpoints used: [GET`/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET`/pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) [GET`/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) [GET`/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) [POST`/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) ## One pool: slot0 math versus one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/pools/pool-detail/) ### The WETH/USDG Uniswap v3 pool, decoded What is WETH worth in the 0.01% WETH/USDG pool (0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca), and how deep is it? GET/v1/robinhood/pool/0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/pool/0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/pool/0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/pool/0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 191 lines (arrays trimmed)** ```json { "data": { "created_block": 1506281, "created_ts": 1783025467340, "currency0": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "decimals": 18, "logo": null, "price_usd": 2355.49, "symbol": "WETH" }, "currency1": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "decimals": 6, "logo": null, "price_usd": 1, "symbol": "USDG" }, "dex": "uniswap_v3", "dynamic_fee": false, "factory": "0x1f7d7550b1b028f7571e69a784071f0205fd2efa", "fee": 100, "fee_bps": 1, "hook": null, "lp": null, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "pool_manager": null, "state": { "initialized_ticks": 2234, "last_block": 100409961, "liquidity": 1994488602507464498, "price_0_in_1": 2357.32, "price_1_in_0": 0.000424211, "real_quote_raised": null, "reserve0": 0, "reserve1": 0, "reserves": { "currency0": 3815.33, "currency1": 3821317, "kind": "real" }, "sqrt_price_x96": 3846701614108804881326106, "tick": -198668 }, "stats": { "all_time": { "buy_volume_usd": 13612852311, "buys": 24419328, "first_trade_ts": 1783530660000, "sell_volume_usd": 13597498410, "sells": 23196198, "since": "chain_start", "trades": 47615526, "volume_usd": 27210350721 }, "avg_trade_usd": { "1h": 278.58, "1m": 337.523, "1s": 835.826, "24h": 665.311, "30s": 298.573, "4h": 669.733, "5m": 261.935, "6h": 732.144 }, "buy_volume_usd": { "1h": 3415833, "1m": 55762.5, "1s": 13.1165, "24h": 71952485, "30s": 20837.4, "4h": 27415158, "5m": 336149, "6h": 37164488 }, "buyers": { "1h": 2322, "1m": 87, "1s": 1, "24h": 10385, "30s": 47, "4h": 4124, "5m": 569, "6h": 4935 }, "buys": { "1h": 11720, "1m": 131, "1s": 1, "24h": 105661, "30s": 65, "4h": 38476, "5m": 1420, "6h": 47760 }, "last_trade_ts": 1793225401000, "sell_volume_usd": { "1h": 3448384, "1m": 52919.9, "1s": 12524.3, "24h": 71729997, "30s": 20962.8, "4h": 27060933, "5m": 349335, "6h": 36625426 }, "sellers": { "1h": 2408, "1m": 119, "1s": 7, "24h": 11079, "30s": 54, "4h": 4805, "5m": 556, "6h": 5661 }, "sells": { "1h": 12920, "1m": 191, "1s": 14, "24h": 110302, "30s": 75, "4h": 42864, "5m": 1197, "6h": 53026 }, "traders": { "1h": 3245, "1m": 194, "1s": 8, "24h": 15793, "30s": 97, "4h": 6304, "5m": 894, "6h": 7551 }, "trades": { "1h": 24640, "1m": 322, "1s": 15, "24h": 215963, "30s": 140, "4h": 81340, "5m": 2617, "6h": 100786 }, "txns": { "1h": 24522, "1m": 322, "1s": 15, "24h": 212815, "30s": 140, "4h": 80538, "5m": 2564, "6h": 99706 }, "volume_eth": { "1h": 2908.97, "1m": 46.14, "1s": 5.32262, "24h": 61121.5, "30s": 17.7459, "4h": 23102.1, "5m": 291.015, "6h": 31357.2 }, "volume_usd": { "1h": 6864217, "1m": 108682, "1s": 12537.4, "24h": 143682482, "30s": 41800.2, "4h": 54476091, "5m": 685484, "6h": 73789914 } }, "swaps_indexed": 1956380, "tick_spacing": 1, "tvl_usd": 12808300 }, "meta": { "block": 100409961, "block_age_ms": 1256, "block_ts": 1793225401000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 22, "safe_block": 100405028 } } ``` What this tells you - `state.sqrt_price_x96` (3846701614108804881326106) and `state.tick` (−198668) are the raw slot0 values an RPC call returns. Crius also returns the result of the math: `state.price_0_in_1` 2357.32 USDG per WETH and `price_1_in_0` 0.000424211. - `currency0` is WETH with 18 decimals, `currency1` USDG with 6: the decimals you would otherwise fetch with two more calls. `fee: 100` is 1 basis point (`fee_bps: 1`). - `state.reserves` holds 3,815.33 WETH and 3,821,317 USDG (`kind: "real"`), and `tvl_usd` is 12,808,300. - `stats.all_time` counts 47,615,526 trades since `first_trade_ts` 1783530660000, with per-window volume and traders from `1s` to `24h`: numbers an RPC can’t give you without indexing every swap. [Pool detail reference](https://docs.crius.sh/reference/pools/pool-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20WETH%2FUSDG%20Uniswap%20v3%20pool%2C%20decoded&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fmigrate-from-rpc-to-crius%2F%23pool%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fpool%2F0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Before: WETH price from slot0 over JSON-RPC (the public RPC is shared and rate limited: use a provider in production) const RPC = "https://rpc.mainnet.chain.robinhood.com"; const POOL = "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca"; // Uniswap v3 WETH/USDG, 0.01% const rpc = await fetch(RPC, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_call", params: [{ to: POOL, data: "0x3850c7bd" }, "latest"] }), // slot0() }); const sqrtPriceX96 = BigInt("0x" + (await rpc.json()).result.slice(2, 66)); // token1 per token0, adjusted for WETH's 18 and USDG's 6 decimals (you must already know them) console.log("slot0:", Number((sqrtPriceX96 * sqrtPriceX96 * 10n ** 12n * 10n ** 6n) >> 192n) / 1e6); // After: the same price, plus reserves, TVL and volume, in one call const { data } = await (await fetch(`https://api.crius.sh/v1/robinhood/pool/${POOL}`)).json(); console.log("crius:", data.state.price_0_in_1, "tvl", data.tvl_usd, "24h volume", data.stats.volume_usd["24h"]); ``` For the sample above, the slot0 math gives 2357.316, the same as `price_0_in_1`. The difference is everything around it: that’s one pool type, one pool, at the latest block. A token’s USD price needs its deepest pool, the quote’s own USD route and a check that the pool isn’t too thin, which `/token/{address}/price` does in one call. ## Swap logs: what decoding gives you Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### Three WETH trades, already attributed What does the decoded version of a Swap log look like? GET/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 144 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 0.241346083005198446, "amount_quote": 569.019791, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 239930, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000503853, "total_eth": 0.00000503853, "usd": 0.0118753 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-6-44", "market_cap_usd_at_trade": 90494155, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00034, "price_usd": 2357.69, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "signer_label": null, "trader": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "trader_app": null, "trader_label": "fomo_relayer_3", "ts": 1793225076000, "tx": "0x5b474612139f91cb226cf9e5097244dbb896a86834d8adbd263641c96d67b9f7", "tx_index": 6, "type": "buy", "value_eth": 0.241428, "value_usd": 569.02, "via": [] }, { "amount_base": 0.021222351350879784, "amount_quote": 50.025498, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 455557, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000095667, "total_eth": 0.0000095667, "usd": 0.0225477 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-1-12", "market_cap_usd_at_trade": 90475571, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00013, "price_usd": 2357.21, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x800539138ff0510191277f6b5c58fb94ae700064", "signer_label": null, "trader": "0x800539138ff0510191277f6b5c58fb94ae700064", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0x0bde8abf03edce0f2ba13a3398ec2575b177c3f2d85eef77c25c7899a9949311", "tx_index": 1, "type": "sell", "value_eth": 0.0212252, "value_usd": 50.0255, "via": [ "uniswap_universal_router" ] }, { "amount_base": 0.011210844980975568, "amount_quote": 26.431588, "block": 100406782, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020904, "gas_used": 315171, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000658833, "total_eth": 0.00000658833, "usd": 0.015528 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406782-10-32", "market_cap_usd_at_trade": 90493695, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00033, "price_usd": 2357.68, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "signer_label": null, "trader": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0xa3a9ddaaa96d7cc4d300eb5ae37d174755cee56aec3e5e15ae7c3adf437a113b", "tx_index": 10, "type": "buy", "value_eth": 0.0112146, "value_usd": 26.4316, "via": [ "gmgn_swap_router" ] } ], "meta": { "block": 100406789, "block_age_ms": 367, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "next_cursor": "100406782-32", "safe_block": 100401329 } } ``` What this tells you - Each trade has a `type`, amounts in human units (`amount_base` 0.241346083005198446 WETH for `amount_quote` 569.019791 USDG), `price_usd` and `value_usd`: no `int256` deltas or `sqrtPriceX96` to convert. - `trader` is the wallet whose balance changed. The routing is reported separately: `via: ["uniswap_universal_router"]` and `via: ["gmgn_swap_router"]`, and `trader_label: "fomo_relayer_3"` names known infrastructure. - `fees.gas` gives the L2 and L1 cost in ETH and USD (`usd` 0.0118753 for the first trade), and `finality: "latest"` says the block isn’t safe yet. - `id` (`100406784-6-44`) is block, transaction index and log index, so trades join with logs you already store. [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20WETH%20trades%2C%20already%20attributed&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fmigrate-from-rpc-to-crius%2F%23trades%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0bd7d308f8e1639fab988df18a8011f41eacad73%2Ftrades%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Plan the move 1. **List your reads.** Group the RPC calls in your app by the question they answer (price, trades, holders, metadata, risk). Each group maps to a row of the table above. 2. **Start with the expensive ones.** Log scans and transfer replays cost the most to run yourself: Robinhood Chain makes a block about every 100 ms and has passed 100 million blocks, so a full backfill over a shared RPC endpoint can take weeks. Replace those first. 3. **Swap subscriptions for the stream.** `eth_subscribe` gives you logs with no replay. The Crius stream adds per-channel `seq` numbers, a 60-second resume buffer and explicit reorg messages ([trades stream guide](https://docs.crius.sh/guides/stream-trades-websocket/)). 4. **Keep identifiers.** Addresses are lowercase hex, v4 pools are 32-byte pool ids, trade ids are `block-tx-log`, amounts are human units and timestamps unix milliseconds ([conventions](https://docs.crius.sh/conventions/)). Plans and costs Trades, candles, prices, pools, token profiles, batch calls and security are on the anonymous plan (2 requests per second without a key; 1–2 credits each with one). Holders need a Free key (2 credits), holder snapshots at past blocks 5. Credits per endpoint are on [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Frequently asked questions **Do I still need an RPC provider if I use Crius?** Only to write to the chain or to read data no index models (your own contracts' state, eth\_call simulations of your transactions, gas estimates, nonces). Crius is a read-only API and doesn't relay transactions. **Is an indexed API slower than calling the RPC myself?** An indexer decodes a block before serving it, so there is a small delay. Crius streams events as each block is decoded, typically well under a second after the block, and every REST response reports `meta.block`, `meta.lag_ms` and the safe and finalized blocks. **How do reorgs work after migrating?** Every trade carries `finality` (`latest`, `safe`, `finalized`) and every response `meta.safe_block` and `meta.finalized_block`. The stream sends a `reorg` message and re-sends affected events with `removed: true`, or holds events until `safe` if you subscribe with `"finality": "safe"`. See [Finality](https://docs.crius.sh/concepts/finality/). **Can I migrate gradually?** Yes. Trade `id`s (`block-tx-log`) and pool keys (v2/v3 address, v4 pool id) are the chain's own identifiers, so Crius data joins with what you already store. Move one read path at a time and compare. ## Related [Concept **Robinhood Chain** What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Read](https://docs.crius.sh/concepts/robinhood-chain/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) [Concept **Trader attribution & wallet tags** How Crius attributes Robinhood Chain trades to the real trader behind routers, aggregators, bundlers and bot contracts, and what each wallet tag means. Read](https://docs.crius.sh/concepts/attribution/) [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) --- # Read a token's bubble map and holder clusters > Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Source: https://docs.crius.sh/guides/read-a-bubble-map/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/bubblemap?top=100` (Starter plan, 10 credits). `nodes` are the top holders with their share (`pct`), USD value and `tags`; `edges` are funding, shared funders and token transfers between them; `clusters` group linked holders with their total `pct`, members and the `links` that join them. Pools, lockers, hooks and burn addresses are listed under `hidden_infra`, not drawn. [GET `/token/{address}/bubblemap`](https://docs.crius.sh/reference/wallet-graph/bubble-map/) A bubble map shows a token’s largest holders as bubbles and draws lines between the ones that are connected, so you can see at a glance whether “the top 20 holders” are 20 people or one person with 20 wallets. Crius builds it from on-chain funding and token transfers on Robinhood Chain. It only links wallets on evidence that means something (the wallet that first funded them, transfers between them) and leaves out pools, lockers and exchanges, which touch everyone. ## Get the map in one call Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallet-graph/bubble-map/) ### Two clusters among Rebot's top holders Rebot (0x192b126efea71ca5e7767bc6fc53038d869fbbba) was an insider launch. Are any of its top 100 holders today the same person? GET/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bubblemap?top=100 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bubblemap?top=100" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bubblemap?top=100", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bubblemap?top=100", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 227 lines (arrays trimmed)** ```json { "data": { "block": null, "clusters": [ { "id": "c_80b9b545", "includes_dev": false, "links": { "funding_between": 0, "shared_funders": [ { "address": "0x795834684cdec507ea9ee240fdb7e908567dd316", "wallets": 2 } ], "token_transfers": 0 }, "members": [ "0xdebabd206e5a73dd81a9211533a1bd610c006d20", "0xf0fd2e7718ea59a6ddfe884c7e4714ae2dd5610a" ], "pct": 3.60847, "risk": "medium", "root_funder": "0x795834684cdec507ea9ee240fdb7e908567dd316", "wallets": 2 }, { "id": "c_377c5b", "includes_dev": false, "links": { "funding_between": 1, "shared_funders": [], "token_transfers": 0 }, "members": [ "0x4eec10e9c115a7ea67b59eea59c3a3c777fab236", "0xa0686afb77ed32fbb402a39642d05158b9fa4c96" ], "pct": 2.56134, "risk": "low", "root_funder": "0xa0686afb77ed32fbb402a39642d05158b9fa4c96", "wallets": 2 } ], "edges": [ { "block": 78435467, "eth": 1.2, "from": "0x795834684cdec507ea9ee240fdb7e908567dd316", "hub": false, "to": "0xdebabd206e5a73dd81a9211533a1bd610c006d20", "type": "common_funder" }, { "block": 9427558, "eth": 2, "from": "0xa0686afb77ed32fbb402a39642d05158b9fa4c96", "hub": false, "to": "0x4eec10e9c115a7ea67b59eea59c3a3c777fab236", "type": "funding" }, { "block": 94538219, "eth": 2.5, "from": "0x795834684cdec507ea9ee240fdb7e908567dd316", "hub": false, "to": "0xf0fd2e7718ea59a6ddfe884c7e4714ae2dd5610a", "type": "common_funder" } ], "hidden_infra": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "label": "uniswap_v4_pool_manager", "pct": 70.8524, "tags": [ "pool" ] }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "label": "pons_v2_launch_locker", "pct": 8.16327, "tags": [ "lp_locker" ] }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "label": "pons_v2_meme_hook", "pct": 0.000056807, "tags": [ "launchpad" ] }, { "address": "0xf69cd0fe7280773bb9b7c93ab68420d07290afa9", "label": null, "pct": 0.00000391777, "tags": [ "contract" ] }, { "address": "0x8cc5b884c33a261fe6aa6499bc7315d5aed57c67", "label": null, "pct": 0.0000000000000000000000002, "tags": [ "contract" ] }, { "address": "0x8f10b468b06c6fd214b65f87778827f7d113f996", "label": null, "pct": 0.0000000000000000000000001, "tags": [ "contract" ] }, { "address": "0xe6eeda550918638529c6cf2ea14f9ea0572d6f88", "label": null, "pct": 0.0000000000000000000000001, "tags": [ "contract" ] } ], "nodes": [ { "cluster": "c_80b9b545", "id": "0xdebabd206e5a73dd81a9211533a1bd610c006d20", "label": null, "pct": 2.19541, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 88.6343 }, { "cluster": null, "id": "0xb6815093cf0108d146aee2e98e53c17287c42393", "label": null, "pct": 1.86, "tags": [ "whale" ], "value_usd": 75.0931 }, { "cluster": null, "id": "0xc3403905b4e0ffaf973663ad261639087091a5da", "label": null, "pct": 1.68482, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 68.0207 }, { "cluster": "c_377c5b", "id": "0x4eec10e9c115a7ea67b59eea59c3a3c777fab236", "label": null, "pct": 1.46153, "tags": [ "whale" ], "value_usd": 59.0056 }, { "cluster": "c_80b9b545", "id": "0xf0fd2e7718ea59a6ddfe884c7e4714ae2dd5610a", "label": null, "pct": 1.41306, "tags": [ "smart_account", "whale" ], "value_usd": 57.049 }, { "cluster": "c_377c5b", "id": "0xa0686afb77ed32fbb402a39642d05158b9fa4c96", "label": null, "pct": 1.09981, "tags": [ "whale" ], "value_usd": 44.4023 }, { "cluster": null, "id": "0x1795eacd1a377133002de3bca335336a19dfa2ca", "label": null, "pct": 1.03781, "tags": [ "whale" ], "value_usd": 41.8992 }, { "cluster": null, "id": "0xa2bfbc13abbf678ed8c743e662ba43fbe18159ea", "label": null, "pct": 1, "tags": [ "whale" ], "value_usd": 40.3726 } ], "token": "0x192b126efea71ca5e7767bc6fc53038d869fbbba" }, "meta": { "block": 100415559, "block_age_ms": 766, "block_ts": 1793225982000, "chain": "robinhood", "finalized_block": 100405028, "lag_ms": 31, "safe_block": 100408671 } } ``` What this tells you - `clusters` has two entries. The larger, `c_80b9b545`, joins `0xdebabd206e5a73dd81a9211533a1bd610c006d20` and `0xf0fd2e7718ea59a6ddfe884c7e4714ae2dd5610a`: together `pct: 3.60847` of supply, so `risk: "medium"` (over 3%). - Why they’re linked: `links.shared_funders` names `0x795834684cdec507ea9ee240fdb7e908567dd316`, which first funded both (`wallets: 2`). It is also the `root_funder`. The two `common_funder` edges show it sent 1.2 ETH at block 78435467 and 2.5 ETH at block 94538219. - The second cluster, `c_377c5b`, is a direct link: `links.funding_between: 1`. The `funding` edge shows `0xa0686afb77ed32fbb402a39642d05158b9fa4c96` sent `0x4eec10e9c115a7ea67b59eea59c3a3c777fab236` its first 2 ETH at block 9427558, so the funder is a member and the `root_funder`. Together they hold `pct: 2.56134`: `risk: "low"`. - All three funding edges are far older than Rebot: its launch transaction was at block 100238938. A link records how a wallet was first funded, which can tie wallets together long before they bought this token. - Each member node carries its cluster id (`cluster: "c_80b9b545"`), and `includes_dev: false` on both clusters: the developer isn’t among them. - `hidden_infra` shows where most of the supply is: the Uniswap v4 PoolManager `0x8366a39cc670b4001a1121b8f6a443a643e40951` holds 70.85% (the pool’s side) and the Pons launch locker `0x267444d099b10fb5ed7c3cc7b7c767adca574952` 8.16%. The largest real holder has 2.20%. [Bubble map reference](https://docs.crius.sh/reference/wallet-graph/bubble-map/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Two%20clusters%20among%20Rebot's%20top%20holders&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fread-a-bubble-map%2F%23clusters%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x192b126efea71ca5e7767bc6fc53038d869fbbba%2Fbubblemap%3Ftop%3D100%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallet-graph/bubble-map/) ### No clusters at all: sockets Are the top 50 holders of sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a) connected to each other? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 138 lines (arrays trimmed)** ```json { "data": { "block": null, "clusters": [], "edges": [], "hidden_infra": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "label": "uniswap_v4_pool_manager", "pct": 22.2145, "tags": [ "pool" ] }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "label": "pons_v2_launch_locker", "pct": 8.16327, "tags": [ "lp_locker" ] }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "label": "pons_v2_meme_hook", "pct": 6.06241, "tags": [ "launchpad" ] }, { "address": "0xbe0b139abc90723af76a89d3051f60ba1b64c8d9", "label": null, "pct": 1, "tags": [ "contract" ] }, { "address": "0xdead000000000000000000000000000000000000", "label": null, "pct": 0.81637, "tags": [ "burn" ] }, { "address": "0x0afeb98a5b40bc38e9cf5a3f202c17843a7ce553", "label": null, "pct": 0.168848, "tags": [ "contract" ] } ], "nodes": [ { "cluster": null, "id": "0xe1a5961d61200006577f2e96114d212889213cd6", "label": null, "pct": 2.82829, "tags": [ "smart_account", "whale" ], "value_usd": 1286.54 }, { "cluster": null, "id": "0xa4109b8d391723d8f6bcfc5d75e6996f61062f76", "label": null, "pct": 2.70423, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1230.11 }, { "cluster": null, "id": "0xf2caeb616fb22a8acc00afbaeee83b24f18b354b", "label": null, "pct": 2.23269, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1015.61 }, { "cluster": null, "id": "0xb9b642020e216e84887ad414e067928e380bbbd5", "label": null, "pct": 1.77186, "tags": [ "whale" ], "value_usd": 805.992 }, { "cluster": null, "id": "0xc9cafef2258a07f8455da92438360318b34848e2", "label": null, "pct": 1.73578, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 789.58 }, { "cluster": null, "id": "0xc51c3340b898a67fed7c9f18db75b346dd04f8a0", "label": null, "pct": 1.63331, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 742.968 } ], "token": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "meta": { "block": 100406890, "block_age_ms": 885, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 30, "safe_block": 100401329 } } ``` What this tells you - `clusters: []` and `edges: []`: none of the top 50 holders funded each other, shared a funder or sent each other tokens. Each bubble stands alone. - The largest holder, `0xe1a5961d61200006577f2e96114d212889213cd6`, has `pct: 2.82829` (about $1,287, `value_usd`). The holder base is spread out. - `tags` say who the holders are: `whale` (1% or more of supply), `smart_account`, and `fomo` for smart accounts created by the FOMO trading app, as with `0xa4109b8d391723d8f6bcfc5d75e6996f61062f76` (2.70%). - `hidden_infra` lists the PoolManager (22.21%), the Pons launch locker (8.16%), the PonsV2MemeHook `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` (6.06%) and the burn address `0xdead000000000000000000000000000000000000` (0.82%). Left on the map, the PoolManager would look like the largest holder by far. [Bubble map reference](https://docs.crius.sh/reference/wallet-graph/bubble-map/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20No%20clusters%20at%20all%3A%20sockets&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fread-a-bubble-map%2F%23clean-map%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%2Fbubblemap%3Ftop%3D50%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How to read the map **Nodes** are holders: `id`, `pct` of supply, `value_usd`, `label`, `tags` and `cluster` (`null` when unlinked). Size them by `pct` and color them by `cluster`. **Edges** say why two bubbles are connected. Funding edges carry `from`, `to`, `type`, `eth`, `block` and `hub`: | Edge `type` | Means | | --- | --- | | `funding` | One holder sent the other its first ETH (at least 0.00001 ETH), like `0xa0686afb77ed32fbb402a39642d05158b9fa4c96` → `0x4eec10e9c115a7ea67b59eea59c3a3c777fab236` above. | | `common_funder` | An outside wallet that first funded two or more of the shown holders, like `0x795834684cdec507ea9ee240fdb7e908567dd316`. | | `transfers` | Holders sent this token to each other. | **Clusters** are groups of holders joined by those links: | Field | Meaning | | --- | --- | | `id` | Cluster id, also set on each member node's `cluster`. | | `wallets`, `members` | How many holders are in it, and their addresses, largest first. | | `pct` | Share of supply the cluster holds together. | | `risk` | `high` above 10% of supply, `medium` above 3%, else `low`. | | `links` | Why they're one cluster: `shared_funders` (each with the number of members it funded), and counts of `funding_between` members and `token_transfers` between them. | | `root_funder` | The funder shared by the most members, else the member that funded the most others. Never an exchange or bridge. | | `includes_dev` | The token's developer is in the cluster. | What doesn’t link wallets matters as much: funding from exchanges, bridges, bots and app relayers (one signer paying the same 100+ wallets again and again), funders that paid more than 500 wallets, dust sends, and lookalike addresses used for address poisoning. Pass `include=hubs` or `include=funders` to see those funders, and `edges=funding,transfers` to choose which edge types come back. ## Use it in your app 1. **Fetch the map with a Starter key.** `top=100` is a good default; each call costs 10 credits, so cache it per token for a few minutes. 2. **Draw it with any force-directed graph library.** `nodes` and `edges` map directly to nodes and links (`from` → source, `to` → target). 3. **Lead with the clusters.** Show each cluster’s `pct` and `risk` next to the map, and say when `includes_dev` is `true`. 4. **List `hidden_infra` separately.** Users want to know where the rest of the supply is: in the pool, locked or burned. ```js // Turn a bubble map into nodes and links for a force-directed graph (d3-force, vis-network, …). const token = "0x192b126efea71ca5e7767bc6fc53038d869fbbba"; // Rebot const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/bubblemap?top=100`, { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data } = await res.json(); const nodes = data.nodes.map((n) => ({ id: n.id, radius: 4 + Math.sqrt(n.pct ?? 0) * 6, group: n.cluster ?? n.id })); const ids = new Set(nodes.map((n) => n.id)); for (const e of data.edges) for (const a of [e.from, e.to]) if (!ids.has(a)) ids.add(a) && nodes.push({ id: a, radius: 3, group: "funder" }); const links = data.edges.map((e) => ({ source: e.from, target: e.to, kind: e.type })); for (const c of data.clusters) console.log(`cluster ${c.id}: ${c.wallets} wallets, ${c.pct}% (${c.risk})`); console.log(`not on the map: ${data.hidden_infra.map((h) => `${h.label ?? h.tags[0]} ${h.pct}%`).join(", ")}`); ``` Clusters at launch The bubble map links today’s top holders. To see whether the launch buyers were linked, which matters even after they sold, use [`/bundles`](https://docs.crius.sh/guides/detect-bundles-and-snipers/): it builds the same kind of clusters over the first 300 blocks of trading. ## Frequently asked questions **What is a bubble map?** A picture of a token's top holders where each holder is a bubble sized by how much it holds, and lines connect holders that are linked: one funded the other, they were funded by the same wallet, or they moved the token between them. A big group of connected bubbles is one owner spread over many wallets. **Why isn't the liquidity pool on the bubble map?** Because it isn't a holder. Pools, the Uniswap v4 PoolManager, LP lockers, hooks, burn addresses, routers, other contracts and exchanges are moved to `hidden_infra` with their share of supply. Everyone trades through them, so drawing them would link unrelated wallets. Add `include=infra` to draw them; they still never join a cluster. **Why are two wallets funded by the same exchange not in one cluster?** Exchanges, bridges, bots and app relayers fund thousands of unrelated people, so they never link wallets. A funder that paid more than 500 wallets is treated the same way. `include=hubs` shows those funding edges, marked `hub: true`, without using them for clusters. **Can I see a bubble map from the past?** Yes: pass `block` and the map uses holder balances at that block, for example to see who held a token at its peak. **How many holders can the map show?** `top` sets how many holders become nodes: 100 by default, up to 500. Infrastructure doesn't use up places, so you always get `top` real holders when the token has that many. ## Related [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Guide **Connected wallets** Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Read](https://docs.crius.sh/guides/find-connected-wallets/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [API reference **Bubble map API** The top holders (top, up to 500) as nodes and the links between them as edges: funding between holders, token transfers between holders, and funders shared by two or more of them. Read](https://docs.crius.sh/reference/wallet-graph/bubble-map/) --- # Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume > Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades. Source: https://docs.crius.sh/guides/robinhood-chain-dex-data/ · Updated 2026-10-28 Short answer Swaps on Robinhood Chain run through Uniswap v4 (53% of 24h DEX volume in the captured stats), Uniswap v3 (44%), Uniswap v2 and launchpad bonding curves (`pons_curve`, `launch_curve`). Crius indexes all of them: `GET /v1/robinhood/stats` splits volume and new pools per DEX (`dex.by_dex`, `pools.by_dex`), `/token/{address}/pools` lists a token's pools on every DEX, `/token/{address}/trades` tags each swap with its `dex`, and `/candles` and `/volume` chart it. All on the anonymous plan. [GET `/stats`](https://docs.crius.sh/reference/chain/chain-stats/) [GET `/token/{address}/pools`](https://docs.crius.sh/reference/tokens/token-markets/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) [GET `/pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) [GET `/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) There is no single Robinhood Chain DEX. Swaps on Robinhood Chain run through four kinds of venue: Uniswap v4 pools (many with hooks), Uniswap v3 pools at several fee tiers, Uniswap v2 pairs, and the bonding curves of token launchpads, where new tokens trade until they graduate into a Uniswap pool. If you searched for a “Robinhood swap DEX”, these are the pools your swap ends up in, whatever app you trade from. Crius indexes every one of them from its own archive nodes, so one API gives you DEX trades, pools, candles and volume for the whole chain, with the DEX of every swap named. ## Which DEXs trade on Robinhood Chain Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/chain-stats/) ### 24 hours of Robinhood Chain DEX volume, split by DEX How much volume did each DEX on Robinhood Chain handle in the last 24 hours, and where are new pools being created? GET/v1/robinhood/stats?window=24h **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=24h" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=24h"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=24h", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 100 lines (arrays trimmed)** ```json { "data": { "blocks": { "active_wallets": 194641, "avg_block_time_ms": 101, "tps_1m": 44.6833, "txs": 2430221 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 114839, "pons_curve": 6920073, "uniswap_v2": 6992610, "uniswap_v3": 235116790, "uniswap_v4": 286137338 }, "traders": 148079, "trades": 1769098, "volume_usd": 535281650, "wash_volume_usd": 100833980 }, "eth_usd": 2355.49, "finalized_block": 100397649, "gas": { "avg_swap_cost_eth": 0.00000791235, "avg_swap_cost_usd": 0.0186374, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021042 }, "head_block": 100406547, "l1_block": 26294099, "launchpads": [ { "graduated": 16, "launches": 1780, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 25485280 }, { "graduated": 0, "launches": 508, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 10784246 }, { "graduated": 0, "launches": 20, "launchpad": "bankr", "launchpad_name": "Bankr", "volume_usd": 595435 } ], "liquidity": { "locked_lp_usd": 44712347, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322714989 }, "pools": { "by_dex": { "launch_curve": 1201, "pons_curve": 1780, "uniswap_v2": 1483, "uniswap_v3": 224, "uniswap_v4": 5457 }, "new": 10145 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100401329, "tokens": { "by_attribution": { "known_launchpad": 3527, "other": 4095 }, "new": 7622, "new_1h": 418 }, "window": "24h" }, "meta": { "block": 100406547, "block_age_ms": 1026, "block_ts": 1793225052000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100397649, "lag_ms": 26, "safe_block": 100401329 } } ``` What this tells you - `dex.volume_usd: 535281650` across `dex.trades: 1769098` by `dex.traders: 148079`: about $302 per trade on average. - `dex.by_dex` adds up exactly to that total: `uniswap_v4` 286,137,338 (53.46%), `uniswap_v3` 235,116,790 (43.92%), `uniswap_v2` 6,992,610 (1.31%), `pons_curve` 6,920,073 (1.29%) and `launch_curve` 114,839 (0.02%). - `dex.wash_volume_usd: 100833980` is kept out of those numbers: buys and sells of one token in one pool inside one transaction that cancel within 2%. - `pools.by_dex` counts pools created in the window (`pools.new: 10145`): 5,457 on Uniswap v4, 1,780 Pons curves, 1,483 Uniswap v2 pairs, 1,201 other launch curves and only 224 Uniswap v3 pools. v3 gets few new pools but almost half the volume: the deep WETH/USDG and stock pools are v3 (next example). - Launchpad tokens keep trading after graduation, so a launchpad’s volume is larger than its curve’s: `launchpads` shows Pons tokens at `volume_usd: 25485280` against $6,920,073 on `pons_curve`. [Chain stats reference](https://docs.crius.sh/reference/chain/chain-stats/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%2024%20hours%20of%20Robinhood%20Chain%20DEX%20volume%2C%20split%20by%20DEX&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-dex-data%2F%23dex-volume-by-dex%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fstats%3Fwindow%3D24h%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The DEX venues and how pools are identified | `dex` value | What it is | Pool id in the API | | --- | --- | --- | | `uniswap_v4` | Uniswap v4 pools inside one PoolManager contract, with an optional hook and, with some hooks, a dynamic fee. | 32-byte pool id | | `uniswap_v3` | Uniswap v3 concentrated-liquidity pools, one per pair and fee tier (`fee` 100 = 0.01%, 500 = 0.05%, 3000 = 0.3%, 10000 = 1%). | Pool address | | `uniswap_v2` | Uniswap v2 constant-product pairs (Flap.sh tokens graduate into these). | Pair address | | `pons_curve` | The Pons launchpad's bonding curve, before a token graduates into a Uniswap v4 pool. | Curve contract address | | `launch_curve` | Other launchpads' bonding curves, such as the Flap.sh curve kept inside the Flap Portal. | Curve address (for Flap.sh, the token's own address) | The same `dex` values appear on pools (`/pools`, `/pool/{pool}`), trades (`/trades`, `/wallet/{address}/trades`) and in `/stats`. How liquidity is measured on each version, and what v4 hook permissions mean, is in [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/); the launchpad curves are in [Launchpads](https://docs.crius.sh/concepts/launchpads/). ## One token’s markets across DEXs Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-markets/) ### WETH's ten deepest pools: Uniswap v3, v2 and v4 On which DEXs does WETH (0x0bd7d308f8e1639fab988df18a8011f41eacad73) trade, and which pools are deepest? GET/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/pools?limit=10 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/pools?limit=10" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/pools?limit=10"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/pools?limit=10", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 365 lines (arrays trimmed)** ```json { "data": [ { "amounts": { "token0": 3796.9, "token1": 3868655 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 1506281, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 100, "hook": null, "is_price_pool": false, "liquidity_usd": 7737311, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_usd": 2359.52, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 3868655, "state": { "liquidity": 2013245941965598379, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 3848495428250050143041601, "tick": -198659 }, "swaps_indexed": 1976194, "tick_spacing": 1 }, { "amounts": { "token0": 832.729, "token1": 3899997650 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 21881211, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 10000, "hook": null, "is_price_pool": false, "liquidity_usd": 3927827, "pool": "0xb7f10f74b39291b9290b779978e19a7637c742d6", "price_usd": 2358.41, "quote": { "address": "0x5cb6f181081301b44905f3ae15419112ecabd8a6", "logo": "https://api.crius.sh/v1/robinhood/logo/0x5cb6f181081301b44905f3ae15419112ecabd8a6.png?size=128", "symbol": "PIPEDOG" }, "quote_liquidity_usd": 1963914, "state": { "liquidity": 1789170497408269004482213, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 170070849739713008914878566088473, "tick": 153440 }, "swaps_indexed": 4426, "tick_spacing": 200 }, { "amounts": { "token0": 1084.94, "token1": 1701846 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 169464, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 500, "hook": null, "is_price_pool": false, "liquidity_usd": 3403692, "pool": "0x69bfaf19c9f377bb306a89aed9f6b07e2c1a8d9a", "price_usd": 2358.8, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 1701846, "state": { "liquidity": 724102881944651186, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 3847913576269808858344466, "tick": -198662 }, "swaps_indexed": 223467, "tick_spacing": 10 }, { "amounts": { "token0": 580.994, "token1": 676.533 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 26815161, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 500, "hook": null, "is_price_pool": false, "liquidity_usd": 2740442, "pool": "0xddcbba3666f578e3f09516f21ff85bfee859ab5e", "price_usd": 2358.41, "quote": { "address": "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", "logo": null, "symbol": "SPY" }, "quote_liquidity_usd": 1370221, "state": { "liquidity": 10523127081908359237112, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 138581615369457152757237488930, "tick": 11183 }, "swaps_indexed": 100737, "tick_spacing": 10 }, { "amounts": { "token0": 499.985, "token1": 4651864 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 8963150, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 10000, "hook": null, "is_price_pool": false, "liquidity_usd": 2358336, "pool": "0x10cc6bd38112cac182db90b6a71d8bb5939526ba", "price_usd": 2358.41, "quote": { "address": "0x39dbed3a2bd333467115de45665cc57f813c4571", "logo": "https://api.crius.sh/v1/robinhood/logo/0x39dbed3a2bd333467115de45665cc57f813c4571.png?size=128", "symbol": "PONS" }, "quote_liquidity_usd": 1179168, "state": { "liquidity": 115212974689589284353544, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 7129899659713896502217055114417, "tick": 89998 }, "swaps_indexed": 18108, "tick_spacing": 200 }, { "amounts": { "token0": 424.192, "token1": 2.22704 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 61203931, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 500, "hook": null, "is_price_pool": false, "liquidity_usd": 2000837, "pool": "0x934e60d1c6c34242b92159a5bcc710fafa50ad87", "price_usd": 2358.41, "quote": { "address": "0xcec185eb182c47d1ba1efc84e6959e18cd620be4", "logo": null, "symbol": "cbBTC" }, "quote_liquidity_usd": 1000418, "state": { "liquidity": 9118051092747224, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 135016153878905788429634, "tick": -265663 }, "swaps_indexed": 15565, "tick_spacing": 10 }, { "amounts": { "token0": 10931021, "token1": 364.172 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 88836, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 10000, "hook": null, "is_price_pool": false, "liquidity_usd": 1717734, "pool": "0xa70fc67c9f69da90b63a0e4c05d229954574e313", "price_usd": 2358.41, "quote": { "address": "0x020bfc650a365f8bb26819deaabf3e21291018b4", "logo": "https://api.crius.sh/v1/robinhood/logo/0x020bfc650a365f8bb26819deaabf3e21291018b4.png?size=128", "symbol": "CASHCAT" }, "quote_liquidity_usd": 858867, "state": { "liquidity": 94572319906131283032430, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 526599349657185029571606764, "tick": -100278 }, "swaps_indexed": 9884, "tick_spacing": 200 }, { "amounts": { "token0": 336.501, "token1": 2.0889 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 49261514, "dex": "uniswap_v3", "dynamic_fee": false, "fee": 3000, "hook": null, "is_price_pool": false, "liquidity_usd": 1587216, "pool": "0xd30e44aae604b42a63f6f9a8109fd0408f35b9fb", "price_usd": 2358.41, "quote": { "address": "0xcec185eb182c47d1ba1efc84e6959e18cd620be4", "logo": null, "symbol": "cbBTC" }, "quote_liquidity_usd": 793608, "state": { "liquidity": 20852775737110336, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 135077002547457756452184, "tick": -265654 }, "swaps_indexed": 3071, "tick_spacing": 60 }, { "amounts": { "token0": 333.504, "token1": 1250777 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 1024127, "dex": "uniswap_v2", "dynamic_fee": false, "fee": 3000, "hook": null, "is_price_pool": false, "liquidity_usd": 1573076, "pool": "0xd95e8e2cd04c207625c6f23c974d365a5f3a91d3", "price_usd": 2358.41, "quote": { "address": "0xc6911796042b15d7fa4f6cde69e245ddcd3d9c31", "logo": "https://api.crius.sh/v1/robinhood/logo/0xc6911796042b15d7fa4f6cde69e245ddcd3d9c31.png?size=128", "symbol": "VIRTUAL" }, "quote_liquidity_usd": 786538, "state": { "liquidity": 0, "reserve0": 333503751967026394755, "reserve1": 1250777463256292048889490, "sqrt_price_x96": 0, "tick": 0 }, "swaps_indexed": 5001, "tick_spacing": 0 }, { "amounts": { "token0": 295.854, "token1": 30000000 }, "base": { "address": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", "logo": null, "symbol": "WETH" }, "created_block": 16778178, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 10000, "hook": null, "is_price_pool": false, "liquidity_usd": 1395491, "pool": "0xb9c2bb68f6862b936ada28e5d5cba37101871b24940815f62d1492aa55b3f87a", "price_usd": 2358.41, "quote": { "address": "0xdb87393727b666c43f5aecb03d8b419ba54d9b03", "logo": "https://api.crius.sh/v1/robinhood/logo/0xdb87393727b666c43f5aecb03d8b419ba54d9b03.png?size=128", "symbol": "SWOGE" }, "quote_liquidity_usd": 697745, "state": { "liquidity": 102423371105951266641285771600, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 24422169966449098211168616, "tick": -161701 }, "swaps_indexed": 0, "tick_spacing": 60 } ], "meta": { "block": 100454091, "block_age_ms": 663, "block_ts": 1793229925000, "chain": "robinhood", "finalized_block": 100442370, "lag_ms": 143, "next_cursor": "10", "safe_block": 100446224, "total": 689857 } } ``` What this tells you - The deepest pool is Uniswap v3 WETH/USDG `0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca` at `fee: 100` (0.01%): `liquidity_usd: 7737311` and `swaps_indexed: 1976194`. A second WETH/USDG v3 pool, `0x69bfaf19c9f377bb306a89aed9f6b07e2c1a8d9a` at `fee: 500`, holds $3,403,692. - Eight of the ten rows are `uniswap_v3`, including WETH/SPY (`0xddcbba3666f578e3f09516f21ff85bfee859ab5e`, $2,740,442) and two WETH/cbBTC tiers (500 and 3000). - Row nine is `uniswap_v2`: WETH/VIRTUAL `0xd95e8e2cd04c207625c6f23c974d365a5f3a91d3` with `fee: 3000` and $1,573,076. - Row ten is `uniswap_v4`: WETH/SWOGE, pool id `0xb9c2bb68f6862b936ada28e5d5cba37101871b24940815f62d1492aa55b3f87a`, `hook: null`, $1,395,491 of liquidity but `swaps_indexed: 0`. Depth is not activity: check trades before treating a pool as a market. - `is_price_pool` is `false` on every row: WETH’s price doesn’t come from these pools. In the `prices` sample its `source_pool` is `0xbac3aa3b91584a53a579b3c999a56756e954e59247e497bad1d25a4334bde551`, a 32-byte Uniswap v4 pool id (see [batch prices](https://docs.crius.sh/guides/get-prices-for-many-tokens/)). [Token markets reference](https://docs.crius.sh/reference/tokens/token-markets/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20WETH's%20ten%20deepest%20pools%3A%20Uniswap%20v3%2C%20v2%20and%20v4&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-dex-data%2F%23weth-pools%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0bd7d308f8e1639fab988df18a8011f41eacad73%2Fpools%3Flimit%3D10%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Which DEX filled each trade Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### WETH trades on Uniswap v3, through three different apps Who traded WETH (0x0bd7d308f8e1639fab988df18a8011f41eacad73) most recently, on which DEX and through which router? GET/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 144 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 0.241346083005198446, "amount_quote": 569.019791, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 239930, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000503853, "total_eth": 0.00000503853, "usd": 0.0118753 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-6-44", "market_cap_usd_at_trade": 90494155, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00034, "price_usd": 2357.69, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "signer_label": null, "trader": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "trader_app": null, "trader_label": "fomo_relayer_3", "ts": 1793225076000, "tx": "0x5b474612139f91cb226cf9e5097244dbb896a86834d8adbd263641c96d67b9f7", "tx_index": 6, "type": "buy", "value_eth": 0.241428, "value_usd": 569.02, "via": [] }, { "amount_base": 0.021222351350879784, "amount_quote": 50.025498, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 455557, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000095667, "total_eth": 0.0000095667, "usd": 0.0225477 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-1-12", "market_cap_usd_at_trade": 90475571, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00013, "price_usd": 2357.21, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x800539138ff0510191277f6b5c58fb94ae700064", "signer_label": null, "trader": "0x800539138ff0510191277f6b5c58fb94ae700064", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0x0bde8abf03edce0f2ba13a3398ec2575b177c3f2d85eef77c25c7899a9949311", "tx_index": 1, "type": "sell", "value_eth": 0.0212252, "value_usd": 50.0255, "via": [ "uniswap_universal_router" ] }, { "amount_base": 0.011210844980975568, "amount_quote": 26.431588, "block": 100406782, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020904, "gas_used": 315171, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000658833, "total_eth": 0.00000658833, "usd": 0.015528 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406782-10-32", "market_cap_usd_at_trade": 90493695, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00033, "price_usd": 2357.68, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "signer_label": null, "trader": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0xa3a9ddaaa96d7cc4d300eb5ae37d174755cee56aec3e5e15ae7c3adf437a113b", "tx_index": 10, "type": "buy", "value_eth": 0.0112146, "value_usd": 26.4316, "via": [ "gmgn_swap_router" ] } ], "meta": { "block": 100406789, "block_age_ms": 367, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "next_cursor": "100406782-32", "safe_block": 100401329 } } ``` What this tells you - All three trades have `dex: "uniswap_v3"` and `pool: "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca"`: the 0.01% WETH/USDG pool from the example above. - They reached it three ways. The first, a buy of 0.241346083005198446 WETH for 569.019791 USDG (`value_usd: 569.02`), has `via: []` and `trader_label: "fomo_relayer_3"`; the second has `via: ["uniswap_universal_router"]`; the third `via: ["gmgn_swap_router"]`. Routers and apps send swaps; the `dex` and `pool` are where they fill. - Each trade carries its gas: the first used 239,930 gas for `fees.gas.usd: 0.0118753`. - `finality: "latest"` on all three: they were seconds old, not yet posted to Ethereum. [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20WETH%20trades%20on%20Uniswap%20v3%2C%20through%20three%20different%20apps&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-dex-data%2F%23weth-trades-dex%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0bd7d308f8e1639fab988df18a8011f41eacad73%2Ftrades%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Which endpoint for which DEX question | Question | Endpoint | Key fields | | --- | --- | --- | | Volume and new pools per DEX, chain-wide | [`GET /stats`](https://docs.crius.sh/reference/chain/chain-stats/) | `dex.by_dex`, `pools.by_dex`, `dex.wash_volume_usd` | | DEX volume per day or hour, in your time zone | [`GET /volume`](https://docs.crius.sh/reference/chain/volume-history/) | `daily.rows`, `hourly.rows`, `windows` | | Every pool of a token, on every DEX | [`GET /token/{address}/pools`](https://docs.crius.sh/reference/tokens/token-markets/) | `dex`, `pool`, `fee`, `hook`, `liquidity_usd`, `is_price_pool` | | One pool's reserves, fee, hook, LP lock and stats | [`GET /pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) | `dex`, `state.reserves`, `tvl_usd`, `lp`, `stats` | | Every swap of a token, with DEX and router | [`GET /token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) | `dex`, `pool`, `via`, `trader`, `value_usd` | | Price candles across a token's markets or one pool | [`GET /token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) | `pool=` for one DEX pool | | Uniswap v4 hooks and their risk | [`GET /hooks`](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) (Free plan) | `risk_level`, `flags` | | Tokens with the most DEX volume | [`GET /tokens`](https://docs.crius.sh/reference/discovery/token-lists/) | `list=top_volume`, `clean=true` | For swaps as they happen, subscribe to trades on the [WebSocket stream](https://docs.crius.sh/reference/stream/) instead of polling the tape. ## Use it in your app 1. **Show the DEX mix.** Call `/stats?window=24h` once a minute from your backend and draw `dex.by_dex` as shares of `dex.volume_usd`. 2. **List a token’s markets.** Call `/token/{address}/pools` and group rows by `dex`. Link each row to its pool with the `pool` value: an address for v2, v3 and curves, a 32-byte id for v4. 3. **Label each trade.** On the trade tape, show `dex` as the venue and `via` or `trader_label` as the app, so users see “Uniswap v3 via GMGN” rather than a router address. 4. **Chart one venue when you need to.** Candles merge a token’s real markets by default; pass `pool=` to chart a single DEX pool. ```python import requests API = "https://api.crius.sh/v1/robinhood" dex = requests.get(f"{API}/stats", params={"window": "24h"}, timeout=10).json()["data"]["dex"] for name, usd in sorted(dex["by_dex"].items(), key=lambda x: -x[1]): print(f"{name:13} ${usd:>14,.0f} {100 * usd / dex['volume_usd']:5.2f}%") weth = "0x0bd7d308f8e1639fab988df18a8011f41eacad73" pools = requests.get(f"{API}/token/{weth}/pools", params={"limit": 50}, timeout=10).json()["data"] by_dex = {} for p in pools: by_dex.setdefault(p["dex"], []).append(p) for name, rows in by_dex.items(): top = rows[0] print(f"{name}: {len(rows)} pools, deepest {top['pool']} ${top['liquidity_usd']:,.0f}") ``` Volume is organic by default `/stats` and `/volume` count DEX volume in USD at trade time and leave out same-transaction wash trades and single trades valued above $25,000,000 (mispriced quotes). `/volume` returns these rules in `method`. ## Frequently asked questions **What is the main DEX on Robinhood Chain?** Uniswap, in three versions. In the captured 24-hour stats, Uniswap v4 handled $286,137,338 (about 53% of DEX volume) and Uniswap v3 $235,116,790 (about 44%). Uniswap v2 ($6,992,610) and the Pons bonding curve ($6,920,073) were about 1.3% each, and other launchpad curves $114,839. **Is there a Robinhood swap DEX?** In Crius's data, every swap on Robinhood Chain goes through a Uniswap v2, v3 or v4 pool or a launchpad bonding curve. Wallet apps, aggregators and trading bots route into those pools: the trade tape shows them in `via` (for example `uniswap_universal_router` or `gmgn_swap_router`) or in `trader_label`, while `dex` names the venue that filled the swap. **Does Crius have a Robinhood Chain DEX API?** Yes. The Crius API decodes every swap on every DEX on Robinhood Chain (chain id 4663): trades with their `dex`, `pool` and router, every pool of a token with its liquidity, pool details, OHLCV candles and chain-wide volume per DEX. The DEX endpoints are on the anonymous plan, so you can try them without a key. **How do I get the volume of each DEX on Robinhood Chain?** `GET /v1/robinhood/stats?window=24h` (or `1h`, `7d`) returns `dex.by_dex`, the USD volume per DEX over the window, with same-transaction wash trades left out and reported in `dex.wash_volume_usd`. For daily or hourly history across all DEXs, use `GET /v1/robinhood/volume`. **Are Uniswap v4 hooks indexed?** Yes. Every v4 pool is indexed with its hook, and every hook is inspected for its permissions, code and what happened in its pools. A token's pools show `hook.address` and `hook.name`; [Check the risk of a Uniswap v4 hook](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) covers the hook endpoints. ## Related [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [API reference **Chain stats API** DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (1h, 24h, 7d). Read](https://docs.crius.sh/reference/chain/chain-stats/) --- # Robinhood Chain RPC, chain ID 4663 and network settings > Robinhood Chain network settings: chain ID 4663 (0x1237), public RPC URLs, ETH gas, the block explorer, an eth_chainId check and what an indexed API adds. Source: https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/ · Updated 2026-10-28 Short answer Robinhood Chain is an Arbitrum Orbit L2 with chain ID `4663` (`0x1237`) and ETH as its gas token. The official public RPC is `https://rpc.mainnet.chain.robinhood.com` (fallback `https://robinhood-rpc.publicnode.com`) and the block explorer is `https://robin.etherscan.io`. For prices, trades, holders and launches, `GET /v1/robinhood/stats` and the rest of the Crius API answer without an RPC. [GET `/v1/chains`](https://docs.crius.sh/reference/chain/supported-chains/) [GET `/stats`](https://docs.crius.sh/reference/chain/chain-stats/) [GET `/v1/status`](https://docs.crius.sh/reference/chain/service-status/) Robinhood Chain is an Ethereum layer-2 network built on **Arbitrum Orbit**, with chain ID **4663** (`0x1237` in hex) and **ETH** as its gas token. To connect a wallet or a script you need four things: the chain ID, an RPC URL (`https://rpc.mainnet.chain.robinhood.com`), the currency symbol ETH and the block explorer (`https://robin.etherscan.io`). The chain’s main assets are WETH, the **USDG** dollar stablecoin and **tokenized stocks** such as NVDA and TSLA; the [Robinhood Chain concept page](https://docs.crius.sh/concepts/robinhood-chain/) lists the WETH and USDG addresses. ## Network settings: add Robinhood Chain to a wallet Enter these values in a wallet’s “add network” form, or in your app’s chain config. | Setting | Value | | --- | --- | | Network name | Robinhood Chain | | RPC URL | `https://rpc.mainnet.chain.robinhood.com` | | Fallback RPC URL | `https://robinhood-rpc.publicnode.com` | | Chain ID | `4663` (hex `0x1237`) | | Currency symbol | ETH (18 decimals) | | Block explorer | `https://robin.etherscan.io` (alternative: [Hoodscan](https://hoodscan.co)) | From a dapp, the same settings go into the standard `wallet_addEthereumChain` request (EIP-3085), which takes the chain ID in hex: ```js await window.ethereum.request({ method: "wallet_addEthereumChain", params: [{ chainId: "0x1237", // 4663 chainName: "Robinhood Chain", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }, rpcUrls: ["https://rpc.mainnet.chain.robinhood.com", "https://robinhood-rpc.publicnode.com"], blockExplorerUrls: ["https://robin.etherscan.io"], }], }); ``` ## Check the chain ID over RPC Any JSON-RPC client can confirm it is talking to Robinhood Chain. `eth_chainId` takes no parameters: Terminal window ```bash curl -s -X POST https://rpc.mainnet.chain.robinhood.com \ -H 'content-type: application/json' \ -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId"}' # {"jsonrpc":"2.0","id":1,"result":"0x1237"} ``` `0x1237` is 4663. The fallback RPC returns the same result, and `net_version` returns the decimal string `"4663"`. `eth_blockNumber` gives the latest L2 block in hex; Robinhood Chain had passed block 100 million when these docs were written. ## Block time, gas and finality in one call An RPC tells you about one block at a time. The Crius chain stats endpoint sums up the network over a window, from Crius’s own archive nodes, without an API key. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/chain-stats/) ### Robinhood Chain over 24 hours: 101 ms blocks, 2-cent swaps How fast are Robinhood Chain blocks, what does gas cost, and how far behind the head are the safe and finalized blocks? GET/v1/robinhood/stats?window=24h **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=24h" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=24h"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=24h", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 100 lines (arrays trimmed)** ```json { "data": { "blocks": { "active_wallets": 194641, "avg_block_time_ms": 101, "tps_1m": 44.6833, "txs": 2430221 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 114839, "pons_curve": 6920073, "uniswap_v2": 6992610, "uniswap_v3": 235116790, "uniswap_v4": 286137338 }, "traders": 148079, "trades": 1769098, "volume_usd": 535281650, "wash_volume_usd": 100833980 }, "eth_usd": 2355.49, "finalized_block": 100397649, "gas": { "avg_swap_cost_eth": 0.00000791235, "avg_swap_cost_usd": 0.0186374, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021042 }, "head_block": 100406547, "l1_block": 26294099, "launchpads": [ { "graduated": 16, "launches": 1780, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 25485280 }, { "graduated": 0, "launches": 508, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 10784246 }, { "graduated": 0, "launches": 20, "launchpad": "bankr", "launchpad_name": "Bankr", "volume_usd": 595435 } ], "liquidity": { "locked_lp_usd": 44712347, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322714989 }, "pools": { "by_dex": { "launch_curve": 1201, "pons_curve": 1780, "uniswap_v2": 1483, "uniswap_v3": 224, "uniswap_v4": 5457 }, "new": 10145 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100401329, "tokens": { "by_attribution": { "known_launchpad": 3527, "other": 4095 }, "new": 7622, "new_1h": 418 }, "window": "24h" }, "meta": { "block": 100406547, "block_age_ms": 1026, "block_ts": 1793225052000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100397649, "lag_ms": 26, "safe_block": 100401329 } } ``` What this tells you - `chain_id: 4663` and `blocks.avg_block_time_ms: 101`: blocks arrived about every 100 ms over the window, with 2,430,221 transactions (`blocks.txs`) from 194,641 active wallets and 44.6833 transactions per second in the last minute (`tps_1m`). - `gas.l2_gas_price_gwei: 0.021042`: an average swap cost 0.00000791235 ETH, or $0.0186374 at `eth_usd: 2355.49`. - `head_block: 100406547`, `safe_block: 100401329` and `finalized_block: 100397649`: the safe block trails the head while batches wait to be posted to Ethereum, and finalized trails safe until Ethereum finalizes them ([Finality](https://docs.crius.sh/concepts/finality/)). - `l1_block: 26294099` is the Ethereum block at that time: inside a contract, `block.number` returns this L1 number, not the L2 block. - `reorgs.count: 0`: no blocks were reorganized in the 24 hours. [Chain stats reference](https://docs.crius.sh/reference/chain/chain-stats/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Robinhood%20Chain%20over%2024%20hours%3A%20101%20ms%20blocks%2C%202-cent%20swaps&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-rpc-and-chain-id%2F%23stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fstats%3Fwindow%3D24h%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · free](https://docs.crius.sh/reference/chain/supported-chains/) ### The chain as the Crius API serves it Which chain ID, native token and block time does the Crius API report for Robinhood Chain? GET/v1/chains **cURL** ```bash curl "https://api.crius.sh/v1/chains" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/chains"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/chains", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 15 lines (arrays trimmed)** ```json { "data": [ { "block_time_ms": 100, "chain_id": 4663, "name": "Robinhood Chain", "native": "ETH", "regions": [ "rigel" ], "slug": "robinhood", "type": "arbitrum_orbit_l2" } ] } ``` What this tells you - `chain_id: 4663`, `name: "Robinhood Chain"`, `native: "ETH"` and `type: "arbitrum_orbit_l2"`: the same network settings as the table above. - `block_time_ms: 100` is the nominal block time; the measured average is in `/stats` (`blocks.avg_block_time_ms`). - `slug: "robinhood"` is the path segment in every endpoint (`/v1/robinhood/...`); the chain ID works too (`/v1/4663/...`). - `/v1/chains` and `/v1/status` are public: no key and no credits. [Supported chains reference](https://docs.crius.sh/reference/chain/supported-chains/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20chain%20as%20the%20Crius%20API%20serves%20it&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Frobinhood-chain-rpc-and-chain-id%2F%23chains%0ARequest%3A%20GET%20%2Fv1%2Fchains%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What an RPC gives you, and what an indexed API adds An RPC node answers questions about raw state: a balance, a contract call, the logs in a block range. It is also how you send transactions. An indexed API has already read every block and turned the logs into answers. | Question | Over RPC | With the Crius API | | --- | --- | --- | | Send a transaction, estimate gas, read a nonce | `eth_sendRawTransaction`, `eth_estimateGas`, `eth_getTransactionCount` | Not available: Crius is read-only. Keep an RPC for this. | | What is this token worth in USD? | Find its pools, read `slot0` or reserves, then convert the quote to USD | `/token/{address}/price` (anonymous) | | Who holds this token? | Replay every `Transfer` log since the token's first block | `/token/{address}/holders` (Free plan) | | Which tokens launched in the last minute, and on which launchpad? | Watch every factory you know about | `/tokens?list=new` with `launchpad` on each row (anonymous) | | Is this token a honeypot, and what tax does it charge? | Read the contract and simulate a buy and a sell | `/token/{address}/security` (anonymous) | | Is the data final? | Ask for `safe` and `finalized` blocks yourself | `meta.safe_block`, `meta.finalized_block` and `meta.lag_ms` on every response | The [RPC migration guide](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/) maps each RPC read to its Crius call, with before-and-after code. ## Use it in your app 1. **Pin the chain ID.** Check `eth_chainId` returns `0x1237` when your app connects, and refuse to sign for any other chain. 2. **Use the RPC for writes.** Transactions, gas estimates, nonces and calls to your own contracts go through an RPC: the public one for testing, a dedicated provider or your own node in production. 3. **Read market data from an index.** Prices, trades, candles, holders, launches and security checks come from the Crius API; most of it works without a key. 4. **Watch the index.** `/v1/status` reports `status` (`live`, `catching_up`, `stalled`, `starting`) and `lag_ms`; every response carries `meta.block`. ```js // Confirm the network over RPC, then read chain-wide numbers from Crius. const RPC = "https://rpc.mainnet.chain.robinhood.com"; const rpc = await fetch(RPC, { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ jsonrpc: "2.0", id: 1, method: "eth_chainId" }), }); const chainId = parseInt((await rpc.json()).result, 16); if (chainId !== 4663) throw new Error(`wrong chain: ${chainId}`); const { data } = await (await fetch("https://api.crius.sh/v1/robinhood/stats?window=1h")).json(); console.log(`block time ${data.blocks.avg_block_time_ms} ms, swap ≈ $${data.gas.avg_swap_cost_usd}, head ${data.head_block}`); ``` Public RPCs are shared The public endpoints are free and serve everyone, so expect rate limits under load. Scanning history over them is slow: at about 10 blocks a second, a full backfill of logs is weeks of `eth_getLogs` calls. That history is what the Crius API already indexes, from block 0. ## Frequently asked questions **What is the chain ID of Robinhood Chain?** `4663`, or `0x1237` in hex. `eth_chainId` on the public RPC returns `"0x1237"` and `net_version` returns `"4663"`. Wallets, signing libraries (EIP-155) and `wallet_addEthereumChain` use this number. **What is the Robinhood Chain RPC URL?** The official public RPC is `https://rpc.mainnet.chain.robinhood.com`. `https://robinhood-rpc.publicnode.com` is a public fallback that returns the same chain ID. Both are shared by everyone, so production apps usually use a dedicated RPC provider or their own node for writes, and an indexed API such as Crius for market data. **What is the gas token on Robinhood Chain?** ETH. It has 18 decimals, like on Ethereum, and is shown with the symbol ETH in wallets. Fees are low: in the 24-hour `stats` sample the L2 gas price was 0.021042 gwei and an average swap cost $0.0186374 (`gas.avg_swap_cost_usd`). **Which block explorer does Robinhood Chain use?** Robinhood Chain Etherscan at [robin.etherscan.io](https://robin.etherscan.io) is the explorer to put in wallet settings. [Hoodscan](https://hoodscan.co) is an alternative explorer for the same chain. **Can I use the chain ID in Crius API URLs?** Yes. The chain segment of every path takes the slug or the chain ID, so `/v1/4663/stats` and `/v1/robinhood/stats` return the same data. The examples in these docs use `robinhood`. ## Related [Concept **Robinhood Chain** What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Read](https://docs.crius.sh/concepts/robinhood-chain/) [Guide **Migrate from RPC** Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs. Read](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) [Guide **Chain stats dashboard** Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Read](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/) [API reference **Chain stats API** DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (1h, 24h, 7d). Read](https://docs.crius.sh/reference/chain/chain-stats/) [Docs **Quickstart** Create a free Crius account, get an API key and make your first Robinhood Chain API request with cURL, JavaScript or Python in under five minutes. Read](https://docs.crius.sh/quickstart/) --- # Search Robinhood Chain tokens, pools and wallets by name or address > Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included. Source: https://docs.crius.sh/guides/search-tokens/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/search?q=`. Text is matched as a prefix of token names and symbols (case-insensitive, best markets first); a 0x address or a 32-byte v4 pool id is matched exactly and comes back as a `token`, `pool`, `hook` or `wallet`. `type` narrows the kind, `limit` goes up to 20. Anonymous plan. [GET `/search`](https://docs.crius.sh/reference/discovery/search/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) Search turns what a user types into a Robinhood Chain address. Type part of a token’s name or symbol and you get the matching tokens with their price, liquidity, launchpad, logo and links. Paste an address or a Uniswap v4 pool id and you get exactly what it is: a token, a pool, a hook or a wallet. It is built for search boxes: one call per keystroke, anonymous, 1 credit with a key. ## Search by name or symbol Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### Searching 'pons': the real token and two copies What is the contract address of the Pons token on Robinhood Chain? GET/v1/robinhood/search?q=pons&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=pons&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=pons&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=pons&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 73 lines (arrays trimmed)** ```json { "data": [ { "address": "0x39dbed3a2bd333467115de45665cc57f813c4571", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/ponsdotfamily", "website": "https://ponsfamily.com/launchpad" }, "liquidity_usd": 5251912, "logo": "https://api.crius.sh/v1/robinhood/logo/0x39dbed3a2bd333467115de45665cc57f813c4571.png?size=128", "name": "Pons", "price_usd": 0.28844, "symbol": "PONS", "type": "token" }, { "address": "0x6c1ae0de06c8c6afb83d29251dfae197c73db9f9", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 10100, "logo": null, "name": "Pons", "price_usd": 0.274026, "symbol": "PONS", "type": "token" }, { "address": "0x2b83910e725ef6822cf1be3fba2fb07bdb7afec8", "label": null, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5041.51, "logo": null, "name": "Pons", "price_usd": 0.00000349204, "symbol": "PONS", "type": "token" } ], "meta": { "block": 100410581, "block_age_ms": 629, "block_ts": 1793225464000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 104, "safe_block": 100405028 } } ``` What this tells you - All three results have `name: "Pons"` and `symbol: "PONS"`. Only the first (`0x39dbed3a2bd333467115de45665cc57f813c4571`) has a logo and links to `https://ponsfamily.com/launchpad` and `https://x.com/ponsdotfamily`, and it has `liquidity_usd: 5251912`. - The second (`0x6c1ae0de06c8c6afb83d29251dfae197c73db9f9`) trades at $0.274026, close to the real token’s $0.28844, on $10,100 of liquidity and with no links. A lookalike priced like the original is the one users get tricked by. - The third (`0x2b83910e725ef6822cf1be3fba2fb07bdb7afec8`) is priced at $0.0000035: an unrelated token reusing the name. - `launchpad: null` on all three: Pons the token wasn’t launched from Pons the launchpad. [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Searching%20'pons'%3A%20the%20real%20token%20and%20two%20copies&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fsearch-tokens%2F%23by-name%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3Dpons%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Results are ranked so the one users mean usually comes first: 1. An exact symbol match before a prefix match. 2. Tokens that have traded before tokens that never have. 3. Higher `liquidity_usd` first. If fewer tokens match than `limit`, the main pools of the best three matches follow as `type: "pool"` results. ## Look up an address or pool id Paste a 0x string and search stops guessing: it matches the exact address or pool id. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### A Uniswap v4 pool id: CHARGE/ETH Which pool is 0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913? GET/v1/robinhood/search?q=0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 20 lines (arrays trimmed)** ```json { "data": [ { "dex": "uniswap_v4", "liquidity_usd": 5604.59, "pair": "CHARGE/ETH", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "type": "pool" } ], "meta": { "block": 100410598, "block_age_ms": 1199, "block_ts": 1793225465000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 20, "safe_block": 100405028 } } ``` What this tells you - `type: "pool"`, `dex: "uniswap_v4"`, `pair: "CHARGE/ETH"`: this is the pool Charge AI graduated into from its Pons curve. - `liquidity_usd: 5604.59` is the value of the liquidity behind CHARGE’s price. For every pool of a token, use [`/token/{address}/pools`](https://docs.crius.sh/guides/get-token-pools-and-liquidity/). [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20Uniswap%20v4%20pool%20id%3A%20CHARGE%2FETH&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fsearch-tokens%2F%23by-pool-id%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3D0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### A hook address: the Pons v4 hook What is the contract 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044? GET/v1/robinhood/search?q=0xe5e702641ea86f4ae6cc3cdaed2b886f976be044 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=0xe5e702641ea86f4ae6cc3cdaed2b886f976be044" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 19 lines (arrays trimmed)** ```json { "data": [ { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "PonsV2MemeHook", "pools": 10480, "type": "hook" } ], "meta": { "block": 100410614, "block_age_ms": 779, "block_ts": 1793225467000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 18, "safe_block": 100405028 } } ``` What this tells you - `type: "hook"`, `name: "PonsV2MemeHook"`: the Uniswap v4 hook every graduated Pons token trades through. - `pools: 10480`: one pool per graduated Pons token. For the hook’s risk level and code, see [Check a Uniswap v4 hook’s risk](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20hook%20address%3A%20the%20Pons%20v4%20hook&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fsearch-tokens%2F%23by-hook%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3D0xe5e702641ea86f4ae6cc3cdaed2b886f976be044%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What search returns | `type` | Matched by | Fields | | --- | --- | --- | | `token` | Name or symbol prefix, or the exact token address | `address`, `name`, `symbol`, `price_usd`, `liquidity_usd`, `launchpad`, `launchpad_name`, `logo`, `links`, `label` | | `pool` | Exact v4 pool id or v2/v3 pool address; also the best matches' main pools | `pool`, `dex`, `pair`, `liquidity_usd` | | `hook` | Exact address of a Uniswap v4 hook | `address`, `name`, `pools` | | `wallet` | Any other exact address | `address`, `label` | Parameters: `q` (required), `type` (`token`, `pool`, `wallet` or `hook`) to return one kind only, and `limit` (default 10, at most 20). ## Use it in your app 1. **Call search on each keystroke, debounced.** 150–250 ms after the user stops typing is enough; the anonymous plan allows 2 requests per second per IP, so a busy site should proxy through its own key. 2. **Show the evidence next to each name.** Logo, `liquidity_usd`, `launchpad_name` and the website from `links` are what tell the real token from a copy. 3. **Route by `type`.** Tokens go to a token page, pools to a pool page, wallets to a wallet page. A pasted address never needs a second lookup to know what it is. 4. **Load the full record once the user picks.** Search results are summaries; the [token profile](https://docs.crius.sh/guides/get-token-data/) has supply, holders, launch and security. ```js // Search box backend: debounce, call search, label each result. let timer; export function onInput(text, render) { clearTimeout(timer); if (!text.trim()) return render([]); timer = setTimeout(async () => { const url = `https://api.crius.sh/v1/robinhood/search?q=${encodeURIComponent(text.trim())}&limit=8`; const { data } = await (await fetch(url)).json(); render( data.map((r) => r.type === "token" ? `${r.symbol} · ${r.name} · $${Math.round(r.liquidity_usd)} liq · ${r.launchpad_name ?? "direct"} · ${r.address}` : r.type === "pool" ? `${r.pair} pool on ${r.dex} · ${r.pool}` : `${r.type} ${r.name ?? r.label ?? ""} ${r.address}`, ), ); }, 200); } ``` Never resolve a symbol to an address automatically A bot that buys “the token called PONS” will sooner or later buy a copy. Resolve symbols with search, let the user (or your allowlist) pick the address, and store the address from then on. ## Frequently asked questions **How do I find a Robinhood Chain token's contract address by name?** Call `GET https://api.crius.sh/v1/robinhood/search?q=` and take the `address` of the result you want. Results with an exact symbol match come first, then tokens that have traded, ranked by liquidity. Check the `links` and `liquidity_usd` before you trust a name: copies of popular tokens are common. **Why are there several tokens with the same symbol?** Anyone can deploy a token with any name and symbol. A search for `pons` returns the real Pons token with $5.25 million of liquidity and two other tokens named Pons with no links, one priced close to the real one. The address is the only identity a token has. **Can I search by pool id or hook address?** Yes. Paste a Uniswap v4 pool id (a 32-byte hex string) to get the pool with its pair, DEX and liquidity, or a hook address to get the hook's name and pool count. A v2 or v3 pool address works the same way. **What does search return for a wallet address?** An address that isn't a token, pool or hook comes back as `type: "wallet"` with its `label` when Crius knows the address, otherwise `label: null`. For the wallet's holdings and trades, use the [wallet endpoints](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/). **Is search case-sensitive?** No. `charge`, `CHARGE` and `Charge` return the same tokens. Matching is on the start of the name or symbol, so `char` finds Charge AI but `ai` doesn't. ## Related [Guide **Get token data** Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Read](https://docs.crius.sh/guides/get-token-data/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Telegram scanner bot** Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples. Read](https://docs.crius.sh/guides/build-a-telegram-token-scanner/) [API reference **Search API** Prefix search over token names and symbols, and exact match on token, pool, wallet and hook addresses and v4 pool ids. Read](https://docs.crius.sh/reference/discovery/search/) --- # Stream live candles for a Robinhood Chain token chart > Keep a Robinhood Chain candlestick chart live: load candles over REST, update the last bar from the Crius WebSocket, with a runnable Node.js relay. Source: https://docs.crius.sh/guides/stream-live-candles/ · Updated 2026-10-28 Short answer Load history with `GET /v1/robinhood/token/{address}/candles?interval=1m`, then subscribe to `candles:` plus the token address and interval (for example `:1m`) on `wss://api.crius.sh/v1/robinhood/stream`. Each trade pushes the current candle (`t`, `o`, `h`, `l`, `c`, `v`, `n`): replace your last bar when `t` matches and append a new one when it's later. Intervals `1s` to `1d`; Free plan. [GET `/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) A live chart needs two things: the history, and the candle that is still forming. Crius gives you the history from the REST [candles endpoint](https://docs.crius.sh/reference/trades/ohlcv-candles/) and the forming candle from the WebSocket channel `candles::`, which pushes the current bucket’s open, high, low, close, USD volume and trade count after every trade. Your chart replaces its last bar when the bucket start `t` is the same and appends a bar when it moves on. The stream needs a Free key with the `stream` scope, so it runs on your server and relays candles to the page. ## Load the history first Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/ohlcv-candles/) ### TSLA one-minute candles, with a gap What do the last minutes of Tesla's tokenized stock (0x322f0929c4625ed5bad873c95208d54e1c003b2d) look like on a 1-minute chart? GET/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/candles?interval=1m&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/candles?interval=1m&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/candles?interval=1m&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/candles?interval=1m&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 59 lines (arrays trimmed)** ```json { "data": { "bv": [ 26.708, 0 ], "c": [ 402.245, 402.686 ], "currency": "usd", "h": [ 402.245, 402.732 ], "interval": "1m", "l": [ 402.089, 402.245 ], "mc": [ 4632116, 4637185 ], "n": [ 2, 2 ], "o": [ 402.089, 402.245 ], "t": [ 1793225280000, 1793225400000 ], "v": [ 26.708, 1185.5 ] }, "meta": { "block": 100410168, "block_age_ms": 986, "block_ts": 1793225422000, "chain": "robinhood", "finalized_block": 100401329, "from_ts": 1793225280000, "lag_ms": 14, "note": "default (usd) = the token's real markets merged plus its launch curve; ?pool=main its main market only (the default with currency=quote), ?pool= one pool, ?pool=all every pool. Candles open at the previous close (?continuous=false for first-trade opens); buckets without trades are omitted unless ?fill=true", "pools": [ "0xb2a6d67bf3fc511d11cac788a531655f5a7b60cd31c8ff386f0476121741e751", "0xa953ca88ff430e9487c60ca34d757414f4efda07", "0x8517f8071ae5b831b738052f12125e8e3d6c158b78728aa44ce3b25e5104d32e" ], "safe_block": 100405028, "to_ts": 1793225422000 } } ``` What this tells you - Columnar arrays: candle `i` is `t[i]`, `o[i]`, `h[i]`, `l[i]`, `c[i]`, `v[i]`. Times are unix milliseconds; Lightweight Charts wants seconds (`t / 1000`). - `limit=3` returned two candles: 1793225280000 (22:08 UTC) and 1793225400000 (22:10 UTC). Nobody traded at 22:09, so that bucket is missing. The stream won’t send it either; pass `fill=true` to REST if you want an evenly spaced axis. - The second candle opens at the first one’s close (402.245): candles open at the previous close, and the stream’s new candles do the same. - `bv` is 0 on the second candle: all 1,185.5 USD of its volume (`v`) was sells. Stream candles carry `v` but not `bv` or `mc` (market cap at close, here 4,637,185). - `meta.pools` lists the three markets merged into these USD candles; thin side pools are left out so a dust trade can’t draw a wick. [OHLCV candles reference](https://docs.crius.sh/reference/trades/ohlcv-candles/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20TSLA%20one-minute%20candles%2C%20with%20a%20gap&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fstream-live-candles%2F%23history%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x322f0929c4625ed5bad873c95208d54e1c003b2d%2Fcandles%3Finterval%3D1m%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What the candle channel sends Subscribe with `{"op": "subscribe", "channels": ["candles:0x322f0929c4625ed5bad873c95208d54e1c003b2d:1m"]}`. Every trade of the token then pushes the candle it fell into: | Field | Meaning | | --- | --- | | `t` | Bucket start, unix ms. Same `t` as your last bar: replace it. Later `t`: a new bar | | `o` | Open: the previous candle's close | | `h`, `l`, `c` | High, low and close so far, in USD | | `v` | USD volume so far in this bucket | | `n` | Number of trades so far in this bucket | A small trade far from the token’s current price (an off-market print in a thin pool, an arbitrage leg) counts in `v` and `n` but doesn’t move `h`, `l` or `c`, the same rule the REST candles use. ## A chart relay in Node.js The relay holds your key, subscribes to one candle channel, and pushes each update to every open page over Server-Sent Events. Pages load history through the relay too, with a short cache so a busy page doesn’t spend credits on every visit. ```js // candles-relay.mjs: CRIUS_API_KEY=... node candles-relay.mjs, then open http://localhost:8080 import { createServer } from "node:http"; import { readFileSync } from "node:fs"; const KEY = process.env.CRIUS_API_KEY; const API = "https://api.crius.sh/v1/robinhood"; const TOKEN = "0x322f0929c4625ed5bad873c95208d54e1c003b2d"; // TSLA, Tesla tokenized stock const INTERVAL = "1m"; const CHANNEL = `candles:${TOKEN}:${INTERVAL}`; const pages = new Set(); // open SSE responses let last = null; // the forming candle let history = { at: 0, body: "" }; // cached REST candles let connectedBefore = false; const send = (res, event, data) => res.write(`${event ? `event: ${event}\n` : ""}data: ${JSON.stringify(data)}\n\n`); function connect(backoff = 1000) { const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); }; ws.onopen = () => { backoff = 1000; touch(); ws.send(JSON.stringify({ op: "subscribe", channels: [CHANNEL] })); if (connectedBefore) { history.at = 0; // trades may have been missed: reload history for (const res of pages) send(res, "reload", {}); } connectedBefore = true; }; ws.onmessage = (e) => { touch(); const m = JSON.parse(e.data); if (m.ch === CHANNEL && !m.data.removed) { last = m.data; for (const res of pages) send(res, null, m.data); } else if (m.ch === "reorg") { history.at = 0; for (const res of pages) send(res, "reload", {}); } else if (m.ch === "error") { console.error(m.data); } }; ws.onclose = () => { clearTimeout(idle); setTimeout(() => connect(Math.min(backoff * 2, 30_000)), backoff + Math.random() * 500); }; ws.onerror = () => ws.close(); } createServer(async (req, res) => { if (req.url === "/candles") { if (Date.now() - history.at > 15_000) { const r = await fetch(`${API}/token/${TOKEN}/candles?interval=${INTERVAL}&limit=300`, { headers: { "x-api-key": KEY } }); history = { at: Date.now(), body: await r.text() }; } res.writeHead(200, { "content-type": "application/json" }); return res.end(history.body); } if (req.url === "/live") { res.writeHead(200, { "content-type": "text/event-stream", "cache-control": "no-cache", connection: "keep-alive" }); pages.add(res); if (last) send(res, null, last); req.on("close", () => pages.delete(res)); return; } res.writeHead(200, { "content-type": "text/html; charset=utf-8" }); res.end(readFileSync(new URL("./index.html", import.meta.url))); }).listen(8080); connect(); ``` The page next to it draws the chart with [TradingView Lightweight Charts](https://github.com/tradingview/lightweight-charts), as in the [chart example](https://docs.crius.sh/examples/chart/), and applies each streamed candle with `update`, which replaces the last bar or appends one: ```html TSLA 1m live
``` 1. **History from REST, the forming bar from the stream.** Call `/candles` once (2 credits), draw it, then apply stream candles. Don’t rebuild history from the stream: it doesn’t replay old buckets. 2. **Reload after a gap.** After a reconnect or a `reorg` message, reload the last candles from REST. Reorged candle messages come back with `removed: true`; skip them and let the reload fix the bar. 3. **One channel per interval.** If users can switch between 1m and 1h, subscribe to the interval being shown and unsubscribe from the old one, so you stay within your plan’s subscriptions (10 on Free). 4. **Format small prices.** Meme tokens trade at fractions of a cent. Set the series’ `priceFormat` precision from the last close so the axis stays readable. Want every trade, not just the candle? Subscribe to `trades:` on the same connection to show a live trade list under the chart. The [trades stream guide](https://docs.crius.sh/guides/stream-trades-websocket/) has a client that resumes and backfills. ## Frequently asked questions **Which candle intervals can I stream?** `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h` and `1d`, the same as the REST candles. Each interval of each token is its own channel (`candles::1m`), so it counts as one subscription. **Why don't I get a candle message every minute?** Candle messages are pushed by trades. A minute without trades sends nothing, and REST omits that bucket too unless you pass `fill=true`. There is also no snapshot on subscribe: draw the current candle from REST and wait for the next trade. **Why does a streamed candle differ slightly from the REST candle later?** The live candle is built as trades arrive, with the same rules as REST for opens and off-market prints. REST also applies filters that need trades after the one being judged, such as isolated spikes, and its default USD candles leave thin side pools out, while the live candle counts trades from every pool. Reload the last few candles from REST after a reconnect, or when a bucket closes if you need exact history. **Does the streamed candle include buy volume and market cap?** No. A stream candle has `t`, `o`, `h`, `l`, `c`, `v` (USD volume) and `n` (trades). Buy volume (`bv`) and market cap at close (`mc`) are in the REST candles. ## Related [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) [Docs **Chart example** Draw a live candlestick and volume chart for any Robinhood Chain token with the Crius candles endpoint and TradingView Lightweight Charts, with full source code. Read](https://docs.crius.sh/examples/chart/) [API reference **OHLCV candles API** Candles in columnar form (one array per field, aligned by index), which is compact and maps straight onto charting libraries. Read](https://docs.crius.sh/reference/trades/ohlcv-candles/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) --- # Get new Robinhood Chain tokens and graduations in real time > Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token. Source: https://docs.crius.sh/guides/stream-new-tokens/ · Updated 2026-10-28 Short answer Subscribe to `launches:all` (or `launches:pons`, `launches:flap`, …) and `graduations:all` on `wss://api.crius.sh/v1/robinhood/stream`. A launch message has the token `address`, `launchpad`, `creator`, `curve`, `quote` and `tx`; a graduation has `token`, `launchpad` and the new `pool`. Add `pools:new` for tokens that launch outside a launchpad. Free plan with a `stream` key. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) The Crius WebSocket stream announces every new Robinhood Chain token as its launch transaction is decoded: one `launches:all` subscription covers Pons, Flap.sh, Bankr, Long.xyz, Flywheel and King of the Markets, and `graduations:all` tells you when a token leaves its bonding curve for a Uniswap pool. Tokens deployed without a launchpad appear on `pools:new` when their first pool is created. The stream needs a Free key with the `stream` scope; the REST [token lists](https://docs.crius.sh/reference/discovery/token-lists/) give you the same tokens when you start up or reconnect. ## The channels and their messages | Channel | Pushes | `data` fields | | --- | --- | --- | | `launches:all`, `launches:` | A new launchpad token | `address`, `launchpad`, `creator`, `curve`, `quote` (the quote token’s symbol, e.g. `ETH`), `tx` | | `graduations:all`, `graduations:` | A token completing its curve | `token`, `launchpad`, `pool` (the pool it graduated into), `position_id` | | `pools:new` | Every new Uniswap v2, v3 or v4 pool | `pool`, `dex`, `token0`, `token1`, `fee`, `tick_spacing`, `hook` (`null`, or `address` and `permissions`) | | `dev:
` | New tokens launched by one creator | Same as a launch | Each message has the usual envelope (`ch`, `seq`, `block`, `ts`, `data`), described in the [stream reference](https://docs.crius.sh/reference/stream/). `launches:all` counts as one subscription, so the Free plan’s 10 leave room for graduations, new pools and a few creators. ## Catch up from REST first Launches you missed while your client was down aren’t replayed after 60 seconds. On startup, read the newest launches from the token list, then let the stream take over. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The three newest Pons launches Which tokens were launched on Pons in the last few minutes, and how are they doing? GET/v1/robinhood/tokens?list=new&launchpad=pons&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x5132c73e282f15e156d43fe1757115c4bda208be", "buy_volume_usd": { "1h": 1425.88, "24h": 1425.88, "5m": 1425.88, "6h": 1425.88 }, "buyers": { "1h": 8, "24h": 8, "5m": 8, "6h": 8 }, "buys": { "1h": 29, "24h": 29, "5m": 29, "6h": 29 }, "change_pct": { "1h": 6.40071, "24h": 6.40071, "5m": 6.40071, "6h": 6.40071 }, "created_block": 100409067, "created_ts": 1793225312360, "decimals": 18, "fdv_usd": 17454, "holders": 7, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/1vampnation1/status/2115566407018565807", "website": "https://trustinnom.xyz/" }, "liquidity_usd": 2392, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5132c73e282f15e156d43fe1757115c4bda208be.png?size=128", "market_cap_usd": 17454, "name": "paycat", "price_eth": 0.00000000740993, "price_usd": 0.000017454, "progress_pct": 3.19647, "quote": "PYPL", "sell_volume_usd": { "1h": 285.934, "24h": 285.934, "5m": 285.934, "6h": 285.934 }, "sellers": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "sells": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "status": "bonding", "symbol": "PAYCAT", "traders": { "1h": 8, "24h": 8, "5m": 8, "6h": 8 }, "txns": { "1h": 31, "24h": 31, "5m": 31, "6h": 31 }, "volume_usd": { "1h": 1711.82, "24h": 1711.82, "5m": 1711.82, "6h": 1711.82 } }, { "address": "0x3736c3daeb6bee85b8086354424e31e23d39a416", "buy_volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 }, "buyers": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "buys": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "change_pct": { "1h": 349.859, "24h": 349.859, "5m": 349.859, "6h": 349.859 }, "created_block": 100408733, "created_ts": 1793225280300, "decimals": 18, "fdv_usd": 9653.95, "holders": 18, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 4794.48, "logo": "https://api.crius.sh/v1/robinhood/logo/0x3736c3daeb6bee85b8086354424e31e23d39a416.png?size=128", "market_cap_usd": 9653.95, "name": "Ronald", "price_eth": 0.00000000409848, "price_usd": 0.00000965395, "progress_pct": 47.1712, "quote": "MCD", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "RONALD", "traders": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "txns": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 } }, { "address": "0x82c43abb2ab9633be5a98b76500acbd700344cec", "buy_volume_usd": { "1h": 0.00000040181, "24h": 0.00000040181, "5m": 0.00000040181, "6h": 0.00000040181 }, "buyers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "buys": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "change_pct": { "1h": -8.2549, "24h": -8.2549, "5m": -8.2549, "6h": -8.2549 }, "created_block": 100408402, "created_ts": 1793225246200, "decimals": 18, "fdv_usd": 14966.5, "holders": 5, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/MiamiMinty/status/2115551765949218980?a=JCtZDJI2ZOGh-1E1Kfw&s=20", "website": "https://trustinnom.xyz/" }, "liquidity_usd": 0.000000264611, "logo": "https://api.crius.sh/v1/robinhood/logo/0x82c43abb2ab9633be5a98b76500acbd700344cec.png?size=128", "market_cap_usd": 14966.5, "name": "paycat", "price_eth": 0.00000000635386, "price_usd": 0.0000149665, "progress_pct": 0.000000000353605, "quote": "PYPL", "sell_volume_usd": { "1h": 0.000000269439, "24h": 0.000000269439, "5m": 0.000000269439, "6h": 0.000000269439 }, "sellers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "sells": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "status": "bonding", "symbol": "PAYCAT", "traders": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "txns": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "volume_usd": { "1h": 0.000000671249, "24h": 0.000000671249, "5m": 0.000000671249, "6h": 0.000000671249 } } ], "meta": { "block": 100409873, "block_age_ms": 333, "block_ts": 1793225393000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 1, "list": "new", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - All three are `status: "bonding"`: still on Pons’s curve, with `progress_pct` showing how far toward graduation they are. Ronald (`0x3736c3daeb6bee85b8086354424e31e23d39a416`) is at about 47% after 16 buys and no sells. - Pons curves are quoted in tokenized stocks: `quote` is `PYPL` for both paycat tokens and `MCD` for Ronald. - Two tokens are named paycat, launched 66 seconds apart (`created_ts` 1793225246200 and 1793225312360), and both link to the same website. Names are not unique on Robinhood Chain: always key your data by `address`. - `created_block` and `created_ts` give you the cut-off for the stream: anything launched after the newest `created_ts` will arrive on `launches:pons`. For a window, use `created_after_ts`. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20three%20newest%20Pons%20launches&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fstream-new-tokens%2F%23newest-pons%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26launchpad%3Dpons%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Check each token before you show it A launch message tells you a token exists. Before you list or alert on it, call [security](https://docs.crius.sh/reference/security/security-checks/) (anonymous plan, 1 credit with a key). For a token this young, read the launch section as well as the score. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A Pons token under a minute after launch Tendies (0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302) launched on Pons seconds ago. What can be checked already? GET/v1/robinhood/token/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 104 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": null, "sniper_supply_pct": 16.1626, "sniper_top_wallet_pct": 3.00308, "sniper_wallets": 6, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "no_liquidity", "summary": { "burned_pct": null, "locked_pct": null, "next_unlock_ts": null, "protocol_fee_pct": null, "unlocked_in_wallets_pct": null, "weighting": "by pool liquidity_usd" } }, "primary_dex": "pons_curve", "risk": "low", "score": 95, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": 0, "others_sell_pct": 0 }, "last_sample_ts": 1793225661000, "max_sell_pct_seen": 0, "samples": { "buys": 89, "sells": 16 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100412111, "pct": 0, "side": "buy" }, { "from_block": 100412321, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302" }, "meta": { "block": 100412355, "block_age_ms": 496, "block_ts": 1793225662000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 22, "safe_block": 100405028, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 95`, `risk: "low"`: the only flag is `unverified`. A score this early mostly says no trap has been found yet. - `primary_dex: "pons_curve"` and `liquidity.status: "no_liquidity"`: the token trades on its bonding curve, so there’s no LP to lock until it graduates. - `launch.sniper_wallets: 6` bought 16.16% of the supply (`sniper_supply_pct`) in the first 10 blocks (`sniper_window_blocks`); the largest took about 3% (`sniper_top_wallet_pct`). This is the number to watch on a new launch. - `tax.realized.samples` already counts 89 buys and 16 sells with 0% tax both ways (`tax.source: "realized"`). `meta.simulation` says no simulation ran yet: `"no V2 WETH pair: realized tax only"`. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20Pons%20token%20under%20a%20minute%20after%20launch&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fstream-new-tokens%2F%23fresh-token%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## A launch watcher in Node.js This client follows every launch and graduation, waits 60 seconds after a launch so the first trades have happened, checks the token, and prints only the ones that pass. It reconnects, resumes and skips reorged launches. ```js // launches.mjs: node launches.mjs (Node.js 22+, CRIUS_API_KEY with the stream scope) const KEY = process.env.CRIUS_API_KEY; const API = "https://api.crius.sh/v1/robinhood"; const CHANNELS = ["launches:all", "graduations:all"]; const CHECK_AFTER_MS = 60_000; // give the first trades time to happen const MAX_SNIPED_PCT = 30; const lastSeq = {}; const pending = new Map(); // token address -> timer, so a reorged launch can be cancelled let backoff = 1000; async function get(path) { const res = await fetch(`${API}${path}`, { headers: { "x-api-key": KEY } }); return (await res.json()).data; } async function check(launch) { pending.delete(launch.address); const s = await get(`/token/${launch.address}/security`); if (!s || s.risk === "critical" || s.risk === "high") return console.log(`skip ${launch.address}: ${s?.risk}`); if ((s.launch?.sniper_supply_pct ?? 0) > MAX_SNIPED_PCT) return console.log(`skip ${launch.address}: sniped`); console.log(`NEW ${launch.launchpad} ${launch.address} by ${launch.creator} (quote ${launch.quote}), score ${s.score}`); } function onMessage(m) { if (m.ch.startsWith("launches:")) { const l = m.data; if (l.removed) { clearTimeout(pending.get(l.address)); // the launch block was reorged out pending.delete(l.address); } else if (!pending.has(l.address)) { pending.set(l.address, setTimeout(() => check(l).catch(console.error), CHECK_AFTER_MS)); } } else if (m.ch.startsWith("graduations:") && !m.data.removed) { console.log(`GRADUATED ${m.data.launchpad} ${m.data.token} into pool ${m.data.pool}`); } else if (m.ch === "error") { console.error(m.data); } } function connect() { const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); }; ws.onopen = () => { backoff = 1000; touch(); ws.send(JSON.stringify({ op: "subscribe", channels: CHANNELS })); if (Object.keys(lastSeq).length) ws.send(JSON.stringify({ op: "resume", seqs: lastSeq })); }; ws.onmessage = (e) => { touch(); const m = JSON.parse(e.data); if (m.seq) lastSeq[m.ch] = m.seq; onMessage(m); }; ws.onclose = () => { clearTimeout(idle); setTimeout(connect, backoff + Math.random() * 500); backoff = Math.min(backoff * 2, 30_000); }; ws.onerror = () => ws.close(); } connect(); ``` 1. **Start from REST.** Call `/tokens?list=new` (with `launchpad=` if you follow one) and remember the newest `created_ts`. After an outage longer than 60 seconds, call it again with `created_after_ts` set to that time. 2. **Delay the check.** A security call right after the launch sees few or no trades. Waiting a minute costs nothing and gives realized tax and sniper numbers to judge. 3. **Re-check at graduation.** On a `graduations:` message the token moves to a Uniswap pool (for Pons, a v4 pool with its hook). Call security again: liquidity and hook risk only exist from this point, and [launch lifecycle](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) gives the curve’s final state. 4. **Add `pools:new` for everything else.** Tokens deployed directly, without a launchpad, first appear when someone creates a pool for them. Filter `pools:new` on `token0` / `token1` you haven’t seen, and check `hook.permissions` on v4 pools. Credits The stream costs 1 credit per connection, a security check 1 credit and a token list call 1 credit. In the 24 hours of the [chain stats](https://docs.crius.sh/reference/chain/chain-stats/) sample, 3,527 new tokens came from known launchpads: checking each once is about 3,500 credits a day, roughly a tenth of the Free plan’s 1,000,000 monthly credits. Launches per launchpad are on [`/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/). ## Frequently asked questions **How fast do new Robinhood Chain tokens show up on the stream?** A `launches:` message is pushed as soon as the launch block is decoded, typically well under a second after the block. The REST list `/tokens?list=new` has the same tokens, which is how you catch up after downtime. **Which launchpads have launch and graduation channels?** Every launchpad Crius attributes, by its id: `pons`, `flap`, `bankr`, `long`, `flywheel` and `standard_reserve` (King of the Markets). `/v1/robinhood/launchpads` lists them. `launches:all` and `graduations:all` cover all of them in one subscription each. **How do I see tokens that weren't launched on a launchpad?** They have no launch event. Subscribe to `pools:new`: every new Uniswap v2, v3 or v4 pool arrives with `token0`, `token1`, `fee`, `tick_spacing` and, for v4, the `hook` address with its decoded `permissions`. **Can I follow one developer's new tokens?** Yes: `dev:
` pushes every token that creator launches, in the same shape as a launch message. Pair it with the [developer profile](https://docs.crius.sh/reference/wallets/developer-profile/) to see how their earlier tokens did. **Is a brand-new token safe to buy if its security score is high?** Not on its own. In its first minutes a token has few trades and nothing has gone wrong yet, so the score is often high. Check it again after the first wave of trades and look at `launch.sniper_supply_pct`, which already shows who bought the first blocks. ## Related [Guide **Find new tokens** List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Read](https://docs.crius.sh/guides/find-new-tokens/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) --- # Stream Robinhood Chain trades over WebSocket > Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Source: https://docs.crius.sh/guides/stream-trades-websocket/ · Updated 2026-10-28 Short answer Open `wss://api.crius.sh/v1/robinhood/stream` with a Free (or higher) key that has the `stream` scope and send a `subscribe` op for `trades:` plus the token address. Each trade arrives, typically well under a second after its block, with `type`, `trader`, `amount_base`, `price_usd` and `value_usd`. `trades:pool:` follows one pool and `wallet:` one wallet; a connection costs 1 credit. [GET `/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) The Crius WebSocket stream pushes every decoded Robinhood Chain trade as soon as its block is indexed, typically well under a second after the block was produced. You open one connection, subscribe to `trades:`, `trades:pool:` or `wallet:
`, and each trade arrives as a JSON message with its side, amounts, USD price and value and the wallet that really traded. It needs a Free key with the `stream` scope, and the REST [trade tape](https://docs.crius.sh/reference/trades/trade-tape/) fills any gap the stream can’t replay. ## Subscribe to a token’s trades Connect, wait for the `hello` greeting (it tells you `max_subscriptions` for your plan), then subscribe. Channel names are lowercase, so lowercase addresses before you subscribe and match on the `ch` field of each message. ```json {"op": "subscribe", "channels": ["trades:0x322f0929c4625ed5bad873c95208d54e1c003b2d"]} ``` The server answers `{"ch": "subscribed", "data": {"channels": [...], "finality": "latest"}}`, and from then on every trade of Tesla’s tokenized stock (TSLA) arrives in the standard envelope: `ch`, `seq`, `block`, `ts` and `data`. The [stream reference](https://docs.crius.sh/reference/stream/) shows a full message. | Channel | What you get | | --- | --- | | `trades:` | Every trade of one token, in any pool | | `trades:pool:` | Every trade in one pool (v2/v3 address or v4 pool id) | | `wallet:
` | The wallet’s trades plus its plain token transfers (`type: "transfer"`) | | `firehose:trades` | Every trade on the chain (Enterprise plan) | ## What a trade message contains | Field | Meaning | | --- | --- | | `id` | `block-tx-log`, the same id the REST trade tape uses: use it to de-duplicate and to undo reorged trades | | `type` | `buy` or `sell`, from the token's side | | `token`, `symbol`, `logo` | The token traded | | `pool`, `dex` | Pool address (v2/v3) or pool id (v4), and `uniswap_v2`, `uniswap_v3`, `uniswap_v4` or a launch curve | | `trader` | The wallet whose balance changed, not the router or bundler that sent the transaction | | `signer` | The address that signed the transaction | | `amount_base`, `amount_quote` | Token and quote amounts in human units | | `price_usd`, `value_usd` | USD price per token and USD value of the trade at that block | | `tax_pct` | Token tax measured on this trade, when there was one | | `removed` | `true` only on a re-sent trade whose block was reorged out | ## Backfill and cross-check with the trade tape The stream only replays the last 60 seconds. For anything older, and to get detail the stream message doesn’t carry, read the REST trade tape: it uses the same `id`, so the two merge cleanly. Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/trades/trade-tape/) ### The last two TSLA trades, for backfilling a stream My stream client was offline. What did Tesla's tokenized stock (0x322f0929c4625ed5bad873c95208d54e1c003b2d) trade while I was gone? GET/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/trades?limit=2 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/trades?limit=2" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/trades?limit=2"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x322f0929c4625ed5bad873c95208d54e1c003b2d/trades?limit=2", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 98 lines (arrays trimmed)** ```json { "data": [ { "amount_base": 0.68873541086638403, "amount_quote": 0.358712450309036398, "block": 100410183, "dex": "uniswap_v4", "eth_usd_at_trade": 2356.79, "executor": "0xe07ba3acee529ff1d4f7290cbae32fa065e18acd", "fees": { "gas": { "gas_price_gwei": 0.021016, "gas_used": 160574, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000337462, "total_eth": 0.00000337462, "usd": 0.00795329 }, "token_tax": { "pct": 0 } }, "finality": "latest", "id": "100410183-9-12", "market_cap_usd_at_trade": 4636638, "pool": "0x3ea70ce0b34473692549f97e630a1d82dc05cea94fa55f81b50f10c8c6d8186f", "price_eth": 0.170843, "price_usd": 402.641, "quote": "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", "quote_symbol": "SPY", "signer": "0xe07ba3acee529ff1d4f7290cbae32fa065e18acd", "signer_label": null, "trader": "0x278d858f05b94576c1e6f73285886876ff6ef8d2", "trader_app": null, "trader_label": null, "ts": 1793225424000, "tx": "0xe45e6dd2072db6c23bbae5aa7719cf43ba81a7f23a0f7d94addf2a4362d819c5", "tx_index": 9, "type": "sell", "value_eth": 0.117665, "value_usd": 277.313, "via": [] }, { "amount_base": 2.131024263465401912, "amount_quote": 1.110019178795529442, "block": 100410039, "dex": "uniswap_v4", "eth_usd_at_trade": 2356.79, "executor": "0xe07ba3acee529ff1d4f7290cbae32fa065e18acd", "fees": { "gas": { "gas_price_gwei": 0.02139, "gas_used": 160578, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000343476, "total_eth": 0.00000343476, "usd": 0.00809503 }, "token_tax": { "pct": 0 } }, "finality": "latest", "id": "100410039-2-2", "market_cap_usd_at_trade": 4637151, "pool": "0x3ea70ce0b34473692549f97e630a1d82dc05cea94fa55f81b50f10c8c6d8186f", "price_eth": 0.170862, "price_usd": 402.686, "quote": "0x117cc2133c37b721f49de2a7a74833232b3b4c0c", "quote_symbol": "SPY", "signer": "0xe07ba3acee529ff1d4f7290cbae32fa065e18acd", "signer_label": null, "trader": "0x278d858f05b94576c1e6f73285886876ff6ef8d2", "trader_app": null, "trader_label": null, "ts": 1793225409000, "tx": "0x70aa3910a6109eb864a3464d828d6ae2c026c3dfe5ca69d5653f4c765a97e569", "tx_index": 2, "type": "sell", "value_eth": 0.36411, "value_usd": 858.133, "via": [] } ], "meta": { "block": 100410278, "block_age_ms": 1180, "block_ts": 1793225433000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 83, "next_cursor": "100410039-2", "safe_block": 100405028 } } ``` What this tells you - Both trades are sells in the same Uniswap v4 pool, quoted in the S&P 500 tokenized stock (`quote_symbol: "SPY"`): tokenized stocks trade against each other, not only against USDG. - `id: "100410183-9-12"` is block 100410183, transaction 9, log 12. A stream message for this trade has the same `id`, so a client that stores ids never counts it twice. - `trader` (`0x278d858f05b94576c1e6f73285886876ff6ef8d2`) differs from `signer` and `executor` (`0xe07ba3acee529ff1d4f7290cbae32fa065e18acd`): another address signed and sent the transaction, and Crius reports the wallet whose balance actually changed. - `value_usd` is 277.313 and 858.133, at `price_usd` around 402.6. `finality: "latest"`: neither block was safe yet when the call was made. - `meta.next_cursor` pages further back; `from_ts` and `to_ts` (unix ms) bound the window, which is how the client below fills a gap. [Trade tape reference](https://docs.crius.sh/reference/trades/trade-tape/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20last%20two%20TSLA%20trades%2C%20for%20backfilling%20a%20stream&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fstream-trades-websocket%2F%23backfill%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x322f0929c4625ed5bad873c95208d54e1c003b2d%2Ftrades%3Flimit%3D2%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## A complete client Both clients follow the same loop: subscribe, remember the last `seq` per channel, resume after a reconnect, backfill from REST when the outage was longer than the replay buffer, and drop trades that come back with `removed: true`. Set `CRIUS_API_KEY` to a key with the `stream` scope. **Node.js** ```js // trades-stream.mjs: node trades-stream.mjs (Node.js 22+, built-in WebSocket) const KEY = process.env.CRIUS_API_KEY; const API = "https://api.crius.sh/v1/robinhood"; const TOKEN = "0x322f0929c4625ed5bad873c95208d54e1c003b2d"; // TSLA, Tesla tokenized stock const CHANNELS = [`trades:${TOKEN}`]; const MIN_USD = 100; // only print trades of $100 or more const lastSeq = {}; // channel -> last seq seen const seen = new Map(); // trade id -> trade (de-duplication and reorg undo) let lastTs = 0; // chain time of the newest trade we hold let lastMsgAt = 0; // wall-clock time of the last message let backoff = 1000; function onTrade(t, source) { if (seen.has(t.id)) return; seen.set(t.id, t); if (seen.size > 50_000) seen.delete(seen.keys().next().value); lastTs = Math.max(lastTs, t.ts); if (t.value_usd >= MIN_USD) { console.log(`${source} ${new Date(t.ts).toISOString()} ${t.type} $${t.value_usd} @ $${t.price_usd} by ${t.trader}`); } } async function backfill() { if (!lastTs) return; const res = await fetch(`${API}/token/${TOKEN}/trades?from_ts=${lastTs}&limit=500`, { headers: { "x-api-key": KEY } }); const { data } = await res.json(); for (const t of (data ?? []).reverse()) onTrade(t, "rest"); // the tape is newest first } function connect() { const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${KEY}`); let idle; const touch = () => { clearTimeout(idle); idle = setTimeout(() => ws.close(), 45_000); // heartbeats arrive every 15 s }; ws.onopen = () => { backoff = 1000; touch(); const offline = lastMsgAt ? Date.now() - lastMsgAt : 0; ws.send(JSON.stringify({ op: "subscribe", channels: CHANNELS })); if (Object.keys(lastSeq).length) ws.send(JSON.stringify({ op: "resume", seqs: lastSeq })); if (offline > 55_000) backfill().catch(console.error); // longer than the 60 s replay buffer }; ws.onmessage = (e) => { touch(); lastMsgAt = Date.now(); const m = JSON.parse(e.data); if (m.seq) lastSeq[m.ch] = m.seq; if (m.ch === "error") { if (m.data.code === "lagged") ws.send(JSON.stringify({ op: "resume", seqs: lastSeq })); else console.error(m.data); return; } if (m.ch === "reorg") return console.warn(`reorg: blocks ${m.data.removed_blocks.join(", ")} replaced`); if (!m.ch.startsWith("trades:")) return; // hello, subscribed, heartbeat, finality, resumed if (m.data.removed) seen.delete(m.data.id); // undo whatever you did for this trade else onTrade(m.data, "live"); }; ws.onclose = () => { clearTimeout(idle); setTimeout(connect, backoff + Math.random() * 500); backoff = Math.min(backoff * 2, 30_000); }; ws.onerror = () => ws.close(); } connect(); ``` **Python** ```python # trades_stream.py: pip install websockets requests; python trades_stream.py import asyncio, json, os, random, time import requests import websockets KEY = os.environ["CRIUS_API_KEY"] API = "https://api.crius.sh/v1/robinhood" TOKEN = "0x322f0929c4625ed5bad873c95208d54e1c003b2d" # TSLA, Tesla tokenized stock CHANNELS = [f"trades:{TOKEN}"] last_seq, seen = {}, {} state = {"last_ts": 0, "last_msg": 0.0} def on_trade(t, source): if t["id"] in seen: return seen[t["id"]] = t state["last_ts"] = max(state["last_ts"], t["ts"]) print(source, t["type"], f"${t['value_usd']}", f"@ ${t['price_usd']}", t["trader"]) def backfill(): if not state["last_ts"]: return r = requests.get(f"{API}/token/{TOKEN}/trades", params={"from_ts": state["last_ts"], "limit": 500}, headers={"x-api-key": KEY}, timeout=10) for t in reversed(r.json().get("data") or []): # the tape is newest first on_trade(t, "rest") async def run(): backoff = 1 while True: try: async with websockets.connect(f"wss://api.crius.sh/v1/robinhood/stream?api_key={KEY}") as ws: backoff = 1 offline = time.time() - state["last_msg"] if state["last_msg"] else 0 await ws.send(json.dumps({"op": "subscribe", "channels": CHANNELS})) if last_seq: await ws.send(json.dumps({"op": "resume", "seqs": last_seq})) if offline > 55: # longer than the 60 s replay buffer await asyncio.to_thread(backfill) while True: m = json.loads(await asyncio.wait_for(ws.recv(), timeout=45)) state["last_msg"] = time.time() if m.get("seq"): last_seq[m["ch"]] = m["seq"] ch, data = m["ch"], m.get("data") or {} if ch == "error": if data.get("code") == "lagged": await ws.send(json.dumps({"op": "resume", "seqs": last_seq})) else: print("error", data) elif ch.startswith("trades:"): if data.get("removed"): seen.pop(data["id"], None) # undo whatever you did for this trade else: on_trade(data, "live") except (OSError, asyncio.TimeoutError, websockets.WebSocketException) as e: print("reconnecting:", e) await asyncio.sleep(backoff + random.random() / 2) backoff = min(backoff * 2, 30) asyncio.run(run()) ``` ## Keep the stream correct 1. **Watch the heartbeat.** A `heartbeat` message arrives every 15 seconds. If nothing arrives for 45 seconds, close the socket and reconnect with backoff, as both clients do. 2. **Resume, then backfill.** After reconnecting, subscribe again and send `resume` with the last `seq` per channel. The server replays up to 60 seconds. If you were away longer, call `/trades?from_ts=` with your newest trade’s `ts`; the `id` check drops anything you already have. 3. **Handle `lagged`.** If your client reads too slowly, the server sends `{"ch": "error", "data": {"code": "lagged", ...}}` with the number of dropped messages. Send `resume` with your last `seq` values to recover them. 4. **Undo reorgs by `id`.** A `reorg` message lists `removed_blocks`; each affected trade is then re-sent with `removed: true` and its replacement follows. Subscribing with `"finality": "safe"` holds trades until their block is safe, at the cost of a short delay; keep the `removed` handling anyway, since reorg re-sends are held and delivered the same way. Keep the key on a server The browser WebSocket API can’t set headers, so a browser client would have to put the key in the URL, where anyone can read it. Run the stream client on your backend and forward trades to your pages, for example over Server-Sent Events, as in the [live candles guide](https://docs.crius.sh/guides/stream-live-candles/). ## Frequently asked questions **Which plan do I need for the trades WebSocket?** The Free plan or higher, with a key that has the `stream` scope (keys get it by default). Free allows 1 connection with 10 subscriptions, Starter 3 connections with 100, Pro 10 with 1,000. Each connection costs 1 credit. Every trade on the chain (`firehose:trades`) is Enterprise only. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). **Can I stream all Robinhood Chain trades, not just one token?** `firehose:trades` carries every trade on the chain and needs the Enterprise plan. On other plans, subscribe to the tokens, pools (`trades:pool:`) or wallets (`wallet:
`) you care about, up to your plan's subscription limit. **What happens to my stream if I disconnect?** The server keeps 60 seconds of messages. Keep the last `seq` of each channel and send `{"op": "resume", "seqs": {...}}` after you subscribe again; you get what you missed, then `{"ch": "resumed"}`. After a longer outage, fill the gap from the REST trade tape with `from_ts`. **Are trades on the stream final?** They are pushed at `latest`, as soon as the block is decoded. If a block is replaced you get a `reorg` message, then each affected trade again with `"removed": true`. Subscribe with `"finality": "safe"` to receive trades only once their block is safe. **Is the stream message the same as the REST trade?** It carries the core fields with the same names and the same `id` (`block-tx-log`), so you can merge both. The REST trade tape adds detail the stream leaves out, such as `fees`, `executor`, `quote_symbol`, `via` and `finality`. ## Related [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) [Docs **Real-time stream example** A complete reconnecting WebSocket client for the Crius stream in Node.js - subscribe to new launches, trades and prices on Robinhood Chain, resume after disconnects and handle reorgs. Read](https://docs.crius.sh/examples/stream/) [Guide **Token trades** Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-trades/) [Guide **Stream live candles** Keep a Robinhood Chain candlestick chart live: load candles over REST, update the last bar from the Crius WebSocket, with a runnable Node.js relay. Read](https://docs.crius.sh/guides/stream-live-candles/) [Guide **Price alerts** Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Read](https://docs.crius.sh/guides/build-price-alerts/) [Concept **Finality & reorgs** Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Read](https://docs.crius.sh/concepts/finality/) --- # Get a Robinhood Chain token security score > Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Source: https://docs.crius.sh/guides/token-security-score/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/security`. It returns a `score` from 0 to 100, a `risk` level (`low`, `medium`, `high`, `critical`) and the `flags` that cost points: honeypot (−100), taxes over 10% (−30), insider launch (−50), unlocked liquidity (−20), risky Uniswap v4 hook (−10 to −60) and more. No API key needed. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) [GET `/token/{address}/bundles`](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) The security score is a single number, 0 to 100, that sums up everything Crius checks about a Robinhood Chain token: whether you can sell it, what it really costs to buy and sell, what the owner can still change, whether the liquidity can be pulled, how risky its Uniswap v4 hook is and whether insiders bought the launch. You start at 100 and each problem found subtracts points. What the score can't promise A score of 95 means the checks found no trap, not that the token is safe. The honeypot simulation only runs for tokens with a Uniswap v2 WETH pair, traps that switch on later or target specific wallets can pass, and most losses on new tokens come from insiders selling. Read [Security score: confidence and limitations](https://docs.crius.sh/concepts/security-score-limits/) before you gate trades on it. ## Get the score in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A clean graduated Pons token: score 95 sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a) launched on Pons and graduated to Uniswap v4. Is it safe to trade? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 187 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x34062c5519d27d399b1deb897b6c769683ec7fa3", "liquidity_usd": 106.386, "pct": 0.549474 }, "sniper_supply_pct": 30.1177, "sniper_top_wallet_pct": 24.0035, "sniper_wallets": 6, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 98.9946, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 1.00542, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 95, "tax": { "buy_pct": 2.69, "confidence": "high", "realized": { "buy_pct": 2.69, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793225076000, "max_sell_pct_seen": 65.93, "samples": { "buys": 4144, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100193859, "pct": 0, "side": "buy" }, { "from_block": 100193869, "pct": 0, "side": "sell" }, { "from_block": 100213206, "pct": 3, "side": "buy" }, { "from_block": 100342818, "pct": 0, "side": "buy" }, { "from_block": 100344806, "pct": 3, "side": "buy" } ], "tax_history_total": 7, "tax_mode": "dynamic", "token": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "meta": { "block": 100406831, "block_age_ms": 624, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 32, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 95`, `risk: "low"`: the only flag is `unverified` (−5), because the contract source isn’t published on an explorer. - `honeypot.is_honeypot: false`: thousands of wallets have sold. - `tax.buy_pct` is about 2.7% and `tax.sell_pct` is 0, measured from real trades (`tax.source: "realized"`, `confidence: "high"`). The buy side is Pons’s standard fee. - `contract.ownership: "none"`: nobody can mint, blacklist, pause or change taxes. - `liquidity.summary.locked_pct` is about 97%: the LP sits in Pons’s permanent launch locker. - `hook.risk_level: "low"`: the PonsV2MemeHook has thousands of traded pools with no honeypots. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20clean%20graduated%20Pons%20token%3A%20score%2095&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftoken-security-score%2F%23clean-token%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### An insider launch: score 45 Rebot (0x192b126efea71ca5e7767bc6fc53038d869fbbba) has a clean contract and locked liquidity, but its price fell 97% within hours. What does the score see? GET/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 180 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified", "insider_launch" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [ "insider_launch" ], "lp_top_wallet": { "address": "0x6e8244ba97cbb7d136aafc667e8da302140dbc5b", "liquidity_usd": 5.70259, "pct": 0.0996139 }, "sniper_supply_pct": 60.9726, "sniper_top_wallet_pct": 53.1794, "sniper_wallets": 4, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 99.7392, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.260807, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "high", "score": 45, "tax": { "buy_pct": 2.64, "confidence": "high", "realized": { "buy_pct": 2.64, "by_wallet_class": { "dev_sell_pct": 0, "others_sell_pct": 0 }, "last_sample_ts": 1793224833000, "max_sell_pct_seen": 0.69, "samples": { "buys": 1417, "sells": 1990 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 100238946, "pct": 0, "side": "buy" }, { "from_block": 100238968, "pct": 0, "side": "sell" }, { "from_block": 100239845, "pct": 3, "side": "buy" } ], "tax_history_total": 3, "tax_mode": "dynamic", "token": "0x192b126efea71ca5e7767bc6fc53038d869fbbba" }, "meta": { "block": 100406835, "block_age_ms": 974, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 46, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `score: 45`, `risk: "high"`: `insider_launch` (−50) and `unverified` (−5). - `launch.sniper_supply_pct` is about 61%: four wallets, including the developer’s, bought most of the supply in the first 10 blocks. `launch.sniper_top_wallet_pct` shows one wallet took 53%. - The contract itself is clean and the liquidity is locked, so nothing in the code is a trap. The risk was who held the supply: insiders sold into the buyers who came after. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20An%20insider%20launch%3A%20score%2045&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftoken-security-score%2F%23insider-token%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x192b126efea71ca5e7767bc6fc53038d869fbbba%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## What costs points Every deduction appears in `flags`, so you can show users exactly why a token scored what it did. | Flag | Points | What it means | | --- | --- | --- | | `honeypot` | −100 | The sell simulation failed, or 20+ buys and no non-dev sells. Always `critical`. | | `admin_scam_flag` | −100 | Reviewed and marked as a scam by Crius. | | `selective_honeypot` | −60 | Only the developer has managed to sell. | | `transfer_events_dont_match_balances` | −60 | Transfer events don't add up to balances (spoofed events). | | `hook_critical_risk` | −60 | The pool's v4 hook has no code, is a delegated wallet, or its code family is behind many honeypots. | | `insider_launch` | −50 | Most of the supply was sniped at launch by a few wallets, including insiders. Always `high`. | | `wallet_farm` | −50 | Holders are a farm of wallets created and funded together. | | `high_tax` | −30 | Buy or sell tax above 10%. | | `hook_high_risk` | −30 | The hook can block swaps, or its code family has a record of rugs. | | `uniform_holders` | −30 | Holder balances are suspiciously equal (an airdrop to controlled wallets). | | `lp_single_wallet` | −25 | One wallet holds most of the unlocked liquidity. | | `lp_unlocked` | −20 | The liquidity can be withdrawn at any time. | | `tax_over_5pct` | −15 | Buy or sell tax between 5% and 10%. | | `mintable`, `blacklist`, `upgradeable_proxy` | −15 each | The owner can mint, blacklist wallets, or swap the contract's code. | | `ownership_active`, `pausable`, `tax_changeable`, `tax_mismatch`, `hook_medium_risk` | −10 each | Owner powers that are still live, or a simulated tax that disagrees with what buyers really paid. | | `unverified` | −5 | The source isn't verified on an explorer. | Owner powers (`mintable`, `blacklist`, `pausable`, `tax_changeable`) only count while someone owns the contract: once ownership is renounced they can’t be used. ## How the verdict is decided `risk` is not just the score cut into bands: - **`critical`**: a honeypot, whatever else the token has. - **`high`**: a score under 50, or any `insider_launch`, `wallet_farm` or `hook_critical_risk`, even if the score is higher. - **`low`**: a score of 80 or more. - **`medium`**: everything in between. Known assets (`known_asset: true`: WETH, USDG, tokenized stocks) are always `low`. ## Use it in your app 1. **Call `/security` before you list or trade a token.** It’s on the anonymous plan, so a backend can call it for every new token without a key; with a key it costs 1 credit. 2. **Gate on `risk`, explain with `flags`.** Block `critical`, warn on `high`, and show the flags as plain-language reasons. The table above has wording you can reuse. 3. **Show the evidence.** `tax.realized.samples` tells users how many trades the tax is based on, `liquidity.summary` how much is locked or burned, and `launch` who bought the first blocks. 4. **Watch for changes.** Taxes and LP status can change after launch. Subscribe to the [WebSocket stream](https://docs.crius.sh/reference/stream/) for tax and LP events, or re-check on a schedule. ```js // Minimal risk gate for a trading bot or token list. const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/security`); const { data } = await res.json(); if (data.risk === "critical") throw new Error("honeypot: can't sell"); if (data.risk === "high") console.warn(`high risk (${data.score}/100): ${data.flags.join(", ")}`); console.log(`buy tax ${data.tax.buy_pct ?? "?"}%, sell tax ${data.tax.sell_pct ?? "?"}%`); ``` Go deeper on one signal The score combines several endpoints. When you need the detail behind a flag, call it directly: [Liquidity & locks](https://docs.crius.sh/reference/security/liquidity-locks/) for every LP position and unlock date, [Snipers, bundles & clusters](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) for who bought the launch, and [Hook detail](https://docs.crius.sh/reference/pools/hook-detail/) for a hook’s code and history. ## Frequently asked questions **What is a good security score?** 80 or more is `low` risk: no honeypot, taxes at or under 5%, no owner powers that matter, liquidity locked or burned, a clean hook and a fair launch. 50–79 is `medium`. Under 50, or any insider launch, wallet farm or critical hook, is `high`; a honeypot is always `critical`. Treat the score as a summary and read the `flags`: they say exactly what cost points. **Does the score need an API key?** No. `/security` is on the anonymous plan (1 credit per call with a key). Without a key you get a low per-IP rate; a free key raises it and adds `fresh=1` re-simulation on paid plans. **How fresh is the score?** Results are cached for 15 seconds per token and trade size; on paid plans `fresh=1` simulates again at the current block. Realized taxes come from the last 30 days of trades (the median of the latest 50 per side), so a tax change appears as new trades arrive. `meta.block` tells you the block the answer was read at. **Can a token with a high score still go to zero?** Yes. The score measures what can be checked on-chain: the contract, the taxes buyers actually paid, the liquidity and who bought the launch. It can't see a team walking away or a market losing interest. A score of 95 means no trap was found, not that the price will hold. **Why is a well-known token marked low risk with flags?** Known assets (WETH, USDG, tokenized stocks) have `known_asset: true` and are always `low` risk; their flags (an upgradeable proxy, for example) are shown for information but don't change the verdict. ## Related [Concept **Score confidence & limits** What the Crius security score can and can't see on Robinhood Chain, how to read its confidence fields, and why a low-risk result is not a guarantee a token is safe. Read](https://docs.crius.sh/concepts/security-score-limits/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [API reference **Security checks API** Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. Read](https://docs.crius.sh/reference/security/security-checks/) --- # Track Robinhood Chain bonding-curve tokens about to graduate > Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Source: https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/tokens?list=graduating` for bonding-curve tokens at 50%+ `progress_pct`, closest to graduation first; `list=bonding` for every token still on a curve (newest first) and `list=graduated` for the latest graduations. Add `launchpad=pons` to follow one launchpad. These lists are on the anonymous plan; `/token/{address}/launch` (Free plan) has the curve, threshold and graduation pool. [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) Most Robinhood Chain launchpad tokens start on a **bonding curve** and **graduate** to a DEX pool once the curve has raised its target. Crius tracks every curve: `progress_pct` says how far a token is (100 once graduated), `status` says which stage it’s in, and three lists cover the stages: `bonding` (every token still on a curve), `graduating` (the ones at 50% or more, closest first) and `graduated` (the most recent graduations). ## See which tokens are closest to graduating Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Three Pons tokens past 80% Which Robinhood Chain launchpad tokens are closest to graduating right now? GET/v1/robinhood/tokens?list=graduating&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduating&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduating&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduating&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x742af99ef5e528ee85fb04ff76c44b22ef08611a", "buy_volume_usd": { "1h": 17156.5, "24h": 27636.8, "5m": 136.711, "6h": 27636.8 }, "buyers": { "1h": 125, "24h": 166, "5m": 9, "6h": 166 }, "buys": { "1h": 377, "24h": 463, "5m": 11, "6h": 463 }, "change_pct": { "1h": 50.0907, "24h": 833.914, "5m": -0.685261, "6h": 833.914 }, "created_block": 100366236, "created_ts": 1793220900600, "decimals": 18, "fdv_usd": 39766.1, "holders": 137, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/OwnerlessFun/status/2115538949003227427", "website": "https://ownerless.fun/" }, "liquidity_usd": 17192.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x742af99ef5e528ee85fb04ff76c44b22ef08611a.png?size=128", "market_cap_usd": 39566.5, "name": "Ownerless", "price_eth": 0.0000000168823, "price_usd": 0.0000397661, "progress_pct": 86.8006, "quote": "ETH", "sell_volume_usd": { "1h": 14474.1, "24h": 18573.6, "5m": 208.628, "6h": 18573.6 }, "sellers": { "1h": 64, "24h": 77, "5m": 11, "6h": 77 }, "sells": { "1h": 128, "24h": 157, "5m": 11, "6h": 157 }, "status": "bonding", "symbol": "OWNERLESS", "traders": { "1h": 137, "24h": 167, "5m": 16, "6h": 167 }, "txns": { "1h": 503, "24h": 618, "5m": 22, "6h": 618 }, "volume_usd": { "1h": 31630.6, "24h": 46210.4, "5m": 345.339, "6h": 46210.4 } }, { "address": "0x15053423de7365ebeabdcc53ff9619b85b5e7e9f", "buy_volume_usd": { "1h": 79807.5, "24h": 79807.5, "5m": 79793.5, "6h": 79807.5 }, "buyers": { "1h": 360, "24h": 360, "5m": 359, "6h": 360 }, "buys": { "1h": 557, "24h": 557, "5m": 555, "6h": 557 }, "change_pct": { "1h": 1319.15, "24h": 1319.15, "5m": 1172.95, "6h": 1319.15 }, "created_block": 100380473, "created_ts": 1793222372300, "decimals": 18, "fdv_usd": 76538.2, "holders": 263, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": "https://mafiacoin.site" }, "liquidity_usd": 33343.4, "logo": "https://api.crius.sh/v1/robinhood/logo/0x15053423de7365ebeabdcc53ff9619b85b5e7e9f.png?size=128", "market_cap_usd": 76538.2, "name": "MAFIA", "price_eth": 0.0000000324936, "price_usd": 0.0000765382, "progress_pct": 84.8, "quote": "PYPL", "sell_volume_usd": { "1h": 64938.6, "24h": 64938.6, "5m": 64938.6, "6h": 64938.6 }, "sellers": { "1h": 144, "24h": 144, "5m": 144, "6h": 144 }, "sells": { "1h": 383, "24h": 383, "5m": 383, "6h": 383 }, "status": "bonding", "symbol": "MAFIA", "traders": { "1h": 361, "24h": 361, "5m": 360, "6h": 361 }, "txns": { "1h": 939, "24h": 939, "5m": 937, "6h": 939 }, "volume_usd": { "1h": 144746, "24h": 144746, "5m": 144732, "6h": 144746 } }, { "address": "0x71d5502c2e670b151960596adfbfd57f3d414544", "buy_volume_usd": { "1h": 0, "24h": 2946.31, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 34, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 35, "5m": 0, "6h": 0 }, "change_pct": { "1h": 0.243191, "24h": 20.4499, "5m": 0.243191, "6h": 0.243191 }, "created_block": 98237798, "created_ts": 1792999460800, "decimals": 18, "fdv_usd": 37033.7, "holders": 160, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 16297.4, "logo": "https://api.crius.sh/v1/robinhood/logo/0x71d5502c2e670b151960596adfbfd57f3d414544.png?size=128", "market_cap_usd": 37033.7, "name": "NMS", "price_eth": 0.0000000157223, "price_usd": 0.0000370337, "progress_pct": 82.3668, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 1727.7, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 16, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 17, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "NMS", "traders": { "1h": 0, "24h": 45, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 52, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 4674.01, "5m": 0, "6h": 0 } } ], "meta": { "block": 100406911, "block_age_ms": 1550, "block_ts": 1793225089000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 558, "list": "graduating", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Ownerless (`0x742af99ef5e528ee85fb04ff76c44b22ef08611a`) leads at `progress_pct: 86.8006`, with 137 holders and 503 transactions in the last hour. - MAFIA (`0x15053423de7365ebeabdcc53ff9619b85b5e7e9f`) is at 84.8%. Of its $144,746 of volume in the last hour, $144,732 was in the last 5 minutes (`volume_usd["5m"]`), from 360 traders: a curve being bought out right now. Its curve is priced in PYPL (`quote`), a tokenized stock. - NMS (`0x71d5502c2e670b151960596adfbfd57f3d414544`) is at 82.3668% but has `txns["1h"]: 0` and was created more than two days earlier. High progress doesn’t mean it will finish: check recent volume. - All three are `status: "bonding"` and `launchpad: "pons"`. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20Pons%20tokens%20past%2080%25&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftrack-bonding-and-graduating-tokens%2F%23graduating%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduating%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Five minutes later, the graduated list shows MAFIA again: Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### MAFIA graduated five minutes later Which Robinhood Chain tokens graduated most recently? GET/v1/robinhood/tokens?list=graduated&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduated&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduated&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduated&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x15053423de7365ebeabdcc53ff9619b85b5e7e9f", "buy_volume_usd": { "1h": 181793, "24h": 181793, "5m": 100746, "6h": 181793 }, "buyers": { "1h": 912, "24h": 912, "5m": 603, "6h": 912 }, "buys": { "1h": 1493, "24h": 1493, "5m": 920, "6h": 1493 }, "change_pct": { "1h": -8.67205, "24h": -8.67205, "5m": -8.67205, "6h": -8.67205 }, "created_block": 100380473, "created_ts": 1793222372300, "decimals": 18, "fdv_usd": 139039, "holders": 517, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": "https://mafiacoin.site" }, "liquidity_usd": 65561.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x15053423de7365ebeabdcc53ff9619b85b5e7e9f.png?size=128", "market_cap_usd": 139039, "name": "MAFIA", "price_eth": 0.0000000590278, "price_usd": 0.000139039, "progress_pct": 100, "quote": "PYPL", "sell_volume_usd": { "1h": 170074, "24h": 170074, "5m": 104923, "6h": 170074 }, "sellers": { "1h": 524, "24h": 524, "5m": 431, "6h": 524 }, "sells": { "1h": 1516, "24h": 1516, "5m": 1127, "6h": 1516 }, "status": "graduated", "symbol": "MAFIA", "traders": { "1h": 915, "24h": 915, "5m": 774, "6h": 915 }, "txns": { "1h": 2950, "24h": 2950, "5m": 1989, "6h": 2950 }, "volume_usd": { "1h": 351867, "24h": 351867, "5m": 205669, "6h": 351867 } }, { "address": "0x2ff4b36c789d08676df4c81d9923d5e4e3b3c1e5", "buy_volume_usd": { "1h": 48439.8, "24h": 48439.8, "5m": 3320.99, "6h": 48439.8 }, "buyers": { "1h": 248, "24h": 248, "5m": 23, "6h": 248 }, "buys": { "1h": 412, "24h": 412, "5m": 35, "6h": 412 }, "change_pct": { "1h": 368.978, "24h": 368.978, "5m": -15.8079, "6h": 368.978 }, "created_block": 100400743, "created_ts": 1793224449300, "decimals": 18, "fdv_usd": 127489, "holders": 131, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/WagieCoinRH", "website": null }, "liquidity_usd": 23110.5, "logo": "https://api.crius.sh/v1/robinhood/logo/0x2ff4b36c789d08676df4c81d9923d5e4e3b3c1e5.png?size=128", "market_cap_usd": 127489, "name": "WAGIE", "price_eth": 0.0000000541243, "price_usd": 0.000127489, "progress_pct": 100, "quote": "MCD", "sell_volume_usd": { "1h": 36040, "24h": 36040, "5m": 4371.27, "6h": 36040 }, "sellers": { "1h": 139, "24h": 139, "5m": 16, "6h": 139 }, "sells": { "1h": 391, "24h": 391, "5m": 32, "6h": 391 }, "status": "graduated", "symbol": "WAGIE", "traders": { "1h": 249, "24h": 249, "5m": 37, "6h": 249 }, "txns": { "1h": 801, "24h": 801, "5m": 67, "6h": 801 }, "volume_usd": { "1h": 84479.8, "24h": 84479.8, "5m": 7692.26, "6h": 84479.8 } }, { "address": "0xeb4641bc510277848984ef9539d54ba05ebd7777", "buy_volume_usd": { "1h": 31499.4, "24h": 31499.4, "5m": 983.296, "6h": 31499.4 }, "buyers": { "1h": 271, "24h": 271, "5m": 22, "6h": 271 }, "buys": { "1h": 376, "24h": 376, "5m": 23, "6h": 376 }, "change_pct": { "1h": 21.509, "24h": 21.509, "5m": 1.91903, "6h": 21.509 }, "created_block": 100389612, "created_ts": 1793223305200, "decimals": 18, "fdv_usd": 70670.2, "holders": 163, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/Vellum_X", "website": "https://www.vellumrh.xyz/" }, "liquidity_usd": 25878.7, "logo": "https://api.crius.sh/v1/robinhood/logo/0xeb4641bc510277848984ef9539d54ba05ebd7777.png?size=128", "market_cap_usd": 70670.2, "name": "Vellum", "price_eth": 0.0000000300023, "price_usd": 0.0000706702, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 17757.8, "24h": 17757.8, "5m": 846.042, "6h": 17757.8 }, "sellers": { "1h": 159, "24h": 159, "5m": 36, "6h": 159 }, "sells": { "1h": 250, "24h": 250, "5m": 41, "6h": 250 }, "status": "graduated", "symbol": "VELLUM", "traders": { "1h": 273, "24h": 273, "5m": 48, "6h": 273 }, "txns": { "1h": 610, "24h": 610, "5m": 63, "6h": 610 }, "volume_usd": { "1h": 49257.2, "24h": 49257.2, "5m": 1829.34, "6h": 49257.2 } } ], "meta": { "block": 100409857, "block_age_ms": 808, "block_ts": 1793225391000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 87, "list": "graduated", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - MAFIA (`0x15053423de7365ebeabdcc53ff9619b85b5e7e9f`) is first, now `status: "graduated"` with `progress_pct: 100`. Its `holders` went from 263 to 517 and `liquidity_usd` from $33,343.4 to $65,561.8 in the 301 seconds between the two samples. - WAGIE (`0x2ff4b36c789d08676df4c81d9923d5e4e3b3c1e5`) is another Pons graduation, quoted in MCD; it was created about 16 minutes before this response. - Vellum (`0xeb4641bc510277848984ef9539d54ba05ebd7777`) graduated from Flap.sh (`launchpad: "flap"`) with a WETH quote. Flap tokens graduate into a Uniswap v2 pair; Pons tokens into a Uniswap v4 pool. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20MAFIA%20graduated%20five%20minutes%20later&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftrack-bonding-and-graduating-tokens%2F%23graduated%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduated%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The full lifecycle of one token The lists tell you where every token stands. `/token/{address}/launch` (Free plan) tells you everything about one launch: the curve contract, the target, what moved into the pool and where the LP went. Example [Free plan · 2 credits](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) ### Charge AI: from Pons curve to locked v4 pool How did Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) graduate, and where is its liquidity? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 74 lines (arrays trimmed)** ```json { "data": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_stats": { "buys": 482, "first_indexed_block": 88385895, "history": "complete", "sells": 280, "unique_traders": 61, "volume_quote": 21.053399701262936019 }, "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fees": { "buyback_burn_bps": 5000, "buyback_enabled": false, "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "creator_fee_recipient": "0x14a6f00bad1f4e21e2af4e317383c3d550378996", "creator_tax_bps": 200, "escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook_fee_bps": 100, "pending": { "buyback": 0, "creator_tax": 0.0010373586867571, "currency": "ETH", "fees": 0.000518679343378549 }, "protocol_fee_recipient": "0x31ea5b453a6cd60f36203830de046ff32dec2cdb", "protocol_fee_share_bps": 3000, "snipe_tax": { "start_bps": 9900, "window_s": 3 } }, "graduation": { "block": 88461321, "blocks_to_graduate": 75435, "graduated_block_recorded": 88461321, "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "lp_position_id": 3790055, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_to_pool": 4.200000000000000236, "tokens_to_pool": 204081632.653061227766208523, "ts": 1791990423100 }, "launch_tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747", "launched_block": 88385886, "launched_ts": 1791982833600, "launched_via": "factory", "launchpad": "pons", "launchpad_name": "Pons", "pair_token": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "progress": { "pct": 100, "raised": 4.200000000000000236, "threshold": 4.2 }, "status": "graduated", "version": "v2" }, "meta": { "block": 100406852, "block_age_ms": 778, "block_ts": 1793225083000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 86, "safe_block": 100401329 } } ``` What this tells you - `progress.raised: 4.2` against `progress.threshold: 4.2` ETH (`pair_token.symbol: "ETH"`): the curve sold out and `status` is `graduated`. - `graduation.blocks_to_graduate: 75435`, about two hours from `launched_ts` to `graduation.ts`, far slower than Pons’s median of 2,490 blocks. - At graduation `graduation.quote_to_pool` (4.2 ETH) and `graduation.tokens_to_pool` (204,081,632.65 CHARGE) went into the v4 pool `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`. The LP position (`lp_position_id: 3790055`) sits in the Pons locker `0x267444d099b10fb5ed7c3cc7b7c767adca574952`. - `curve_stats`: 482 buys and 280 sells by 61 wallets on the curve, and `history: "complete"`, so every curve trade is indexed. [Launch lifecycle reference](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Charge%20AI%3A%20from%20Pons%20curve%20to%20locked%20v4%20pool&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftrack-bonding-and-graduating-tokens%2F%23lifecycle%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Flaunch%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Which list to use | List | Contains | Order | | --- | --- | --- | | `bonding` | Every launchpad token still on its curve (`status: "bonding"`) | Newest launch first | | `graduating` | Bonding tokens with `progress_pct` of 50 or more | Highest `progress_pct` first | | `graduated` | Tokens that left their curve for a DEX pool | Most recent graduation first | | `new` | Every new token, launchpad or not | Newest first | Fields that describe the stage: - `status`: `bonding`, `graduated`, or `launched` for launchpads with no curve (Bankr and Long.xyz tokens trade on Uniswap v4 from the first block). - `progress_pct`: raised quote ÷ the curve’s target, in percent; `null` before the first curve trade or when the launchpad’s progress isn’t measured (many fresh Flap tokens show `null`). - `quote`: what the curve is priced in. On Pons that is often a stock token (PYPL, MCD) rather than ETH. - `launchpad`: filter any of these lists with `launchpad=pons`, `flap`, `flywheel` or `standard_reserve`. How each launchpad graduates (target, destination pool, LP handling) is on its own page: [Pons](https://docs.crius.sh/launchpads/pons/), [Flap.sh](https://docs.crius.sh/launchpads/flap/), [Flywheel](https://docs.crius.sh/launchpads/flywheel/), [King of the Markets](https://docs.crius.sh/launchpads/standard-reserve/). ## Use it in your app 1. **Poll `graduating` for a watchlist.** Every 5–10 seconds; keep the last `progress_pct` per address so you can alert on a threshold you choose (90%, 95%). 2. **Weigh progress by recent activity.** A token at 85% with no trades in the last hour (NMS above) is not about to graduate; one at 84.8% with 360 traders in 5 minutes (MAFIA) is. 3. **Catch the graduation.** When a watched token drops out of `graduating`, look for it in `graduated`, or subscribe to `graduations:all` on the [WebSocket](https://docs.crius.sh/reference/stream/) to get the new pool immediately. 4. **Read the launch once it graduates.** `/launch` gives the pool and the LP lock; `/security` confirms the liquidity is locked or burned. ```js // Alert when a Pons token crosses 95% of its curve, and when it graduates. const API = "https://api.crius.sh/v1/robinhood"; const last = new Map(); // address -> last progress_pct async function tick() { const { data } = await (await fetch(`${API}/tokens?list=graduating&launchpad=pons&limit=100`)).json(); const now = new Set(); for (const t of data) { now.add(t.address); const before = last.get(t.address) ?? 0; if (before < 95 && t.progress_pct >= 95) console.log(`${t.symbol} ${t.address} at ${t.progress_pct.toFixed(1)}%, ${t.traders["5m"]} traders in 5m`); last.set(t.address, t.progress_pct); } const gone = [...last.keys()].filter((a) => !now.has(a)); if (gone.length === 0) return; const g = await (await fetch(`${API}/tokens?list=graduated&launchpad=pons&limit=50`)).json(); for (const addr of gone) { last.delete(addr); const t = g.data.find((x) => x.address === addr); if (t) console.log(`graduated: ${t.symbol} ${addr}, liquidity $${Math.round(t.liquidity_usd)}`); } } setInterval(tick, 10_000); ``` ## Frequently asked questions **How do I track Pons launches that are about to graduate?** Poll `GET https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons`. It returns Pons tokens still on their bonding curve with `progress_pct` of 50 or more, highest first. When a token leaves this list with `status: "graduated"`, it has moved to its Uniswap v4 pool; `list=graduated&launchpad=pons` shows it there. **What does graduating mean on Robinhood Chain?** A launchpad token starts on a bonding curve that sells tokens for a quote asset (ETH, USDG or a stock token). When the curve has raised its target, the launchpad moves the raised liquidity into a DEX pool and trading continues there. That move is the graduation. Pons, Flap, Flywheel and King of the Markets tokens graduate; Bankr and Long.xyz tokens trade on Uniswap v4 from the start and have no curve stage. **How long does a Pons token take to graduate?** Of the Pons tokens that graduate, the median took 2,490 blocks (`median_blocks_to_graduate`), about four minutes at Robinhood Chain's ~100 ms blocks. Most never do: 10,479 of 716,241 Pons launches had graduated (`graduation_rate_pct` 1.46) when the samples were captured. **Why is progress\_pct null?** The curve hasn't been traded yet, or Crius doesn't measure progress for that launchpad's curve. Such tokens are in `list=bonding` but never in `list=graduating`, which needs a measured progress of 50% or more. **Can I get notified the moment a token graduates?** Yes. Subscribe to `graduations:all` or `graduations:pons` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) (free API key). Each message includes the new pool. Polling `list=graduated` every few seconds works without a key. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Find new tokens** List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Read](https://docs.crius.sh/guides/find-new-tokens/) [Guide **Stream new tokens** Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token. Read](https://docs.crius.sh/guides/stream-new-tokens/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) [API reference **Launch lifecycle API** A launchpad token's lifecycle: creator, curve, bonding progress, raised amount, graduation block and the pool it graduated into. Read](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [API reference **Token lists API** Lists: new, bonding, graduating, graduated, trending, top\_volume, top\_gainers, top\_losers, top\_market\_cap (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Read](https://docs.crius.sh/reference/discovery/token-lists/) --- # Track a token's holder count over time > Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example. Source: https://docs.crius.sh/guides/track-holder-count/ · Updated 2026-10-28 Short answer Call `GET /v1/robinhood/token/{address}/holders/history?interval=1h` (Starter plan, 10 credits). It returns parallel arrays per interval: `t`, `holders` (count at the end), `min`, `max`, `new` and `exited`, plus a `summary` with the period's `min`, `max` and `now`. `min_usd` or `min_balance` set who counts as a holder. [GET `/token/{address}/holders/history`](https://docs.crius.sh/reference/holders/holder-count-history/) [GET `/token/{address}/holders`](https://docs.crius.sh/reference/holders/live-holders/) Holder count history is the number of addresses holding a token, measured over time at the interval you choose. Crius replays every transfer of the token and, for each interval, returns the count at its end, the lowest and highest count during it, and how many wallets arrived and left. You decide who counts as a holder: any balance, a minimum USD value or a minimum token amount. ## Get the history in one call Example [Starter plan · 10 credits](https://docs.crius.sh/reference/holders/holder-count-history/) ### CHARGE's first five days: from 476 holders to 294 How did the number of Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) holders change day by day after its launch? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1d&limit=5 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1d&limit=5" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1d&limit=5", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1d&limit=5", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 70 lines (arrays trimmed)** ```json { "data": { "exited": [ 3082, 1030, 462, 216, 148 ], "history": "complete", "holder_definition": { "exclude": [], "min_balance": null, "min_usd": null, "note": "" }, "holders": [ 421, 381, 359, 309, 294 ], "interval": "1d", "max": [ 476, 429, 382, 359, 313 ], "min": [ 1, 378, 353, 306, 294 ], "new": [ 3503, 990, 440, 166, 133 ], "summary": { "max": 476, "max_ts": 1791936000000, "min": 1, "min_ts": 1791936000000, "now": 238 }, "t": [ 1791936000000, 1792022400000, 1792108800000, 1792195200000, 1792281600000 ] }, "meta": { "block": 100406819, "block_age_ms": 372, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 41, "safe_block": 100401329 } } ``` What this tells you - `interval: "1d"`: each array index is one UTC day. `t[0]` is 1791936000000 (2026-10-14, launch day) and `t[4]` 1792281600000 (2026-10-18). The captured example is cut to the first five days. - Launch day: `min[0]: 1` (right after the mint, the whole supply sat in one address), `max[0]: 476`, and the day closed at `holders[0]: 421`. - `new[0]: 3503` and `exited[0]: 3082`: thousands of wallets bought and sold out on the first day. That’s what launch-day flipping looks like. - From day 2 the count only fell: 381, 359, 309, 294. On each of those days `exited` was higher than `new` (1030 against 990 on day 2, 148 against 133 on day 5). - `summary.max: 476` at `max_ts: 1791936000000` is the peak of the whole history; `summary.now: 238` holders at capture, half the peak. - `holder_definition` has no `min_balance`, `min_usd` or `exclude`: every address with a balance counts, including pools and the burn address. Add `exclude=infra` to leave them out. [Holder count history reference](https://docs.crius.sh/reference/holders/holder-count-history/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20first%20five%20days%3A%20from%20476%20holders%20to%20294&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Ftrack-holder-count%2F%23charge-holder-history%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%2Fhistory%3Finterval%3D1d%26limit%3D5%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) The arrays add up: each day’s closing count is the previous close plus `new` minus `exited` (421 + 990 − 1030 = 381). ## What the fields mean | Field | Meaning | | --- | --- | | `interval` | Bucket size: `1m`, `5m`, `15m`, `1h` (default), `4h` or `1d`. | | `t[]` | Start of each interval, unix ms. | | `holders[]` | Holder count at the end of the interval. | | `min[]`, `max[]` | Lowest and highest count during the interval. | | `new[]`, `exited[]` | Addresses that became holders, and that stopped being holders, during the interval. | | `summary.min`, `min_ts`, `max`, `max_ts` | Lowest and highest count in the window, and the interval where each happened. | | `summary.now` | The count at the end of the window. | | `holder_definition` | Who counts: `min_balance`, `min_usd`, `exclude`, and a `note` (for example that `min_usd` was converted at the current price). | | `history` | `complete` when the token's whole transfer history is indexed. | `from` and `to` limit the window, with the same point forms as snapshots: `block:N`, `ts:MS`, `mcap:USD`, or the labels `launch`, `graduation`, `ath`, `now` (see [historical holders](https://docs.crius.sh/guides/get-historical-holders/#choose-the-point-in-time)). For example `from=graduation&to=now&interval=4h` charts holders since the token left its bonding curve. Intervals with no transfers are left out, so the `t` array can skip time. ## Use it in your app 1. **Choose an interval for the chart’s range.** `1h` for a few days, `1d` for weeks. Finer intervals return more points for the same window. 2. **Decide who counts.** The raw count includes every dust wallet, pools and the burn address. For a number users trust, use `exclude=infra` and a small `min_usd`, and say so on the chart. 3. **Plot `holders` as the line and `min`/`max` as the band.** On busy days the count moves a lot inside one interval; the band shows it. Bars of `new` and `exited` explain the moves. 4. **Get a Starter key.** Holder history needs the Starter plan and costs 10 credits per call. Past intervals don’t change, so fetch the full history once and then only the recent window. ```python import os, requests from datetime import datetime, timezone token = "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" r = requests.get( f"https://api.crius.sh/v1/robinhood/token/{token}/holders/history", params={"interval": "1d", "from": "launch", "to": "now", "exclude": "infra", "min_usd": 1}, headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) d = r.json()["data"] for t, n, new, out in zip(d["t"], d["holders"], d["new"], d["exited"]): day = datetime.fromtimestamp(t / 1000, timezone.utc).date() print(day, n, f"+{new}", f"-{out}") s = d["summary"] print(f"peak {s['max']}, now {s['now']} ({s['now'] / s['max']:.0%} of peak)") ``` Very active tokens Holder history replays every transfer of the token. Tokens with more than 2M transfers (WETH, USDG, tokenized stocks) return `400 window_too_large` (or `token_too_active`). For those, poll the live [`/holders`](https://docs.crius.sh/reference/holders/live-holders/) `count` on a schedule instead. ## Frequently asked questions **How do I get a token's holder count history?** Call `/v1/robinhood/token/{address}/holders/history` with an `interval` (`1m`, `5m`, `15m`, `1h`, `4h`, `1d`). Each index `i` of the arrays is one interval starting at `t[i]` (unix ms): `holders[i]` is the count at its end, `min[i]` and `max[i]` the lowest and highest during it, `new[i]` and `exited[i]` the wallets that arrived and left. **What was the most holders a token ever had?** `summary.max` and `summary.max_ts` give the highest count in the window and when it happened; `summary.min` and `min_ts` the lowest; `summary.now` the current count. For CHARGE, the peak was 476 on launch day and the count at capture was 238. **Can I ignore dust wallets in the holder count?** Yes. `min_usd=10` counts only wallets holding $10 or more, `min_balance` a token amount. `min_usd` is converted to a token amount at the current price (`holder_definition.note` says so), so the threshold is the same token amount across the whole chart. **Why are new and exited holders so high on launch day?** Arrivals and exits both rise with volume. On CHARGE's first day 3,503 wallets became holders and 3,082 left the same day; quick flippers and bots inflate both. Watch `new` against `exited` rather than the count alone. **Which plan does holder history need?** The Starter plan or higher, 10 credits per call. See [Plans & limits](https://docs.crius.sh/plans-and-limits/). ## Related [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Guide **Historical holders** Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder. Read](https://docs.crius.sh/guides/get-historical-holders/) [Guide **Diamond-hand holders** Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example. Read](https://docs.crius.sh/guides/find-diamond-hand-holders/) [Guide **Chain stats dashboard** Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Read](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/) [API reference **Holder count history API** Holder count over time at a chosen interval, with your own definition of a holder (min\_balance or min\_usd). Read](https://docs.crius.sh/reference/holders/holder-count-history/) --- # Use the Crius API from AI agents (OpenAPI, llms.txt, MCP) > Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips. Source: https://docs.crius.sh/guides/use-crius-with-ai-agents/ · Updated 2026-10-28 Short answer For writing code, give the model `https://docs.crius.sh/llms.txt` (or `llms-full.txt`, or any page as `.md`). For live data, turn `https://api.crius.sh/openapi.json` into tool definitions or run a small MCP server around a few endpoints. Core endpoints work without a key at 2 requests per second; give a production agent its own key with only the `read` scope. [GET `/search`](https://docs.crius.sh/reference/discovery/search/) [GET `/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) AI agents use the Crius API in two ways: they read the documentation to write correct code against it, and they call it as a tool to answer questions about Robinhood Chain right now. For the first, the docs are published as [llms.txt](https://docs.crius.sh/llms.txt), one full-text file and a Markdown copy of every page. For the second, the OpenAPI document at `https://api.crius.sh/openapi.json` turns into tool definitions in a few lines, or into a small MCP server. Core endpoints work without a key, so an agent can explore before you give it one. ## What to give the model | Resource | URL | Use it for | | --- | --- | --- | | `llms.txt` | `https://docs.crius.sh/llms.txt` | Index of every docs page, with summaries and links to Markdown | | `llms-full.txt` | `https://docs.crius.sh/llms-full.txt` | All docs in one Markdown file, for long-context models or retrieval | | Markdown pages | `https://docs.crius.sh/.md` | One page, e.g. `https://docs.crius.sh/guides/token-security-score.md` | | OpenAPI 3.1 | `https://api.crius.sh/openapi.json` | Endpoints, parameters and descriptions for tool definitions | Every page also has a **Copy as Markdown** button. More on these resources is on the [AI page](https://docs.crius.sh/ai/). ## The two lessons every agent needs Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### Three tokens with the symbol NVDA A user asks an agent for the price of NVDA. Which token is that? GET/v1/robinhood/search?q=nvda&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=nvda&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=nvda&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=nvda&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 73 lines (arrays trimmed)** ```json { "data": [ { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "label": "stock_nvda", "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5690673, "logo": null, "name": "NVIDIA • Robinhood Token", "price_usd": 214.313, "symbol": "NVDA", "type": "token" }, { "address": "0xdecf74e4aa6ff30b1612e65665aaf650bedecba3", "label": null, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 7070.72, "logo": null, "name": "NVDA", "price_usd": 0.000000282232, "symbol": "NVDA", "type": "token" }, { "address": "0xaaea5ec642e0b3ebbe7b484ad3702a408ca743c9", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/NVDADogAsset", "twitter": "https://x.com/NVDADogAsset", "website": "https://www.nextviraldogasset.vip" }, "liquidity_usd": 4674.03, "logo": "https://api.crius.sh/v1/robinhood/logo/0xaaea5ec642e0b3ebbe7b484ad3702a408ca743c9.png?size=128", "name": "Next Viral Dog Asset", "price_usd": 0.00000270377, "symbol": "NVDA", "type": "token" } ], "meta": { "block": 100409954, "block_age_ms": 464, "block_ts": 1793225401000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 7, "safe_block": 100405028 } } ``` What this tells you - The first result is NVIDIA’s tokenized stock: `name: "NVIDIA • Robinhood Token"`, `label: "stock_nvda"`, `address` `0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec`, `price_usd` 214.313 and `liquidity_usd` 5,690,673. - The other two also use the symbol `NVDA`: a Bankr token (`0xdecf74e4aa6ff30b1612e65665aaf650bedecba3`, price 0.000000282232) and a Pons token named Next Viral Dog Asset (`0xaaea5ec642e0b3ebbe7b484ad3702a408ca743c9`). - An agent that passes the symbol around would be off by a factor of about 760 million. Resolve to an address once, prefer a `label` or the deepest liquidity, and confirm with the user when results are close. [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20tokens%20with%20the%20symbol%20NVDA&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fuse-crius-with-ai-agents%2F%23symbols%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3Dnvda%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Free plan · 2 credits](https://docs.crius.sh/reference/holders/live-holders/) ### An error the agent can act on An agent without a key asks for CHARGE's holders. What comes back? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 403 Captured Oct 28, 2026 · 10 lines (arrays trimmed)** ```json { "error": { "code": "plan_required", "docs_url": "https://docs.crius.sh/plans-and-limits/", "message": "This endpoint needs an API key (Free plan or higher); you called it without one. To use it, get a free API key at https://dashboard.crius.sh.", "plan": "anon", "required_plan": "free", "upgrade_url": "https://dashboard.crius.sh" } } ``` What this tells you - `403` with `error.code: "plan_required"` and `required_plan: "free"`: the endpoint needs a key on the Free plan or higher. - `error.message` is a complete sentence the agent can pass to the user as is, and `upgrade_url` says where to get a key. - Return errors to the model as text, not exceptions. It can then explain the problem, wait after a `429 rate_limited` (`retry_after_ms`), or pick an endpoint its key allows. [Live holders reference](https://docs.crius.sh/reference/holders/live-holders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20An%20error%20the%20agent%20can%20act%20on&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fguides%2Fuse-crius-with-ai-agents%2F%23errors%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Tool definitions from the OpenAPI document This turns a handful of endpoints into provider-neutral tool definitions (name, description, JSON Schema parameters) and runs them. Pass `tools` to your model’s tool or function-calling API and feed each call to `runTool`. ```js // crius-tools.mjs: tool definitions from Crius's OpenAPI document (Node.js 22+) const KEY = process.env.CRIUS_API_KEY; // optional: the anonymous plan covers these endpoints const spec = await (await fetch("https://api.crius.sh/openapi.json")).json(); const PATHS = [ "/v1/{chain}/search", "/v1/{chain}/token/{address}", "/v1/{chain}/token/{address}/price", "/v1/{chain}/token/{address}/security", "/v1/{chain}/token/{address}/candles", "/v1/{chain}/tokens", ]; const toolName = (path) => path.replace("/v1/{chain}", "").replace(/\{\w+\}/g, "").split("/").filter(Boolean).join("_"); export const tools = PATHS.map((path) => { const op = spec.paths[path].get; const params = op.parameters.filter((p) => p.name !== "chain"); // always Robinhood Chain return { name: toolName(path), // search, token, token_price, token_security, token_candles, tokens description: `Robinhood Chain: ${op.summary}. ${op.description ?? ""}`.trim(), path, parameters: { type: "object", properties: Object.fromEntries(params.map((p) => [p.name, { type: p.schema?.type ?? "string", description: p.description || p.name }])), required: params.filter((p) => p.required).map((p) => p.name), }, }; }); export async function runTool(name, args) { const tool = tools.find((t) => t.name === name); let path = tool.path.replace("{chain}", "robinhood"); const query = new URLSearchParams(); for (const [k, v] of Object.entries(args ?? {})) { if (path.includes(`{${k}}`)) path = path.replace(`{${k}}`, encodeURIComponent(v)); else if (v != null) query.set(k, String(v)); } const res = await fetch(`https://api.crius.sh${path}${query.size ? `?${query}` : ""}`, { headers: KEY ? { "x-api-key": KEY } : {} }); const body = await res.json(); if (!res.ok) return `Crius API error ${res.status} ${body.error?.code}: ${body.error?.message}`; // text the model can act on return JSON.stringify({ data: body.data, block: body.meta?.block }).slice(0, 20_000); // trim, and keep the block for citing } console.log(tools.map((t) => t.name).join(", ")); console.log((await runTool("token_price", { address: "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" })).slice(0, 120)); ``` ## Or an MCP server For assistants that speak the Model Context Protocol (desktop assistants, IDE agents), wrap the same calls as MCP tools. Tested with `@modelcontextprotocol/sdk` 1.32.1 and `zod` 4.6.5: ```js // crius-mcp.mjs: npm i @modelcontextprotocol/sdk@1.32.1 zod@4.6.5, then register "node crius-mcp.mjs" in your MCP client import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"; import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"; import { z } from "zod"; const API = "https://api.crius.sh/v1/robinhood"; const KEY = process.env.CRIUS_API_KEY; const address = z.string().regex(/^0x[0-9a-fA-F]{40}$/).describe("Token address (0x + 40 hex characters)"); async function crius(path) { const res = await fetch(`${API}${path}`, { headers: KEY ? { "x-api-key": KEY } : {} }); const body = await res.json(); const text = res.ok ? JSON.stringify({ data: body.data, block: body.meta?.block }).slice(0, 20_000) : `Crius API error ${res.status} ${body.error?.code}: ${body.error?.message}`; return { content: [{ type: "text", text }], isError: !res.ok }; } const server = new McpServer({ name: "crius", version: "1.0.0" }); const ro = { readOnlyHint: true }; server.registerTool("search_tokens", { description: "Find Robinhood Chain tokens by name, symbol or address. Symbols are not unique: pick by address.", inputSchema: { query: z.string().min(1).max(64) }, annotations: ro, }, ({ query }) => crius(`/search?q=${encodeURIComponent(query)}&type=token&limit=10`)); server.registerTool("token_profile", { description: "Price, market cap, liquidity, holders summary and launchpad of a Robinhood Chain token.", inputSchema: { address }, annotations: ro, }, ({ address }) => crius(`/token/${address}`)); server.registerTool("token_security", { description: "Security score 0-100, risk level, flags, buy/sell tax and honeypot check of a token.", inputSchema: { address }, annotations: ro, }, ({ address }) => crius(`/token/${address}/security`)); await server.connect(new StdioServerTransport()); ``` ## Keep the agent accurate 1. **A key of its own.** Create a key for the agent with only the `read` scope, an IP allow-list if it runs on a fixed host and a per-key rate limit ([Authentication](https://docs.crius.sh/authentication/)). Revoke it without touching your other services. 2. **Teach the units.** Amounts are in human units, USD values are plain decimals and timestamps are unix milliseconds. Say so in the system prompt, with the [conventions](https://docs.crius.sh/conventions/) page in context. 3. **Cite the block.** Every response has `meta.block`. Returning it with the data lets the agent say “at block 100409954” instead of “now”. 4. **Budget the calls.** Each tool call costs its endpoint’s credits: 1 for search, profile, price or security, 2 for candles or trades, 5 or 10 for the heavier holder and wallet analytics. Limit tool calls per conversation if the agent is public. Suggested system prompt “You can call the Crius API for Robinhood Chain (chain id 4663) data. Resolve token names with search and use addresses afterwards; symbols are not unique. Amounts are human units, USD values plain decimals, timestamps unix milliseconds. Cite `block` with every number. Docs: [https://docs.crius.sh/llms.txt](https://docs.crius.sh/llms.txt).” ## Frequently asked questions **Is there an llms.txt for the Crius docs?** Yes: `https://docs.crius.sh/llms.txt` lists every page with a one-line summary and a link to its Markdown version, and `https://docs.crius.sh/llms-full.txt` has all pages in one file. Any page is also available as Markdown by adding `.md` to its path, for example `https://docs.crius.sh/guides/token-security-score.md`. **Where is the Crius OpenAPI document?** At `https://api.crius.sh/openapi.json` (OpenAPI 3.1). It lists every endpoint with its parameters and descriptions, which is what tool and function definitions need. Plans and credit costs per endpoint are on [Plans & limits](https://docs.crius.sh/plans-and-limits/). **Can an agent call the API without a key?** Yes, for the anonymous-plan endpoints: token profiles and prices, batch prices, pools, trades, candles, token lists, search, stats, volume, launchpads and security. The limit is 2 requests per second per IP. Holders, wallets, bundles and the stream need a key; the error says which plan. **How do I stop an agent confusing tokens with the same symbol?** Make it resolve every name to an address with `/search` first, prefer results with a `label` such as `stock_nvda` or the deepest `liquidity_usd`, and pass addresses, never symbols, to every other tool. Tell it in the system prompt that symbols are not unique on Robinhood Chain. **Is there an official Crius MCP server?** There's no package to install. The server on this page is about 40 lines, wraps whichever endpoints you choose, and runs in any MCP-capable client. ## Related [Docs **For AI agents & LLMs** How AI assistants and agents can read the Crius documentation (llms.txt, llms-full.txt, Markdown pages) and call the Crius API (OpenAPI document, anonymous endpoints). Read](https://docs.crius.sh/ai/) [Use case **AI agents** Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block. Read](https://docs.crius.sh/use-cases/ai-agents/) [Docs **Authentication & API keys** How to authenticate Crius API requests with the x-api-key header, key scopes, IP allow-lists, browser origins, expiry, rotation with a grace period, and dashboard sessions. Read](https://docs.crius.sh/authentication/) [Guide **Search tokens** Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included. Read](https://docs.crius.sh/guides/search-tokens/) [Docs **Errors** Crius API error format, HTTP status codes and every error code with its meaning and what to do about it. Read](https://docs.crius.sh/errors/) --- # Robinhood Chain API for AI agents > Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block. Source: https://docs.crius.sh/use-cases/ai-agents/ · Updated 2026-10-28 AI agents and LLM assistants are asked Robinhood Chain questions all the time: “is this token safe”, “what is it worth”, “who holds it”, “what launched on Pons today”. They can only answer from data they can fetch. The Crius API gives an agent a small set of tools that return compact JSON with plain decimal numbers, human-unit amounts and the block each answer reflects, plus errors that explain themselves. An agent can start without a key, and the OpenAPI document turns into tool definitions directly. ## Tools to give an agent Expose a handful of tools rather than every endpoint. Models choose better from five clear tools than from thirty. - [GET`/search`](https://docs.crius.sh/reference/discovery/search/) name or symbol → address. Every other tool takes an address, so this comes first. - [GET`/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) the one-call summary: price, market cap, liquidity, holders, launchpad, LP lock, links. - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) “is it safe”: `score`, `risk`, `flags`, taxes, honeypot. - [GET`/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) the cheapest call, for price questions and loops. - [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) history questions (“how did it do this week”). - [GET`/v1/status`](https://docs.crius.sh/reference/chain/service-status/) a freshness check before answering “right now” questions. Add [top traders](https://docs.crius.sh/reference/holders/top-traders/), [holders](https://docs.crius.sh/reference/holders/live-holders/) or [token lists](https://docs.crius.sh/reference/discovery/token-lists/) when your agent’s job needs them (holders and traders need a Free key). ## Suggested architecture 1. **Generate tools from OpenAPI.** Fetch `https://api.crius.sh/openapi.json`, keep the endpoints you chose, and write a one-line description for each that says when to use it. 2. **Resolve names before anything else.** Symbols aren’t unique on Robinhood Chain (three tokens match “charge”). Have the agent search, show the candidates with their addresses, and continue only with an address. 3. **Give the agent its own key.** A dedicated key with only the `read` scope, an IP allow-list if it runs on a fixed host and its own rate limit. Revoke it from the dashboard at any time without touching your other keys. 4. **Pass errors to the model as they are.** Errors have a stable `error.code` and a `message` written for people, so the agent can explain a missing plan or a rate limit in plain words. 5. **Cite the block.** Ask the model to include `meta.block` in answers about prices, holders or risk. Each tool call costs what the endpoint costs: 1 credit for search, profile, price and security, 2 for candles. An agent answering 2,000 questions a day with about four calls each uses roughly 8,000 to 16,000 credits a day, within the Free plan’s 1,000,000 a month. ## Errors an agent can explain Example [Free plan · 2 credits](https://docs.crius.sh/reference/holders/live-holders/) ### A plan error with the fix in it The agent called the holders endpoint without a key. What does it get back? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 403 Captured Oct 28, 2026 · 10 lines (arrays trimmed)** ```json { "error": { "code": "plan_required", "docs_url": "https://docs.crius.sh/plans-and-limits/", "message": "This endpoint needs an API key (Free plan or higher); you called it without one. To use it, get a free API key at https://dashboard.crius.sh.", "plan": "anon", "required_plan": "free", "upgrade_url": "https://dashboard.crius.sh" } } ``` What this tells you - HTTP `403` with `error.code: "plan_required"`: the endpoint isn’t on the caller’s plan (`plan: "anon"`). - `required_plan: "free"` names the lowest plan that includes it, and `upgrade_url` says where to get it. - `message` is a full sentence the agent can relay as it is: the endpoint needs an API key, Free plan or higher. - The right reaction is to tell the user, not to retry. Retrying a `plan_required` error never succeeds. [Live holders reference](https://docs.crius.sh/reference/holders/live-holders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20plan%20error%20with%20the%20fix%20in%20it&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fai-agents%2F%23plan-error%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Check freshness first Example [Anonymous · no key · free](https://docs.crius.sh/reference/chain/service-status/) ### Index status before a real-time answer Is the Robinhood Chain index live, and how far behind the chain is it? GET/v1/status **cURL** ```bash curl "https://api.crius.sh/v1/status" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/status"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/status", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 21 lines (arrays trimmed)** ```json { "data": { "chains": { "robinhood": { "addresses": 29509881, "block_age_ms": 1203, "chain_id": 4663, "finalized_block": 100397649, "indexed_block": 100406757, "lag_ms": 50, "pools": 2780862, "safe_block": 100401329, "start_block": 0, "status": "live", "tokens": 2406786 } }, "region": "rigel", "version": "0.1.0" } } ``` What this tells you - `chains.robinhood.status: "live"`: the index is following the chain head. Other values are `catching_up`, `stalled` and `starting`. - `indexed_block: 100406757` with `lag_ms: 50`: the index was 50 ms behind the chain head when this was captured. - `tokens: 2406786`, `pools: 2780862` and `addresses: 29509881` are indexed, from `start_block: 0`. - An agent that sees anything but `live` should say its answer may be behind, and link [status.crius.sh](https://status.crius.sh). [Service status reference](https://docs.crius.sh/reference/chain/service-status/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Index%20status%20before%20a%20real-time%20answer&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fai-agents%2F%23status%0ARequest%3A%20GET%20%2Fv1%2Fstatus%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```json { "name": "robinhood_token_security", "description": "Safety check for a Robinhood Chain token: score 0-100, risk level, honeypot, buy and sell tax, owner powers, LP lock. Call it before saying whether a token is safe. Needs the token's 0x address (use robinhood_search first if you only have a name).", "parameters": { "type": "object", "properties": { "address": { "type": "string", "pattern": "^0x[0-9a-fA-F]{40}$", "description": "Token contract address" } }, "required": ["address"] } } ``` The tool calls `GET https://api.crius.sh/v1/robinhood/token/{address}/security` and returns `data` and `meta.block` to the model. More on prompts, the docs files for models and key setup is in [Use the Crius API from AI agents](https://docs.crius.sh/guides/use-crius-with-ai-agents/) and [For AI agents & LLMs](https://docs.crius.sh/ai/). ## Frequently asked questions **Can an AI assistant call the Crius API without an API key?** Yes. Search, token profiles, prices, candles, trades, pools, the security check and chain stats are on the anonymous plan at 2 requests per second per IP. Give a production agent its own key with only the `read` scope for higher limits and the Free or paid endpoints. **Is there an OpenAPI spec for the Crius API?** Yes, at `https://api.crius.sh/openapi.json`. It lists every endpoint and parameter, so you can generate tool or function definitions from it. The docs are available to models as `llms.txt`, `llms-full.txt` and a Markdown version of every page. **How should an agent handle rate limits and plan errors?** Read `error.code`. On `rate_limited` wait `retry_after_ms` and retry; on `quota_exceeded` stop; on `plan_required` tell the user which plan the endpoint needs (`required_plan`) instead of retrying. Messages are written to be shown to people as they are. **How can an agent show where its numbers come from?** Every response has `meta.block` and `meta.block_ts`. Have the agent quote the block (for example "as of block 100406772") and link the token's address on an explorer, so a user can check the answer. ## Related [Guide **AI agents** Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips. Read](https://docs.crius.sh/guides/use-crius-with-ai-agents/) [Docs **For AI agents & LLMs** How AI assistants and agents can read the Crius documentation (llms.txt, llms-full.txt, Markdown pages) and call the Crius API (OpenAPI document, anonymous endpoints). Read](https://docs.crius.sh/ai/) [Guide **Get token data** Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed. Read](https://docs.crius.sh/guides/get-token-data/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Docs **Errors** Crius API error format, HTTP status codes and every error code with its meaning and what to do about it. Read](https://docs.crius.sh/errors/) --- # Robinhood Chain API for analytics dashboards > Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts. Source: https://docs.crius.sh/use-cases/analytics-dashboards/ · Updated 2026-10-28 An analytics dashboard answers “how is Robinhood Chain doing”: DEX volume and trades, active traders, TVL and locked liquidity, launches and graduations per launchpad, gas costs and block times, and charts for single tokens. The Crius API serves these as aggregates computed from its own index of every block, so a dashboard needs a few calls a minute instead of an indexer and a data warehouse. Organic and wash volume are reported separately, so headline numbers aren’t inflated by same-transaction round trips. ## Endpoints a dashboard uses - [GET`/stats`](https://docs.crius.sh/reference/chain/chain-stats/) chain-wide numbers over `1h`, `24h` or `7d`: volume and trades per DEX, traders, TVL and locked LP, launches and graduations per launchpad, new pools and tokens, gas and block times, reorgs. - [GET`/volume`](https://docs.crius.sh/reference/chain/volume-history/) daily and hourly volume rows, rolling windows from `1s` to `180d` with change versus the previous window, and weekday × hour patterns. - [GET`/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) each launchpad’s launches, graduations, graduation rate, traders, volume by quote asset and fees. - [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) price and volume charts for any token, from `1s` to `1d`. - [GET`/token/{address}/holders/history`](https://docs.crius.sh/reference/holders/holder-count-history/) holder count over time for a token, with your own holder definition (`min_usd` or `min_balance`). - [GET`/hooks`](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) Uniswap v4 hooks ranked by pools or volume, with their risk level. ## Suggested architecture 1. **Poll chain-wide numbers once a minute.** `/stats`, `/volume` and `/launchpads` cost 1 credit each. Refreshing all three every minute is 4,320 credits a day, about 130,000 a month: a Free plan covers it. 2. **Store your own time series.** `/stats` is a rolling window. To draw a TVL or locked-LP line over months, save each refresh with `meta.block` and `meta.block_ts`. Daily volume history comes ready-made from `/volume`. 3. **Use `tz` for daily charts.** `/volume?tz=America/New_York` puts day boundaries at local midnight; the default is UTC. 4. **Load token charts on demand.** Candles cost 2 credits per call (up to 1,500 candles). Cache each token’s closed candles and fetch only the newest ones on refresh. 5. **Show organic volume first.** Lead with `volume_usd`, and show `wash_volume_usd` next to it so readers see how much activity was round trips. ## The chain in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/chain-stats/) ### Robinhood Chain over 24 hours How much did Robinhood Chain trade in the last 24 hours, and how much of it was wash trading? GET/v1/robinhood/stats?window=24h **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=24h" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=24h"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=24h", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 100 lines (arrays trimmed)** ```json { "data": { "blocks": { "active_wallets": 194641, "avg_block_time_ms": 101, "tps_1m": 44.6833, "txs": 2430221 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 114839, "pons_curve": 6920073, "uniswap_v2": 6992610, "uniswap_v3": 235116790, "uniswap_v4": 286137338 }, "traders": 148079, "trades": 1769098, "volume_usd": 535281650, "wash_volume_usd": 100833980 }, "eth_usd": 2355.49, "finalized_block": 100397649, "gas": { "avg_swap_cost_eth": 0.00000791235, "avg_swap_cost_usd": 0.0186374, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021042 }, "head_block": 100406547, "l1_block": 26294099, "launchpads": [ { "graduated": 16, "launches": 1780, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 25485280 }, { "graduated": 0, "launches": 508, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 10784246 }, { "graduated": 0, "launches": 20, "launchpad": "bankr", "launchpad_name": "Bankr", "volume_usd": 595435 } ], "liquidity": { "locked_lp_usd": 44712347, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322714989 }, "pools": { "by_dex": { "launch_curve": 1201, "pons_curve": 1780, "uniswap_v2": 1483, "uniswap_v3": 224, "uniswap_v4": 5457 }, "new": 10145 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100401329, "tokens": { "by_attribution": { "known_launchpad": 3527, "other": 4095 }, "new": 7622, "new_1h": 418 }, "window": "24h" }, "meta": { "block": 100406547, "block_age_ms": 1026, "block_ts": 1793225052000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100397649, "lag_ms": 26, "safe_block": 100401329 } } ``` What this tells you - `dex.volume_usd: 535281650` from `dex.trades: 1769098` by 148,079 traders; `dex.wash_volume_usd: 100833980` of round trips is reported apart from it. - Per DEX (`dex.by_dex`): Uniswap v4 $286,137,338, Uniswap v3 $235,116,790, Uniswap v2 $6,992,610, the Pons curve $6,920,073. - `liquidity.tvl_usd: 322714989`, of which `locked_lp_usd: 44712347` sits in LP lockers (`method`: 2 × the quote side of every pool, v3/v4 in range). - `launchpads`: Pons had 1,780 launches and 16 graduations, Long.xyz 508 launches, Bankr 20. - `blocks.avg_block_time_ms: 101`, `gas.avg_swap_cost_usd: 0.0186374` and `reorgs.count: 0`: blocks every ~100 ms, swaps under two cents, no reorgs in the window. [Chain stats reference](https://docs.crius.sh/reference/chain/chain-stats/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Robinhood%20Chain%20over%2024%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fanalytics-dashboards%2F%23chain-24h%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fstats%3Fwindow%3D24h%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Volume history and patterns Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/chain/volume-history/) ### Three days of volume and the busiest hours What were the last three days of Robinhood Chain DEX volume, and when is the chain busiest? GET/v1/robinhood/volume?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/volume?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/volume?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/volume?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 334 lines (arrays trimmed)** ```json { "data": { "as_of_ts": 1793225074000, "by_hour": { "lookback_days": 90, "peak_hour": 14, "quietest_hour": 4, "rows": [ { "avg_trades": 171529, "avg_volume_usd": 37907414, "days_counted": 89, "hour": 0, "share_pct": 3.69344 }, { "avg_trades": 160908, "avg_volume_usd": 37815486, "days_counted": 89, "hour": 1, "share_pct": 3.68448 }, { "avg_trades": 154787, "avg_volume_usd": 36420348, "days_counted": 89, "hour": 2, "share_pct": 3.54855 } ] }, "by_weekday": { "lookback_days": 90, "peak_day": "wednesday", "quietest_day": "saturday", "rows": [ { "avg_trades": 4116146, "avg_volume_usd": 1013038326, "day": "monday", "days_counted": 13, "share_pct": 14.4174, "total_volume_usd": 13169498233 }, { "avg_trades": 4180257, "avg_volume_usd": 1002030520, "day": "tuesday", "days_counted": 13, "share_pct": 14.2607, "total_volume_usd": 13026396763 }, { "avg_trades": 4330613, "avg_volume_usd": 1440396094, "day": "wednesday", "days_counted": 12, "share_pct": 18.9226, "total_volume_usd": 17284753124 } ] }, "chain": "robinhood", "daily": { "busiest_day": { "ts": 1792972800000, "volume_usd": 556198238 }, "days": 3, "rows": [ { "buy_volume_usd": 247729766, "sell_volume_usd": 218992798, "trades": 1389513, "ts": 1792886400000, "volume_usd": 466722564, "wash_volume_usd": 50319274 }, { "buy_volume_usd": 286515806, "sell_volume_usd": 269682432, "trades": 1621146, "ts": 1792972800000, "volume_usd": 556198238, "wash_volume_usd": 50493821 }, { "buy_volume_usd": 237548924, "sell_volume_usd": 204145666, "trades": 1521812, "ts": 1793059200000, "volume_usd": 441694590, "wash_volume_usd": 50553407 } ] }, "hourly": { "busiest_hour": { "ts": 1793210400000, "volume_usd": 60323335 }, "hours": 48, "rows": [ { "buy_volume_usd": 6716118, "sell_volume_usd": 6323281, "trades": 53655, "ts": 1793052000000, "volume_usd": 13039399, "wash_volume_usd": 105689 }, { "buy_volume_usd": 9419407, "sell_volume_usd": 7621334, "trades": 59499, "ts": 1793055600000, "volume_usd": 17040740, "wash_volume_usd": 12295.4 }, { "buy_volume_usd": 8410243, "sell_volume_usd": 7053796, "trades": 60264, "ts": 1793059200000, "volume_usd": 15464040, "wash_volume_usd": 75408.9 } ] }, "method": { "caught_up": true, "data_since_ts": 1779484440000, "live": "windows up to 1h from the live trade flow (chain time); longer windows from complete minutes plus the live flow", "outliers": "excluded: single trades valued above $25000000 (mispriced quotes), counted in outlier_trades", "table_through_ts": 1793224500000, "volume": "organic DEX volume in USD at trade time (Uniswap V2/V3/V4, launchpad curves)", "wash": "excluded: same-tx round trips — buys and sells of one token in one pool inside one tx that cancel within 2%" }, "tz": "UTC", "windows": { "180d": { "buy_volume_usd": 54358559462, "buys": 253826654, "change_pct": null, "complete": false, "outlier_trades": 762, "prev_volume_usd": null, "sell_volume_usd": 52435524640, "sells": 204573895, "tokens": 1738934, "traders": 8246046, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 458400549, "volume_usd": 106794084102, "wash_trades": 1140815, "wash_volume_usd": 43228252019 }, "1h": { "buy_volume_usd": 13832591, "buys": 73433, "change_pct": -12.0881, "complete": true, "outlier_trades": 0, "prev_volume_usd": 31025009, "sell_volume_usd": 13442088, "sells": 75039, "tokens": 1747, "traders": 20684, "trades": 148472, "volume_usd": 27274679, "wash_trades": 27, "wash_volume_usd": 2621.56 }, "1m": { "buy_volume_usd": 437276, "buys": 2297, "change_pct": -6.49047, "complete": true, "outlier_trades": 0, "prev_volume_usd": 912411, "sell_volume_usd": 415915, "sells": 2293, "tokens": 181, "traders": 1326, "trades": 4590, "volume_usd": 853191, "wash_trades": 0, "wash_volume_usd": 0 }, "1s": { "buy_volume_usd": 3078.99, "buys": 36, "change_pct": -50.5284, "complete": true, "outlier_trades": 0, "prev_volume_usd": 22701.8, "sell_volume_usd": 8151.96, "sells": 52, "tokens": 21, "traders": 49, "trades": 88, "volume_usd": 11230.9, "wash_trades": 0, "wash_volume_usd": 0 }, "24h": { "buy_volume_usd": 286730820, "buys": 902381, "change_pct": 20.2008, "complete": true, "outlier_trades": 0, "prev_volume_usd": 445610023, "sell_volume_usd": 248895996, "sells": 868651, "tokens": 13008, "traders": 153221, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 1771032, "volume_usd": 535626816, "wash_trades": 17601, "wash_volume_usd": 100833980 }, "30d": { "buy_volume_usd": 12247569095, "buys": 34846699, "change_pct": -51.5393, "complete": true, "outlier_trades": 69, "prev_volume_usd": 48875200678, "sell_volume_usd": 11437699166, "sells": 31074225, "tokens": 291323, "traders": 2263899, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 65920924, "volume_usd": 23685268262, "wash_trades": 296158, "wash_volume_usd": 5483273594 }, "30s": { "buy_volume_usd": 185288, "buys": 1118, "change_pct": -25.6305, "complete": true, "outlier_trades": 0, "prev_volume_usd": 489301, "sell_volume_usd": 178603, "sells": 1202, "tokens": 124, "traders": 790, "trades": 2320, "volume_usd": 363891, "wash_trades": 0, "wash_volume_usd": 0 }, "5m": { "buy_volume_usd": 1526559, "buys": 7394, "change_pct": 45.1834, "complete": true, "outlier_trades": 0, "prev_volume_usd": 2700471, "sell_volume_usd": 2394075, "sells": 9124, "tokens": 464, "traders": 4438, "trades": 16518, "volume_usd": 3920634, "wash_trades": 0, "wash_volume_usd": 0 }, "6h": { "buy_volume_usd": 105598591, "buys": 321121, "change_pct": 52.3693, "complete": true, "outlier_trades": 0, "prev_volume_usd": 133649465, "sell_volume_usd": 98042204, "sells": 329945, "tokens": 5441, "traders": 63519, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 651066, "volume_usd": 203640796, "wash_trades": 541, "wash_volume_usd": 359759 }, "7d": { "buy_volume_usd": 1909691103, "buys": 5753033, "change_pct": -31.3766, "complete": true, "outlier_trades": 0, "prev_volume_usd": 5322350520, "sell_volume_usd": 1742687772, "sells": 5560924, "tokens": 58647, "traders": 500833, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 11313957, "volume_usd": 3652378875, "wash_trades": 66125, "wash_volume_usd": 453119545 }, "90d": { "buy_volume_usd": 46760389080, "buys": 208523175, "change_pct": null, "complete": true, "outlier_trades": 343, "prev_volume_usd": null, "sell_volume_usd": 45143857321, "sells": 166892984, "tokens": 1441104, "traders": 7052878, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 375416159, "volume_usd": 91904246401, "wash_trades": 953623, "wash_volume_usd": 41341982607 } } }, "meta": { "block": 100406767, "block_age_ms": 1146, "block_ts": 1793225074000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 3, "safe_block": 100401329 } } ``` What this tells you - `daily.rows` has one row per day with `volume_usd`, buy and sell volume, `trades` and `wash_volume_usd`; the busiest of the three was $556,198,238 (`daily.busiest_day`). - `by_hour.peak_hour: 14` and `quietest_hour: 4` over 90 days (`lookback_days`), in the response’s `tz` (UTC here). - `by_weekday.peak_day: "wednesday"` and `quietest_day: "saturday"`. - `windows["24h"]` gives `volume_usd: 535626816` with `change_pct: 20.2008` versus the previous 24 hours; `windows["30d"]` shows 65,920,924 trades. - `method` documents every rule: what counts as volume, what is wash (`same-tx round trips`), and the $25,000,000 outlier cut. [Volume history reference](https://docs.crius.sh/reference/chain/volume-history/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20days%20of%20volume%20and%20the%20busiest%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fanalytics-dashboards%2F%23volume-history%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fvolume%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```python import requests, time API = "https://api.crius.sh/v1/robinhood" def snapshot(): s = requests.get(f"{API}/stats", params={"window": "24h"}).json() d = s["data"] return { "block": s["meta"]["block"], "ts": s["meta"]["block_ts"], "volume_usd": d["dex"]["volume_usd"], "wash_volume_usd": d["dex"]["wash_volume_usd"], "tvl_usd": d["liquidity"]["tvl_usd"], "locked_lp_usd": d["liquidity"]["locked_lp_usd"], "launches": {l["launchpad"]: l["launches"] for l in d["launchpads"]}, } while True: row = snapshot() print(row) # write it to your own table to chart TVL over time time.sleep(60) ``` A full walk-through is in [Build a chain stats dashboard](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/); launchpad panels are covered in [Get launchpad stats](https://docs.crius.sh/guides/get-launchpad-stats/), and per-token charts in [OHLCV candles](https://docs.crius.sh/guides/get-ohlcv-candles/) and [Track holder count](https://docs.crius.sh/guides/track-holder-count/). ## Frequently asked questions **Does Crius volume include wash trading?** No. `volume_usd` is organic DEX volume; same-transaction round trips (buys and sells of one token in one pool inside one transaction that cancel within 2%) are counted separately as `wash_volume_usd`. Single trades valued above $25,000,000 (mispriced quotes) are left out and counted in `outlier_trades`. **Can I get Robinhood Chain volume per day or per hour?** Yes. `/volume` returns daily rows (`days`) and hourly rows, a busiest day and hour, rolling windows from `1s` to `180d`, and a weekday × hour pattern. `tz` sets the time zone, so days start at your local midnight. **How is TVL measured on Robinhood Chain?** `liquidity.tvl_usd` on `/stats` is 2 × the quote side (ETH, WETH or USDG) of every pool, with only in-range liquidity counted for Uniswap v3 and v4. `locked_lp_usd` is the part of it held by LP lockers. **Which plan does a dashboard need?** Chain stats, volume history, launchpads, candles and token lists are on the anonymous plan at 1 or 2 credits per call. Holder count history (10 credits) needs Starter. A backend refreshing a few chain-wide calls every minute stays on the Free plan. ## Related [Guide **Chain stats dashboard** Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code. Read](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Holder count history** Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example. Read](https://docs.crius.sh/guides/track-holder-count/) [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [API reference **Chain stats & status** Chain-wide Robinhood Chain numbers (volume, trades, TVL, launches, gas) and the API's own health and supported chains. Read](https://docs.crius.sh/reference/chain/) --- # Robinhood Chain API for launchpad and DEX builders > How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain. Source: https://docs.crius.sh/use-cases/launchpad-and-dex-builders/ · Updated 2026-10-28 Teams that run a launchpad, a DEX front end, an aggregator or a Uniswap v4 hook on Robinhood Chain need the same data their users ask about: where each token is in its lifecycle, how the launchpad compares with others, what fees creators earn, whether a hook has a clean record, and the live state of every pool. The Crius API already decodes every launchpad event, curve, Uniswap pool and hook on the chain, so a team can build token pages, creator dashboards and analytics without writing and running its own indexer. ## Endpoints builders use - [GET`/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) every supported launchpad with live stats: tokens launched, graduations, graduation rate, median blocks to graduate, traders, volume by quote asset, fees. - [GET`/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) one token’s launch: creator, curve, progress, raised amount, fee settings, graduation block and the pool it graduated into. - [GET`/token/{address}/fees`](https://docs.crius.sh/reference/launchpads/fees-claims/) fees around a token over a window (LP, hook, creator, protocol, gas) and who received and claimed them. - [GET`/hooks`](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) every v4 hook with pool count, volume, risk level and flags; filter by `launchpad`, `verified` or `risk_level`. - [GET`/hook/{address}`](https://docs.crius.sh/reference/pools/hook-detail/) one hook’s permissions, code, observed outcomes in its pools, code family and events. - [GET`/pool/{pool}`](https://docs.crius.sh/reference/pools/pool-detail/) one pool’s tokens, reserves, in-range liquidity, fee, hook, price, TVL and LP lock. - [Token lists](https://docs.crius.sh/reference/discovery/token-lists/) with `launchpad=` for your own tokens, and the `launches:`, `graduations:` and `pools:new` [stream channels](https://docs.crius.sh/reference/stream/). ## Suggested architecture 1. **Token pages from the lifecycle.** `/token/{address}/launch` (Free, 2 credits) gives the curve, progress and graduation; `/token/{address}` (1 credit) the market. Cache bonding tokens briefly and graduated ones longer: their curve and graduation no longer change. 2. **Live progress from the stream.** Subscribe to `launches:` and `graduations:`, and to `trades:` for the tokens on screen, instead of polling every curve. 3. **Creator dashboards from fees.** `/token/{address}/fees` (Starter, 5 credits) per token, per window. Group tokens by creator with the [developer profile](https://docs.crius.sh/reference/wallets/developer-profile/). 4. **Compare launchpads daily.** `/launchpads` is 1 credit for all of them; `/launchpads/pons` (one launchpad by id) adds 30 days of daily history. 5. **Hook teams: watch your reputation.** `/hook/{address}` (2 credits) shows what Crius sees in your pools, including `observed.honeypot_pools`, `liquidity_pulled_pools` and measured taxes. That’s what wallets and bots read before trading through your hook. ## Launchpads side by side Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/launchpads/launchpads/) ### Pons, Flap.sh and Bankr over 24 hours How do Robinhood Chain's launchpads compare on launches, graduations and volume? GET/v1/robinhood/launchpads **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 122 lines (arrays trimmed)** ```json { "data": [ { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 109888, "tax": 139840, "total": 249728 }, "graduated": 10479, "graduated_24h": 16, "graduation_rate_pct": 1.46306, "launches_24h": 1781, "median_blocks_to_graduate": 2490, "tokens_launched": 716241, "traders_24h": 54793, "trades_24h": 282607, "volume_by_quote_usd_24h": { "eth": 13311920, "other": 1629236, "stock": 3076503, "usdg": 7488610 }, "volume_usd_24h": 25506268 }, "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, { "contracts": { "launch_contracts": [ "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" ] }, "id": "flap", "name": "Flap.sh", "since_block": 4227932, "stats": { "fees_usd_24h": { "lp": 2011.32, "tax": 7332.7, "total": 9344.02 }, "graduated": 338, "graduated_24h": 1, "graduation_rate_pct": 0.0872587, "launches_24h": 1200, "median_blocks_to_graduate": 8533, "tokens_launched": 387354, "traders_24h": 3257, "trades_24h": 7870, "volume_by_quote_usd_24h": { "eth": 364111, "other": 16.2147, "stock": 5051.86, "usdg": 11553.7 }, "volume_usd_24h": 380733 }, "type": "config_driven", "website": "https://flap.sh" }, { "contracts": { "launch_contracts": [ "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" ] }, "id": "bankr", "name": "Bankr", "since_block": 1565844, "stats": { "fees_usd_24h": { "lp": 5006.22, "tax": 12930.7, "total": 17937 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 20, "median_blocks_to_graduate": null, "tokens_launched": 98672, "traders_24h": 1966, "trades_24h": 7282, "volume_by_quote_usd_24h": { "eth": 220967, "other": 25109.3, "stock": 262823, "usdg": 86535.8 }, "volume_usd_24h": 595435 }, "type": "config_driven", "website": "https://bankr.bot" } ], "meta": { "block": 100406698, "block_age_ms": 1356, "block_ts": 1793225067000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 202, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100401329 } } ``` What this tells you - Pons (`type: "bonding_curve_to_v4"`): `tokens_launched: 716241`, `graduated: 10479`, so `graduation_rate_pct: 1.46306`. In 24 hours: 1,781 launches, 16 graduations, `volume_usd_24h: 25506268` from 54,793 traders. - Pons tokens that graduate take a median of 2,490 blocks (`median_blocks_to_graduate`), about four minutes at ~100 ms a block. - Pons volume by quote asset (`volume_by_quote_usd_24h`): $13,311,920 in ETH, $7,488,610 in USDG and $3,076,503 against tokenized stocks. - Flap.sh: `tokens_launched: 387354` and `graduated: 338` (`graduation_rate_pct: 0.0872587`). Bankr: 98,672 launched, `graduated: 0`. - `contracts` lists each launchpad’s addresses, e.g. the Pons factory `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e`, hook `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` and LP locker `0x267444d099b10fb5ed7c3cc7b7c767adca574952`. [Launchpads reference](https://docs.crius.sh/reference/launchpads/launchpads/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Pons%2C%20Flap.sh%20and%20Bankr%20over%2024%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Flaunchpad-and-dex-builders%2F%23launchpads%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## One token’s launch Example [Free plan · 2 credits](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) ### CHARGE: from Pons curve to v4 pool in about two hours How did Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) launch and graduate, and what fees does it pay? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 74 lines (arrays trimmed)** ```json { "data": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_stats": { "buys": 482, "first_indexed_block": 88385895, "history": "complete", "sells": 280, "unique_traders": 61, "volume_quote": 21.053399701262936019 }, "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fees": { "buyback_burn_bps": 5000, "buyback_enabled": false, "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "creator_fee_recipient": "0x14a6f00bad1f4e21e2af4e317383c3d550378996", "creator_tax_bps": 200, "escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook_fee_bps": 100, "pending": { "buyback": 0, "creator_tax": 0.0010373586867571, "currency": "ETH", "fees": 0.000518679343378549 }, "protocol_fee_recipient": "0x31ea5b453a6cd60f36203830de046ff32dec2cdb", "protocol_fee_share_bps": 3000, "snipe_tax": { "start_bps": 9900, "window_s": 3 } }, "graduation": { "block": 88461321, "blocks_to_graduate": 75435, "graduated_block_recorded": 88461321, "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "lp_position_id": 3790055, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_to_pool": 4.200000000000000236, "tokens_to_pool": 204081632.653061227766208523, "ts": 1791990423100 }, "launch_tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747", "launched_block": 88385886, "launched_ts": 1791982833600, "launched_via": "factory", "launchpad": "pons", "launchpad_name": "Pons", "pair_token": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "progress": { "pct": 100, "raised": 4.200000000000000236, "threshold": 4.2 }, "status": "graduated", "version": "v2" }, "meta": { "block": 100406852, "block_age_ms": 778, "block_ts": 1793225083000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 86, "safe_block": 100401329 } } ``` What this tells you - Launched at block 88385886 and graduated at block 88461321: `graduation.blocks_to_graduate: 75435`, about two hours by the timestamps. - `progress`: `raised: 4.2` ETH against `threshold: 4.2`. At graduation 4.2 ETH (`quote_to_pool`) and 204,081,632.65 tokens (`tokens_to_pool`) went into the v4 pool `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`, with the LP position 3790055 in the Pons locker. - On the curve: `curve_stats` shows 482 buys, 280 sells and 61 unique traders. - `fees`: `creator_tax_bps: 200` (2% to the creator), `hook_fee_bps: 100`, and a `snipe_tax` starting at 9,900 bps (99%) for the first 3 seconds (`window_s: 3`). - `fees.pending` holds what is waiting to be swept, in ETH: `creator_tax: 0.0010373586867571`. [Launch lifecycle reference](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE%3A%20from%20Pons%20curve%20to%20v4%20pool%20in%20about%20two%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Flaunchpad-and-dex-builders%2F%23launch%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Flaunch%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // A launchpad token page: lifecycle plus market, refreshed by the stream (Free key). const API = "https://api.crius.sh/v1/robinhood"; const headers = { "x-api-key": process.env.CRIUS_API_KEY }; async function tokenPage(token) { const [launch, profile] = await Promise.all([ fetch(`${API}/token/${token}/launch`, { headers }).then((r) => r.json()), fetch(`${API}/token/${token}`, { headers }).then((r) => r.json()), ]); const l = launch.data; return { name: profile.data.name, status: l?.status ?? "not a launchpad token", progress: l ? `${l.progress.raised} / ${l.progress.threshold} ${l.pair_token.symbol}` : null, pool: l?.graduation?.pool ?? null, marketCap: profile.data.market.market_cap_usd, }; } ``` How launchpads work on Robinhood Chain is on the [Launchpads concept page](https://docs.crius.sh/concepts/launchpads/), pool and hook mechanics on [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/). For hooks, start with [Check the risk of a Uniswap v4 hook](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). ## Frequently asked questions **How do I get my launchpad attributed by Crius?** Email [support@crius.sh](mailto:support@crius.sh) with your factory, curve, hook and locker contract addresses and a link to your docs. Until a factory is attributed, its tokens show a `creation.attribution` other than `known_launchpad`, and `/launch` returns `data: null` with `meta.attribution = "unattributed_factory"`. **Does Crius index custom Uniswap v4 hooks?** Yes, every v4 hook on Robinhood Chain. Each is inspected and re-inspected every 30 minutes: permissions decoded from its address, its code and owner, what happened in its pools (honeypots, liquidity pulled, taxes) and its code family's history. **Can I stream new pools and launches?** Yes. On the WebSocket stream, `pools:new` pushes every new Uniswap v2, v3 and v4 pool with its hook permissions, `launches:` every new launch and `graduations:` every graduation with the new pool. **How are launchpad fees measured?** `fees_usd_24h.lp` is LP fees at each pool's fee (for v4, the swap's own fee). `tax` is token and hook taxes measured from trades. Taxes a hook takes in the quote currency on sells are not measured yet, as `meta.notes` says. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Get fees & creator rewards** See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response. Read](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) --- # Robinhood Chain API for risk and compliance > Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks. Source: https://docs.crius.sh/use-cases/risk-and-compliance/ · Updated 2026-10-28 Risk teams on Robinhood Chain (exchanges and launchpads deciding what to list, wallets deciding what to warn about, trust-and-safety teams and researchers investigating a rug) need the same answers again and again: can this token be sold, who bought its launch, who funded those wallets, what has this developer launched before, and can the liquidity be pulled. The Crius API answers each with one call and returns the evidence (wallets, blocks, shares of supply), so a decision can be explained and checked later. ## Endpoints a risk review uses - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) the first gate for every token: honeypot, realized taxes, owner powers, LP status, hook risk, and launch flags such as `insider_launch` and `wallet_farm`. - [GET`/token/{address}/bundles`](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) who bought the first blocks, bundled buys, funding clusters and how much of the supply they still hold. - [GET`/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/) the creator’s track record: tokens launched, graduated, rugged, peak market caps. - [GET`/wallet/{address}/connections`](https://docs.crius.sh/reference/wallets/wallet-connections/) who funded a wallet, who it funded and which wallets share a funder. - [GET`/token/{address}/bubblemap`](https://docs.crius.sh/reference/wallet-graph/bubble-map/) funding and transfer links among the top holders, with infrastructure set aside. - [GET`/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) every LP position: burned, locked (which locker, until when) or held by a wallet that can pull it. ## Suggested architecture 1. **Gate everything cheaply.** Run `/security` (1 credit) on every token you might list or show. Reject `critical`; send `high` and anything with launch flags to review. 2. **Review in depth only what passes the gate.** A full review costs about 31 credits a token: liquidity (5), bundles (10), bubble map (10), developer profile (5) and the security check (1). Bundles, bubble maps and wallet connections need a Starter key. 3. **Follow the money for the wallets that matter.** For the dev and the top snipers, call `/wallet/{address}/connections` (10 credits) to see who funded them and who else that funder paid. 4. **Keep the evidence.** Save each response with its `meta.block`. For decisions that must not be reversed by a reorg, use data whose block is at or below `meta.safe_block`. 5. **Re-check on change.** Taxes, LP and holder concentration change after launch. Subscribe to `tax:` and `lp:` on the [stream](https://docs.crius.sh/reference/stream/), or re-run the gate on a schedule. ## Who bought the launch Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) ### An insider launch: four wallets took 61% of the supply Rebot (0x192b126efea71ca5e7767bc6fc53038d869fbbba) fell 97% within hours. Who bought its first blocks? GET/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 99 lines (arrays trimmed)** ```json { "data": { "bundle_supply_pct": 1, "bundle_supply_pct_now": 0, "bundled": true, "bundles": [ { "block": 100238938, "bought": 10000000.000000000905969664, "cost_eth": 0.0174316, "funder": null, "id": "b_1", "still_holding_pct": 0, "supply_pct": 1, "type": "launch_tx_buy", "wallets": [ "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864" ] } ], "clusters": [], "dev": { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "bought_in_launch_tx": true, "first_buy_pct": 1, "funded_by": null, "holding_pct": 0 }, "early_buyers_analyzed": 54, "insider_launch": true, "launch": { "flags": [ "insider_launch" ], "lp_top_wallet": { "address": "0x6e8244ba97cbb7d136aafc667e8da302140dbc5b", "liquidity_usd": 5.70259, "pct": 0.0996139 }, "sniper_supply_pct": 60.9726, "sniper_top_wallet_pct": 53.1794, "sniper_wallets": 4, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "snipers": { "count": 4, "still_holding_pct": 0, "supply_pct": 60.9726, "wallets": [ { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "tags": [ "dev", "sniper" ] }, { "address": "0x0f0bb85fddc70f04344bc7704bb940e387ae7762", "tags": [ "sniper" ] }, { "address": "0x5051e45b2dbecf1b2041af3937bd85fc0dc43cd4", "tags": [ "sniper" ] }, { "address": "0x217be8970fa83b0864ca06d3c18ea6d9ac04e3a5", "tags": [ "sniper" ] } ], "window_blocks": 10 }, "trader_funding": { "bridge": 18, "dev_linked": 1, "other_wallets": 21, "protocol": 3, "unknown": 6, "unlabeled_hub": 5 } }, "meta": { "block": 100406882, "block_age_ms": 1103, "block_ts": 1793225086000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 134, "safe_block": 100401329, "scope": "first 300 blocks of trading" } } ``` What this tells you - `insider_launch: true`: `snipers.count: 4` wallets bought `supply_pct: 60.9726` of the supply in the first 10 blocks (`window_blocks: 10`), and one of them took 53.1794% (`launch.sniper_top_wallet_pct`). - The first sniper, `0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864`, is tagged `dev` and `sniper`: the developer bought in its own launch transaction (`dev.bought_in_launch_tx: true`, bundle type `launch_tx_buy`, 1% of supply). - `snipers.still_holding_pct: 0` and `dev.holding_pct: 0`: every sniper has sold. The supply went to the buyers who came after. - `trader_funding` shows where the early traders’ ETH came from: 18 from a bridge, 21 from other wallets, 5 from unlabeled hubs, 1 linked to the dev. - `meta.scope: "first 300 blocks of trading"`: the analysis covers the launch window, `early_buyers_analyzed: 54` wallets. [Snipers, bundles & clusters reference](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20An%20insider%20launch%3A%20four%20wallets%20took%2061%25%20of%20the%20supply&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Frisk-and-compliance%2F%23insider-launch%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x192b126efea71ca5e7767bc6fc53038d869fbbba%2Fbundles%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The developer’s record Example [Free plan · 5 credits](https://docs.crius.sh/reference/wallets/developer-profile/) ### A creator with one token, graduated and not rugged What else has CHARGE's creator (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) launched, and how did it end? GET/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 61 lines (arrays trimmed)** ```json { "data": { "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "first_seen_ts": 1792283372000, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "label": "bridge:Relay solver" }, "summary": { "best_ath_market_cap_usd": 68675.8, "by_launchpad": { "pons": 1 }, "graduated": 1, "graduation_rate_pct": 100, "median_ath_market_cap_usd": 68675.8, "rugged": 0, "tokens_created": 1 }, "tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "created_block": 88385886, "created_ts": 1791982834000, "deployed_via": "launchpad", "dev_sold_pct": null, "launchpad": "pons", "launchpad_name": "Pons", "liquidity_usd": 5611.81, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "market_cap_usd": 3773.42, "name": "Charge AI", "rugged": false, "status": "graduated", "symbol": "CHARGE" } ], "top_tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" } ] }, "meta": { "block": 100406874, "block_age_ms": 1212, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 26, "next_cursor": null, "rugged_rule": "market cap < 10% of ATH (ATH > $5k) and liquidity < $500", "safe_block": 100401329 } } ``` What this tells you - `summary.tokens_created: 1`, `graduated: 1`, `rugged: 0`: one Pons launch (`by_launchpad.pons: 1`) that graduated. - `best_ath_market_cap_usd: 68675.8`, while the token’s `market_cap_usd` is now 3773.42. It isn’t counted as rugged because its liquidity (5611.81) is above the $500 in `meta.rugged_rule`. - `funded_by` is a Relay solver (`label: "bridge:Relay solver"`, `amount_eth: 0.008148386337868892`): the creator’s first ETH was bridged in, so there is no earlier wallet to trace. - A serial rugger looks different: many `tokens`, several with `rugged: true`, and a low `graduation_rate_pct`. [Developer profile reference](https://docs.crius.sh/reference/wallets/developer-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20creator%20with%20one%20token%2C%20graduated%20and%20not%20rugged&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Frisk-and-compliance%2F%23dev-record%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fdev%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Two-stage token review: a cheap gate, then the deep checks (Starter key). const API = "https://api.crius.sh/v1/robinhood"; const get = (p) => fetch(API + p, { headers: { "x-api-key": process.env.CRIUS_API_KEY } }).then((r) => r.json()); async function review(token) { const sec = await get(`/token/${token}/security`); if (sec.data.risk === "critical") return { verdict: "reject", why: sec.data.flags, block: sec.meta.block }; const [bundles, liquidity] = await Promise.all([get(`/token/${token}/bundles`), get(`/token/${token}/liquidity`)]); const reasons = []; if (bundles.data.insider_launch) reasons.push(`insider launch: snipers took ${bundles.data.snipers.supply_pct}%`); if (liquidity.data.summary.unlocked_in_wallets_pct > 50) reasons.push("most LP can be withdrawn"); return { verdict: reasons.length ? "review" : "pass", reasons, block: sec.meta.block }; } ``` Each check has its own guide: [snipers and bundles](https://docs.crius.sh/guides/detect-bundles-and-snipers/), [developer history](https://docs.crius.sh/guides/check-developer-history/), [connected wallets](https://docs.crius.sh/guides/find-connected-wallets/), [bubble maps](https://docs.crius.sh/guides/read-a-bubble-map/) and [LP locks](https://docs.crius.sh/guides/check-liquidity-locked/). The score that ties them together is explained in [Token security score](https://docs.crius.sh/guides/token-security-score/). ## Frequently asked questions **How does Crius decide a token was rugged?** A developer's token counts as rugged when its market cap is under 10% of its all-time high (and that high was above $5,000) and its liquidity is under $500. The rule is returned with every developer profile as `meta.rugged_rule`, so your reports can quote it. **Can I show what the data looked like when a decision was made?** Yes. Store `meta.block` with every decision. Holder snapshots (`at=block:…`) and bubble maps (`block=`) can be fetched again for that block later, so a reviewer sees the same holders you did. **Does the Crius API do sanctions or identity screening?** No. It is on-chain analytics: contracts, trades, holders, funding links and launch behaviour on Robinhood Chain. It has no sanctions lists and no identity data; use a dedicated provider for those. **Do exchange and bridge deposits link unrelated wallets?** No. Funding from exchanges, bridges and app relayers (one signer paying the same 100+ wallets again and again) never links wallets into a cluster, and exchange wallets are treated as infrastructure, not holders. ## Related [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Developer history** Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling. Read](https://docs.crius.sh/guides/check-developer-history/) [Guide **Connected wallets** Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils. Read](https://docs.crius.sh/guides/find-connected-wallets/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Check liquidity locks** Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens. Read](https://docs.crius.sh/guides/check-liquidity-locked/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) --- # Robinhood Chain API for Telegram and Discord bots > Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs. Source: https://docs.crius.sh/use-cases/telegram-and-discord-bots/ · Updated 2026-10-28 Community bots are often the first place a Robinhood Chain token gets looked at: someone pastes a contract address into a Telegram group or Discord channel, and the bot replies with price, market cap, holders, the launchpad, the security score and links. Others post every buy of a community’s token, or alert a channel the moment a token launches or graduates. The Crius API answers a scanner reply in two anonymous calls and pushes buys and launches over one WebSocket, so the bot needs no indexer and no RPC node. ## Endpoints a chat bot uses - [GET`/search`](https://docs.crius.sh/reference/discovery/search/) turns a name or symbol into token addresses, and checks whether a pasted address is a token, pool or wallet. - [GET`/token/{address}`](https://docs.crius.sh/reference/tokens/token-profile/) the scanner card: name, price and changes, market cap, liquidity, holders and top-10 share, launchpad status, LP lock and links. - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) the safety line: `score`, `risk`, taxes and honeypot verdict. - [GET`/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) for a `/price` command. - [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) to draw a chart image for a `/chart` command. - [GET`/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) bonding progress for tokens still on a curve. - The [WebSocket stream](https://docs.crius.sh/reference/stream/): `trades:` for a buy bot, `launches:all` and `graduations:all` (or `launches:pons`, …) for alert channels. ## Suggested architecture 1. **Detect an address in the message.** Match `0x` followed by 40 hex characters. Anything else that looks like a ticker goes to `/search`. 2. **Build the card from two calls.** `/token/{address}` and `/token/{address}/security` cost 1 credit each and work without a key. Send them in parallel. 3. **Cache per token for a short time.** In a busy group ten people paste the same token within a minute. A 30-second cache keyed by address answers them all for one pair of calls. 4. **Push, don’t poll, for alerts.** One stream connection (Free key, 1 credit) carries a buy bot’s `trades:` and an alert channel’s `launches:all` and `graduations:all`. Free allows 10 subscriptions per connection, Starter 100. 5. **Rate-limit users, not the API.** Per-user cooldowns keep one member from spending the bot’s credits. A scanner answering 5,000 pastes a day with profile + security uses 10,000 credits a day, about 300,000 a month, within the Free plan. With the 30-second cache, repeated pastes cost nothing. ## Resolve a name to an address Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/search/) ### Three different tokens called CHARGE A user types /scan charge. Which token do they mean? GET/v1/robinhood/search?q=charge&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=charge&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=charge&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=charge&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 73 lines (arrays trimmed)** ```json { "data": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeairh", "website": "https://chargeai.bid/" }, "liquidity_usd": 5611.81, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "name": "Charge AI", "price_usd": 0.00000388948, "symbol": "CHARGE", "type": "token" }, { "address": "0x202e72dcbc815ca222f1a0674dd08755545b1329", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeitdotfun", "website": "https://chargeit.fun/" }, "liquidity_usd": 4869.43, "logo": "https://api.crius.sh/v1/robinhood/logo/0x202e72dcbc815ca222f1a0674dd08755545b1329.png?size=128", "name": "CHARGE", "price_usd": 0.00000293605, "symbol": "CHARGE", "type": "token" }, { "address": "0xc15f9324d2742387f98e2dba6b3745e5390113ec", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeitdotfun", "website": "https://chargeit.fun/" }, "liquidity_usd": 2490.27, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc15f9324d2742387f98e2dba6b3745e5390113ec.png?size=128", "name": "CHARGE", "price_usd": 0.00000683926, "symbol": "CHARGE", "type": "token" } ], "meta": { "block": 100406952, "block_age_ms": 1260, "block_ts": 1793225093000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 11, "safe_block": 100401329 } } ``` What this tells you - Three tokens match, all launched on Pons (`launchpad: "pons"`): Charge AI `0x7b8892cea949bc60d494681d1bc3ea96071ab0b8` and two tokens named CHARGE, `0x202e72dcbc815ca222f1a0674dd08755545b1329` and `0xc15f9324d2742387f98e2dba6b3745e5390113ec`. - All three have the symbol `CHARGE`. Their `liquidity_usd` (5611.81, 4869.43 and 2490.27) and `links` differ, which is what the user needs to tell them apart. - The two CHARGE tokens share the same `twitter` and `website` links (`https://x.com/chargeitdotfun`), so a bot must not assume one link means one token. - Reply with a short list (symbol, name, liquidity and the full address) and scan the one the user picks. [Search reference](https://docs.crius.sh/reference/discovery/search/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Three%20different%20tokens%20called%20CHARGE&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftelegram-and-discord-bots%2F%23search-name%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fsearch%3Fq%3Dcharge%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The scanner card Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-profile/) ### Everything for a Telegram scan reply What should the bot reply when someone pastes 0x7b8892cea949bc60d494681d1bc3ea96071ab0b8? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 320 lines (arrays trimmed)** ```json { "data": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/bundles" }, "burned": 29840058.774195638068253872, "chain_id": 4663, "circulating_supply": 970159941.225804361931746128, "creation": { "attribution": "known_launchpad", "block": 88385886, "deployed_via": "pons_v2", "deployer": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "launchpad_name": "Pons", "tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793040659244, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1791988981764, "orders": [ { "payment_ts": 1791988981764, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": null, "header": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "icon": "https://cdn.dexscreener.com/cms/images/DjTh8_NirbFrIzjW?width=800&height=800&quality=95&format=auto", "links": [ { "label": "Website", "type": "website", "url": "https://chargeai.bid/" }, { "type": "twitter", "url": "https://x.com/chargeairh" } ] }, "url": "https://dexscreener.com/robinhood/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" }, "first_seen_block": 88385886, "history": "complete", "holders": { "burned_pct": 2.98401, "count": 179, "dev_holding": false, "dev_pct": 0, "locked_pct": 8.16327, "top10_pct": 13.436 }, "launch": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "creator_label": null, "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_state": null, "graduated_block": 88461321, "graduation_threshold": 4.2, "launched_block": 88385886, "launchpad": "pons", "launchpad_name": "Pons", "pair_token": "0x0000000000000000000000000000000000000000", "progress_pct": 100, "raised": null, "status": "graduated" }, "liquidity": { "locked_pct": 100, "lockers": [ "pons_v2_launch_locker" ], "next_unlock_ts": null, "permanent": true, "status": "locked" }, "locked": 81632653.061224486519511236, "market": { "fdv_usd": 3889.48, "liquidity_usd": 5611.8, "market_cap_usd": 3773.42, "pools_count": 10, "quote_liquidity_usd": 2805.9 }, "metadata": { "banner": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "description": "hf:charge-ai/charge-30b@9ff2ef1e98ea4d9745a70b33ea02b80dba26c582", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeairh", "website": "https://chargeai.bid/" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "logo_original": "https://api.surplusllm.com/api/launchpad/logos/bb4315cb9506ef872830b1dab25ffdb6694df1b8b8e32cc2c8d083208f26baab.png", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": { "source": "pons_launch", "url": "https://x.com/chargeairh" }, "website": { "source": "pons_launch", "url": "https://chargeai.bid/" } }, "source": "pons_launch", "sources": { "links": "pons_launch", "logo": "pons_launch" } }, "name": "Charge AI", "price": { "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "ath_ts": 1792055400000, "ath_usd": 0.0000707881, "change_pct": { "1h": 0.896103, "1m": 0.896103, "1s": 0.896103, "24h": -0.171971, "30s": 0.896103, "4h": 0.896103, "5m": 0.896103, "6h": 0.896103 }, "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "thin_liquidity": false, "usd": 0.00000388948 }, "security": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 143046, "buys": 2893, "first_trade_ts": 1791982835000, "sell_volume_usd": 137621, "sells": 2250, "since": "chain_start", "trades": 5143, "volume_usd": 280667 }, "avg_trade_usd": { "1h": null, "1m": null, "1s": null, "24h": 2.96366, "30s": null, "4h": null, "5m": null, "6h": null }, "buy_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "last_trade_ts": 1793196204000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "trades": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_eth": { "1h": 0, "1m": 0, "1s": 0, "24h": 0.00252958, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 } }, "symbol": "CHARGE", "total_supply": 1000000000, "type": "launchpad", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": null, "sourcify": null } }, "meta": { "block": 100406769, "block_age_ms": 400, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 38, "pending": [], "safe_block": 100401329 } } ``` What this tells you - Header: `name: "Charge AI"`, `symbol: "CHARGE"`, `launch.launchpad_name: "Pons"` and `launch.status: "graduated"`. - Price line: `price.usd: 0.00000388948`, `price.change_pct["24h"]: -0.171971` and `price.confidence: "medium"`. - Market line: `market.market_cap_usd: 3773.42`, `market.liquidity_usd: 5611.8`. Against `price.ath_market_cap_usd: 68675.8` the token is about 95% below its peak. - Holders line: `holders.count: 179`, `holders.top10_pct: 13.436`, `holders.dev_pct: 0`. - Liquidity line: `liquidity.status: "locked"`, `permanent: true`, locker `pons_v2_launch_locker`. - Links: `metadata.links.website` and `metadata.links.twitter`; `metadata.logo` is an image URL the bot can attach. [Token profile reference](https://docs.crius.sh/reference/tokens/token-profile/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Everything%20for%20a%20Telegram%20scan%20reply&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftelegram-and-discord-bots%2F%23scan-card%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Scanner reply for Telegram (Markdown) from two anonymous calls. const API = "https://api.crius.sh/v1/robinhood"; const cache = new Map(); async function scan(address) { const hit = cache.get(address); if (hit && Date.now() - hit.at < 30_000) return hit.text; const [t, s] = await Promise.all([ fetch(`${API}/token/${address}`).then((r) => r.json()), fetch(`${API}/token/${address}/security`).then((r) => r.json()), ]); if (!t.data) return "Not a token on Robinhood Chain."; const d = t.data, sec = s.data; const text = [ `*${d.name}* (${d.symbol})${d.launch ? ` · ${d.launch.launchpad_name} · ${d.launch.status}` : ""}`, `Price $${d.price?.usd ?? "?"} · 24h ${d.price?.change_pct?.["24h"] ?? "?"}%`, `MC $${d.market.market_cap_usd ?? "?"} · Liq $${d.market.liquidity_usd}`, `Holders ${d.holders.count ?? "?"} · Top 10 ${d.holders.top10_pct}%`, sec ? `Score ${sec.score}/100 (${sec.risk}) · Tax ${sec.tax.buy_pct ?? "?"}% / ${sec.tax.sell_pct ?? "?"}%` : "", `\`${d.address}\``, ].filter(Boolean).join("\n"); cache.set(address, { at: Date.now(), text }); return text; } ``` The full bot, with commands and the buy feed, is in [Build a Telegram token scanner](https://docs.crius.sh/guides/build-a-telegram-token-scanner/). Alert channels are covered in [Get new tokens and graduations in real time](https://docs.crius.sh/guides/stream-new-tokens/) and price commands in [Build price alerts](https://docs.crius.sh/guides/build-price-alerts/). ## Frequently asked questions **Can a Telegram bot use the Crius API without a key?** Yes, for the scanner itself: search, token profile, price, security and candles are on the anonymous plan at 2 requests per second. A bot in busy groups should use a Free key (10 requests per second, 1,000,000 credits a month), which also unlocks the WebSocket stream for buy and launch alerts. **How does a buy bot post every buy of a token?** Subscribe to `trades:` on the WebSocket stream and post messages whose `type` is `buy`, above a minimum `value_usd`. Each message has the attributed `trader`, the amounts and the USD value. A Free key allows one connection with 10 subscriptions. **What should the bot do when several tokens share a symbol?** Show them all. `/search?q=charge` returns three different tokens named CHARGE or Charge AI, with their addresses and liquidity. Let the user pick by address, and treat the contract address as the only identifier. **Is a Discord bot any different?** No. The endpoints and the flow are the same; only the message formatting differs (embeds instead of Markdown). Everything on this page applies to both. ## Related [Guide **Telegram scanner bot** Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples. Read](https://docs.crius.sh/guides/build-a-telegram-token-scanner/) [Guide **Search tokens** Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included. Read](https://docs.crius.sh/guides/search-tokens/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Stream new tokens** Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token. Read](https://docs.crius.sh/guides/stream-new-tokens/) [Guide **Price alerts** Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Read](https://docs.crius.sh/guides/build-price-alerts/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) --- # Robinhood Chain API for token screeners > Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs. Source: https://docs.crius.sh/use-cases/token-screeners/ · Updated 2026-10-28 A token screener is a live table of a chain’s tokens: newest launches, trending tokens, top gainers, tokens about to graduate from a bonding curve, each with price, change, market cap, liquidity, volume and a risk badge. With the Crius API the table comes from one list call per tab, the detail page from a handful of anonymous calls, and the risk badge from the same security check traders use. You don’t need to index Robinhood Chain or decode its launchpads. ## Endpoints a screener uses - [GET`/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) one call per tab: `new`, `bonding`, `graduating`, `graduated`, `trending`, `top_volume`, `top_gainers`, `top_losers`, `top_market_cap`. Filters: `launchpad`, `quote`, `min_liquidity_usd`, `min_volume_usd`, `min_market_cap_usd` / `max_market_cap_usd`, `created_after_ts`, `window` and `clean=true`. - [POST`/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) to refresh the rows a user is watching, trimmed to the fields you show. - [GET`/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) for a watchlist’s prices and 24h change, 100 tokens per call. - [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) for sparklines and the detail chart, with the launch curve merged in. - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) for the risk badge (`risk`, `score`, `flags`). - [GET`/search`](https://docs.crius.sh/reference/discovery/search/) for the search box: names, symbols and exact addresses. ## Suggested architecture 1. **Refresh lists on the server.** A worker calls each tab’s list on a timer and caches the result. Five tabs refreshed every 10 seconds is 43,200 calls a day, about 1.3 million credits a month: more than the Free plan’s 1,000,000, well within Starter. Every visitor is served from the cache. 2. **Compute risk once per token.** Call `/security` (1 credit) the first time a token enters any list, store the badge, and re-check on a schedule or when the `tax:` or `lp:` stream channels report a change. 3. **Load detail pages on demand.** A token page needs the profile (1 credit), candles (2), recent trades (2) and the cached security check (1): 6 credits. Cache it per `meta.block`, and push live updates with `candles::` and `trades:` on the stream. 4. **Let the user filter on the server.** Pass `min_liquidity_usd`, `launchpad` or `min_market_cap_usd` to the list instead of filtering 100 rows in the browser: you get full pages of matching tokens. ## A trending tab in one call Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Trending tokens in the last 24 hours Which Robinhood Chain tokens are trending today, without rugs and wash trading? GET/v1/robinhood/tokens?list=trending&window=24h&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xd086f891229cd123aadfcae7c4b40150a80fd9d7", "buy_volume_usd": { "1h": 846676, "24h": 1760953, "5m": 213539, "6h": 1760953 }, "buyers": { "1h": 2862, "24h": 4951, "5m": 893, "6h": 4951 }, "buys": { "1h": 5160, "24h": 10660, "5m": 1143, "6h": 10660 }, "change_pct": { "1h": 219.677, "24h": 34319.8, "5m": 3.97796, "6h": 34319.8 }, "created_block": 100319502, "created_ts": 1793216058240, "decimals": 18, "fdv_usd": 2836574, "holders": 2857, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/search?q=0xd086f891229cd123aadfcae7c4b40150a80fd9d7&src=typed_query&f=live", "website": "https://xdcoinsol.lol" }, "liquidity_usd": 723990, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd086f891229cd123aadfcae7c4b40150a80fd9d7.png?size=128", "market_cap_usd": 2552917, "name": "Pizza", "price_eth": 0.00000120424, "price_usd": 0.00283657, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 706205, "24h": 1465984, "5m": 207484, "6h": 1465984 }, "sellers": { "1h": 1951, "24h": 3642, "5m": 630, "6h": 3642 }, "sells": { "1h": 7995, "24h": 17196, "5m": 1833, "6h": 17196 }, "status": null, "symbol": "PIZZA", "traders": { "1h": 3401, "24h": 5197, "5m": 1288, "6h": 5197 }, "txns": { "1h": 8316, "24h": 17544, "5m": 1915, "6h": 17544 }, "volume_usd": { "1h": 1552881, "24h": 3226937, "5m": 421023, "6h": 3226937 } }, { "address": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", "buy_volume_usd": { "1h": 68152.3, "24h": 3574310, "5m": 1310.32, "6h": 2375164 }, "buyers": { "1h": 168, "24h": 2815, "5m": 15, "6h": 1546 }, "buys": { "1h": 369, "24h": 11920, "5m": 17, "6h": 5582 }, "change_pct": { "1h": 0.783146, "24h": 25.2392, "5m": -1.01199, "6h": 21.3351 }, "created_block": 9721433, "created_ts": 1784051310300, "decimals": 18, "fdv_usd": 80269321, "holders": 58015, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/artificiallyinu", "website": "https://artificialinu.com/" }, "liquidity_usd": 4181412, "logo": "https://api.crius.sh/v1/robinhood/logo/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18.png?size=128", "market_cap_usd": 80102641, "name": "Artificial Inu", "price_eth": 0.0000343898, "price_usd": 0.0810048, "progress_pct": null, "quote": "PONS", "sell_volume_usd": { "1h": 50026.5, "24h": 3026550, "5m": 4390.97, "6h": 1840520 }, "sellers": { "1h": 151, "24h": 3051, "5m": 15, "6h": 1664 }, "sells": { "1h": 287, "24h": 12095, "5m": 20, "6h": 5933 }, "status": "launched", "symbol": "AI", "traders": { "1h": 272, "24h": 4132, "5m": 27, "6h": 2294 }, "txns": { "1h": 454, "24h": 14552, "5m": 28, "6h": 6627 }, "volume_usd": { "1h": 118179, "24h": 6600860, "5m": 5701.29, "6h": 4215684 } }, { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "buy_volume_usd": { "1h": 305614, "24h": 5466111, "5m": 20057.3, "6h": 2772574 }, "buyers": { "1h": 229, "24h": 1996, "5m": 56, "6h": 790 }, "buys": { "1h": 847, "24h": 16482, "5m": 104, "6h": 6874 }, "change_pct": { "1h": 0.3314, "24h": -1.40466, "5m": -0.235953, "6h": -1.21643 }, "created_block": 153563, "created_ts": 1782222069300, "decimals": 18, "fdv_usd": 18876187, "holders": 192283, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5815054, "logo": null, "market_cap_usd": 18876064, "name": "NVIDIA • Robinhood Token", "price_eth": 0.0911626, "price_usd": 214.732, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 159139, "24h": 6030012, "5m": 54077.9, "6h": 3340517 }, "sellers": { "1h": 224, "24h": 2645, "5m": 57, "6h": 1101 }, "sells": { "1h": 678, "24h": 18554, "5m": 151, "6h": 8629 }, "status": null, "symbol": "NVDA", "traders": { "1h": 325, "24h": 3519, "5m": 83, "6h": 1422 }, "txns": { "1h": 1413, "24h": 32946, "5m": 240, "6h": 14457 }, "volume_usd": { "1h": 464753, "24h": 11496124, "5m": 74135.1, "6h": 6113091 } } ], "meta": { "block": 100406892, "block_age_ms": 1238, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 117, "list": "trending", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - First is Pizza (`0xd086f891229cd123aadfcae7c4b40150a80fd9d7`): `change_pct.24h: 34319.8`, `volume_usd.24h: 3226937` from 5,197 traders, `market_cap_usd: 2552917` and `liquidity_usd: 723990`, quoted in USDG. - Second is Artificial Inu (`0x2e8c31162b855a2ffa90f6f8634643ad6f111e18`), a Long.xyz token (`launchpad: "long"`) quoted in PONS, with 58,015 holders. - Third is NVIDIA’s Robinhood token (`0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec`, `NVDA`): tokenized stocks rank alongside meme tokens, here with 192,283 holders and `volume_usd.24h: 11496124`. - Each row already has what a table row needs: `logo`, `links`, price, `change_pct`, `buys`, `sells`, `traders` and volume per window (`5m`, `1h`, `6h`, `24h`), plus `status` and `progress_pct` for launchpad tokens. - `meta.next_cursor: "3"`: pass it as `cursor` for the next page. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Trending%20tokens%20in%20the%20last%2024%20hours&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftoken-screeners%2F%23trending%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtrending%26window%3D24h%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Refresh a watchlist Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-token-profiles/) ### Two watchlist rows, only the fields the table shows How do I refresh price, 24h change, market cap and liquidity for the tokens a user is watching? POST/v1/robinhood/tokens/batch **cURL** ```bash curl -X POST "https://api.crius.sh/v1/robinhood/tokens/batch" \ -H "content-type: application/json" \ -d '{"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}' ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens/batch", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ], "fields": [ "symbol", "price.usd", "price.change_pct.24h", "market.market_cap_usd", "market.liquidity_usd" ] }), }); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.post( "https://api.crius.sh/v1/robinhood/tokens/batch", json={"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 40 lines (arrays trimmed)** ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "market": { "liquidity_usd": 73135530, "market_cap_usd": 90409474 }, "price": { "change_pct": { "24h": 0.286017 }, "usd": 2355.49 }, "symbol": "WETH" }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "market": { "liquidity_usd": 5611.8, "market_cap_usd": 3773.42 }, "price": { "change_pct": { "24h": -0.171971 }, "usd": 0.00000388948 }, "symbol": "CHARGE" } }, "meta": { "block": 100406780, "block_age_ms": 575, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 196, "missing": [], "safe_block": 100401329 } } ``` What this tells you - One POST returns both tokens, trimmed to the five `fields` in the body: `symbol`, `price.usd`, `price.change_pct.24h`, `market.market_cap_usd` and `market.liquidity_usd`. - CHARGE has `market_cap_usd: 3773.42` and `liquidity_usd: 5611.8`. Liquidity counts both sides of each pool (2 × the quote side), so on a small token it can exceed the market cap. - WETH has `market_cap_usd: 90409474` and `liquidity_usd: 73135530` across all its pools. - `meta.missing: []`: every address was found. Unknown addresses are listed there instead of failing the request. [Batch token profiles reference](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Two%20watchlist%20rows%2C%20only%20the%20fields%20the%20table%20shows&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftoken-screeners%2F%23watchlist%0ARequest%3A%20POST%20%2Fv1%2Frobinhood%2Ftokens%2Fbatch%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Server-side list cache for a screener tab (anonymous plan; add a key for higher limits). const cache = new Map(); async function refresh(tab, query) { const res = await fetch(`https://api.crius.sh/v1/robinhood/tokens?list=${tab}&limit=100&${query}`); const { data, meta } = await res.json(); cache.set(tab, { block: meta.block, rows: data.map((t) => ({ address: t.address, symbol: t.symbol, logo: t.logo, price: t.price_usd, change24h: t.change_pct["24h"], mcap: t.market_cap_usd, liquidity: t.liquidity_usd, volume24h: t.volume_usd["24h"], launchpad: t.launchpad_name, progress: t.progress_pct, })), }); } setInterval(() => refresh("trending", "window=24h"), 10_000); setInterval(() => refresh("graduating", "min_liquidity_usd=1000"), 10_000); ``` Step-by-step builds are in [Build a token screener](https://docs.crius.sh/guides/build-a-token-screener/), and each tab has its own guide: [new tokens](https://docs.crius.sh/guides/find-new-tokens/), [trending](https://docs.crius.sh/guides/find-trending-tokens/), [by market cap](https://docs.crius.sh/guides/find-tokens-by-market-cap/) and [bonding and graduating](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/). ## Frequently asked questions **How do I keep rugs and wash trading off a Robinhood Chain screener?** Use `list=trending`, which only lists clean tokens: no crash of 90% from the window's peak, $1,000+ liquidity, 20+ real holders, no insider or wallet-farm launch, no bot distribution and no single wallet holding 40%+ of the liquidity unlocked. Add `clean=true` to any other list (`top_volume`, `top_gainers`, …) for the same checks. **How many tokens does one call return?** Token lists return up to 100 tokens per page (paginate with `cursor`). Batch prices and batch profiles take up to 100 addresses per call. Each of those calls costs 1 credit. **Can I show bonding-curve progress for launchpad tokens?** Yes. Every row of `/tokens` has `status` (`bonding` or `graduated` for launchpad tokens) and `progress_pct` toward graduation. `list=graduating` lists bonding tokens closest to graduation first. **Should my screener call the API from the browser?** Better from your backend. Without a key each visitor's browser gets 2 requests per second, and a key in front-end code must be origin-restricted. A backend that refreshes the lists on a timer and serves every visitor from its cache costs the same credits for 10 visitors or 10,000. ## Related [Guide **Token screener** Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code. Read](https://docs.crius.sh/guides/build-a-token-screener/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [Guide **Find new tokens** List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API. Read](https://docs.crius.sh/guides/find-new-tokens/) [Guide **Find tokens by market cap** Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses. Read](https://docs.crius.sh/guides/find-tokens-by-market-cap/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) --- # Robinhood Chain API for trading bots > What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs. Source: https://docs.crius.sh/use-cases/trading-bots/ · Updated 2026-10-28 A trading bot on Robinhood Chain (sniping, copy trading, momentum, market making) needs four things from a data API: candidates to trade, a check that each one can be sold at a fair cost, a live price with the depth behind it, and a fast feed of what happens after it buys. The Crius API covers all four from its own archive nodes, over REST and one WebSocket, so the bot can spend its time on strategy instead of decoding Uniswap v4 hooks and launchpad events. ## Endpoints a trading bot uses - [GET`/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) `list=new`, `list=bonding` and `list=graduating` for candidates, with `launchpad`, `min_liquidity_usd` and `clean=true` filters. - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) before every first buy: honeypot verdict, realized buy and sell tax, owner powers, LP lock status and the v4 hook’s risk. - [GET`/token/{address}/price`](https://docs.crius.sh/reference/tokens/token-price/) for the price, the pool it came from and `liquidity_usd`, to size the order. - [GET`/token/{address}/pools`](https://docs.crius.sh/reference/tokens/token-markets/) for every pool of the token (v2, v3, v4 with hook and fee, bonding curve), to pick the one to route through. - [GET`/token/{address}/trades`](https://docs.crius.sh/reference/trades/trade-tape/) for recent trades with the real trader, `executor` and the router used (`via`). - [GET`/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) for a launchpad token’s curve, `progress` toward graduation and its launch fees, including Pons’s snipe tax. - The [WebSocket stream](https://docs.crius.sh/reference/stream/): `launches:all` and `graduations:all` for new tokens, `trades:` and `price:` for positions, `tax:` and `lp:` for changes that should make the bot exit. ## Suggested architecture 1. **Discover on the stream.** Subscribe to `launches:all` and `graduations:all` (a Free key, 1 credit per connection). Without a key, poll `/tokens?list=new` instead: 1 credit per call, up to 100 tokens. 2. **Gate every candidate.** Call `/security` once per token (1 credit, cached). Skip `critical` and `high`, then check taxes against your target. Just before a large buy, `fresh=1` re-runs the buy → transfer → sell simulation at the head block (20 credits, Starter). 3. **Size from depth.** Read `/price` and keep the order a small share of `quote_liquidity_usd`. Skip `confidence: "low"`: that price has under $1,000 behind it. 4. **Route through a real pool.** `/token/{address}/pools` lists every market. Avoid pools with tiny liquidity or extreme fees, as the example below shows. 5. **Watch open positions on the stream, not by polling.** `price:` for exits, `tax:` and `lp:` because taxes and liquidity can change after launch. 6. **Reconcile on `safe`.** Act on `latest` events for speed. Book PnL from events whose block is `safe` (see [finality](https://docs.crius.sh/concepts/finality/)). | Operation | Call | Credits | | --- | --- | --- | | Screen a new token | `GET /token/{address}/security` | 1 | | Re-simulate before a large buy | `GET /token/{address}/security?fresh=1` (Starter) | 20 | | Price and depth | `GET /token/{address}/price` | 1 | | Pick a pool | `GET /token/{address}/pools` | 1 | | Recent trades | `GET /token/{address}/trades` | 2 | | Live feed for every position | WebSocket stream (Free key or higher) | 1 per connection | Screening 500 new tokens a day with `/security` and `/price` costs 1,000 credits a day, about 30,000 a month: a small part of the Free plan’s 1,000,000. Polling `/price` every second for 20 open positions would cost 1,728,000 credits a day and hit the Free plan’s 10 requests per second. The stream does the same job for 1 credit per connection. ## Check a token before buying Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A 5% sell tax and a hook that can block swaps: score 70 Ruby (0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be) passes the honeypot check. Should the bot buy it? GET/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 191 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x000000000000000000000000000000000000dead", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": "none" }, "flags": [ "tax_over_5pct", "hook_can_block_swaps", "hook_medium_risk", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0x97240e95756c7b70db1ffaeee85a6c091c33a4ce", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": false, "can_modify_liquidity_amounts": true, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207142599, "code_hash": "0x5cb5a35842eb82ff5c9dbed2dca84d023823d841a2c0fc642568bc8ff276f72f", "family": "0xaa8854cbf2bd", "kind": "contract", "logic": null, "owner": "0x33acedd086ee7fec19764b5f4a93a6ef067953f5", "ownership": "active", "size": 24040 }, "family": { "honeypot_pct": 0, "hooks": 3, "id": "0xaa8854cbf2bd", "liquidity_pulled_pct": 0, "pools_traded": 10, "taxed_pct": 90, "verified_hooks": 0 }, "flags": [ { "evidence": "7 of its 7 measured pools take 1%+ per trade (median per pool, up to 6.3%); only 10.83% of traded hooked pools tax at all", "flag": "tax_observed", "severity": "medium" }, { "evidence": "can take part of every swap (return delta); 4.55% of traded pools of hooks that can block swaps and change swap amounts taxed, 0.61% became honeypots", "flag": "can_modify_swap_amounts", "severity": "low" } ], "name": null, "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1793119940000, "honeypot_pools": 0, "last_trade_ts": 1793223286000, "liquidity_pulled_pct": 0, "liquidity_pulled_pools": 0, "max_buy_tax_pct": 2.545, "max_sell_tax_pct": 6.28, "median_pool_life_min": 1380, "pools": 18, "pools_traded": 8, "tax_measured_pools": 7, "taxed_10pct_pools": 0, "taxed_pools": 7, "volume_usd": 924751 }, "pattern": { "description": "hooks that can block swaps and change swap amounts", "honeypot_pct": 0.608377, "id": "before_swap_with_delta", "liquidity_pulled_pct": 21.5893, "pools_traded": 18574, "taxed_pct": 4.55475 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "beforeSwap", "afterSwap", "beforeSwapReturnDelta" ], "risk": [ "can_block_or_reprice_swaps", "can_modify_swap_amounts", "can_modify_liquidity_amounts", "unverified" ], "risk_level": "medium" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x20ac92362ead44f457913ca1a6c24fae049078d9", "liquidity_usd": 23.0571, "pct": 0.214633 }, "sniper_supply_pct": 1.77655, "sniper_top_wallet_pct": 1.77655, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 99.2777, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.722259, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "medium", "score": 70, "tax": { "buy_pct": 0.84, "confidence": "high", "realized": { "buy_pct": 0.84, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 5.28 }, "last_sample_ts": 1793221716000, "max_sell_pct_seen": 16.65, "samples": { "buys": 8, "sells": 240 }, "sell_pct": 5.28, "window": "30d" }, "sell_pct": 5.28, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 99421932, "pct": 5, "side": "sell" }, { "from_block": 99791485, "pct": 1, "side": "buy" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be" }, "meta": { "block": 100406622, "block_age_ms": 595, "block_ts": 1793225060000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 100, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `honeypot.is_honeypot: false`, but `score: 70` and `risk: "medium"`, with flags `tax_over_5pct`, `hook_can_block_swaps`, `hook_medium_risk` and `unverified`. - `tax.sell_pct: 5.28`, measured from 240 real sells (`tax.realized.samples.sells`); the highest sell tax seen in 30 days was 16.65% (`max_sell_pct_seen`). A bot aiming for 3% per trade loses money on every round trip. - `tax_history` shows a 5% sell tax from block 99421932 and a 1% buy tax from block 99791485: the token’s taxes changed after launch. - The pool’s hook has `beforeSwap` and `beforeSwapReturnDelta` permissions, an owner (`code.ownership: "active"`) and `risk_level: "medium"`: it could change what a swap pays. - `meta.simulation` is “no V2 WETH pair: realized tax only”, so the taxes here come from real trades, not from a simulation. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%205%25%20sell%20tax%20and%20a%20hook%20that%20can%20block%20swaps%3A%20score%2070&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftrading-bots%2F%23sell-tax%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x8b5a7a19fbd3d8e8422643fc229b3ab08697c0be%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Pick the pool to trade in Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-markets/) ### CHARGE's markets: one real pool and two traps Which pool should a bot use to trade Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8)? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 123 lines (arrays trimmed)** ```json { "data": [ { "amounts": { "token0": 1.18969, "token1": 720478686 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461321, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 0, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "pons_v2_meme_hook" }, "is_price_pool": true, "liquidity_usd": 5604.57, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_usd": 0.00000388948, "quote": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "quote_liquidity_usd": 2802.29, "state": { "liquidity": 29277002188455996438188, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 1949728392666469411451966154432124, "tick": 202227 }, "swaps_indexed": 432, "tick_spacing": 200 }, { "amounts": { "token0": 3.1477, "token1": 115029 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461495, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 850000, "hook": null, "is_price_pool": false, "liquidity_usd": 6.29539, "pool": "0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3", "price_usd": 0.0000273644, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 3.1477, "state": { "liquidity": 601728037770030, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 15145615706034675540349663040887263187, "tick": 381391 }, "swaps_indexed": 3, "tick_spacing": 60 }, { "amounts": { "token0": 0.328859, "token1": 35779.5 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88466617, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 450000, "hook": null, "is_price_pool": false, "liquidity_usd": 0.657719, "pool": "0x1a184f0aa1978e7b543ee944a30df88dd34fcb667aa5a9142bb399ef582481b8", "price_usd": 0.00000919127, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 0.328859, "state": { "liquidity": 108473206521826, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 26133147987752847079481471382601445977, "tick": 392302 }, "swaps_indexed": 4, "tick_spacing": 4500 } ], "meta": { "block": 100406784, "block_age_ms": 826, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 11, "next_cursor": "3", "safe_block": 100401329, "total": 10 } } ``` What this tells you - The first pool, `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913`, has `is_price_pool: true`, `liquidity_usd: 5604.57` and the Pons hook (`pons_v2_meme_hook`) with `fee: 0`. This is the market. - The second, `0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3`, is a USDG pool with `fee: 850000` (Uniswap’s units of one millionth: an 85% swap fee) and `liquidity_usd: 6.29539`. - The third, `0x1a184f0aa1978e7b543ee944a30df88dd34fcb667aa5a9142bb399ef582481b8`, takes 45% (`fee: 450000`) and holds `liquidity_usd: 0.657719`. - `meta.total: 10`: the token has ten pools. A bot that routes to “any pool with the token” can lose most of its order in fees. [Token markets reference](https://docs.crius.sh/reference/tokens/token-markets/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20markets%3A%20one%20real%20pool%20and%20two%20traps&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Ftrading-bots%2F%23pick-pool%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fpools%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Safety gate before a first buy (anonymous plan: no key needed). const API = "https://api.crius.sh/v1/robinhood"; const get = async (p) => (await (await fetch(API + p)).json()).data; async function canBuy(token, targetProfitPct) { const [sec, px] = await Promise.all([get(`/token/${token}/security`), get(`/token/${token}/price`)]); if (!sec || !px) return { ok: false, why: "unknown token or no market" }; if (sec.risk === "critical" || sec.risk === "high") return { ok: false, why: `${sec.risk}: ${sec.flags.join(", ")}` }; const roundTrip = (sec.tax.buy_pct ?? 0) + (sec.tax.sell_pct ?? 0); if (roundTrip >= targetProfitPct) return { ok: false, why: `taxes ${roundTrip}% eat the target` }; if (px.confidence === "low") return { ok: false, why: `thin market: $${px.liquidity_usd}` }; return { ok: true, pool: px.source_pool, maxOrderUsd: px.quote_liquidity_usd * 0.02 }; } ``` The 2% order cap is an example, not a rule; pick yours from the price impact you accept. For the full checklist, see [Add safety checks to a trading bot](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/); for the feed, [Stream trades over WebSocket](https://docs.crius.sh/guides/stream-trades-websocket/). ## Frequently asked questions **Can the Crius API execute trades for my bot?** No. The Crius API is read-only data. Your bot signs and sends its own transactions through its wallet and an RPC endpoint; Crius tells it what to trade, what it costs and whether it can be sold. **How fast does a bot see a new token or trade?** Stream messages are pushed as soon as a block is decoded, typically well under a second after it was produced. Every REST response carries `meta.lag_ms`, the time since the index applied that block. **Do I need a paid plan for a trading bot?** Not to start. Prices, pools, trades, token lists and the cached security check work without a key at 2 requests per second. The WebSocket stream needs a Free key. A fresh honeypot re-simulation on demand (`/security?fresh=1`, 20 credits) needs Starter or higher. **How does a bot avoid honeypots and high taxes?** Call `/token/{address}/security` before the first buy. Skip `risk: "critical"` (a honeypot), and compare `tax.buy_pct` plus `tax.sell_pct` with the profit you're aiming for. Taxes are measured from real trades, so they include Uniswap v4 hook taxes the contract code doesn't show. ## Related [Guide **Safety checks for bots** Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts. Read](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/) [Guide **Stream trades** Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill. Read](https://docs.crius.sh/guides/stream-trades-websocket/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Price alerts** Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first. Read](https://docs.crius.sh/guides/build-price-alerts/) [API reference **WebSocket stream** Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Read](https://docs.crius.sh/reference/stream/) --- # Robinhood Chain API for wallets and portfolio apps > What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens. Source: https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/ · Updated 2026-10-28 A wallet or portfolio app shows a user what they own, what it is worth and how they did: balances in ETH and tokens, USD values that don’t count spam as money, realized and unrealized PnL, and a trade history that names the token rather than the router. The Crius API returns the whole portfolio in one call, priced from on-chain pools, with a confidence level on each value. Apps that already read balances can use batch prices alone. ## Endpoints a portfolio app uses - [GET`/wallet/{address}`](https://docs.crius.sh/reference/wallets/wallet-profile/) holdings with USD value and `price_confidence`, native ETH balance, realized and unrealized PnL over a window, win rate, gas spent and wallet tags. `min_value_usd` hides dust. - [GET`/wallet/{address}/trades`](https://docs.crius.sh/reference/wallets/wallet-trades/) every trade the wallet made across all tokens, newest first, filterable by `token`, `side`, `min_usd` and time. - [GET`/prices`](https://docs.crius.sh/reference/tokens/batch-prices/) USD and ETH prices with 24h change for up to 100 tokens, when you have the balances already. - [POST`/tokens/batch`](https://docs.crius.sh/reference/tokens/batch-token-profiles/) names, logos and market data for the tokens in a portfolio, trimmed to the fields you show. - [GET`/token/{address}/candles`](https://docs.crius.sh/reference/trades/ohlcv-candles/) price charts for a token detail screen. - [GET`/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) a warning before the user sends, swaps or trusts a token. - The `wallet:
` [stream channel](https://docs.crius.sh/reference/stream/): the wallet’s trades and transfers as they happen, so you refresh only when something changed. ## Suggested architecture 1. **Balances you already have: price them in batches.** `POST /prices` with up to 100 token addresses costs 1 credit and needs no key. A wallet with 300 tokens is three calls. 2. **Full portfolio: one profile call.** `/wallet/{address}` (Starter, 5 credits) returns holdings, values and PnL together. Cache it per user and refresh when the `wallet:
` channel reports activity, not on every screen view. 3. **Value only what can be sold.** Leave holdings with `price_confidence: "low"` out of the headline total, or show them under “unpriced”. Values are already capped at what each token’s price pool could pay out. 4. **Load history page by page.** `/wallet/{address}/trades` with `limit` and `cursor` (5 credits per page). Each trade carries the USD value at trade time, so history never needs re-pricing. As a budget: 10,000 users who each open the app three times a day, with one profile call per open, is 150,000 credits a day, about 4.5 million a month, which fits Starter’s 10,000,000. Refreshing on stream events instead of every open lowers that further. ## A portfolio in one call Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-profile/) ### A smart account holding ETH and two fake USDG tokens What does wallet 0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca hold, and what is it really worth? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 84 lines (arrays trimmed)** ```json { "data": { "account_type": "smart_account", "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "delegate": "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b", "holdings": [ { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500064, "value_usd": 0.0117789 }, { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0x06993ae1230d3755b54f25022028daa66772bc3d", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500061, "value_usd": 0.0117789 } ], "holdings_truncated": false, "holdings_value_usd": 0.0235578, "is_contract": false, "label": null, "native_balance": 0.71473787532832551, "native_value_usd": 1683.56, "pnl": { "avg_hold_time_s": null, "best_trade": null, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 0.198772, "realized_usd": 0, "tokens_traded": 0, "tokens_with_known_cost": 0, "total_usd": 0, "trades": 0, "unrealized_usd": 0, "volume_usd": 0, "win_rate_pct": null, "window": "30d", "worst_trade": null }, "profile": { "first_seen_block": 91351250, "first_seen_ts": 1792283372000, "fresh": false, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "block": 87601233, "label": "bridge:Relay solver", "ts": 1791903516300 }, "history": "complete", "tags": [ "dev", "smart_account" ], "tx_count": 14, "wallet_age_days": 10.8994 } }, "meta": { "balances_block": 100406864, "block": 100406864, "block_age_ms": 1301, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 59, "safe_block": 100401329 } } ``` What this tells you - `account_type: "smart_account"` with `delegate: "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b"`: an EIP-7702 wallet. `profile.tags` are `dev` and `smart_account`. - `native_balance: 0.71473787532832551` ETH, worth `native_value_usd: 1683.56`. Almost all the value is ETH. - Both token holdings have `symbol: "USDG"` and `balance: 25`, but their addresses are `0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775` and `0x06993ae1230d3755b54f25022028daa66772bc3d`, not the real USDG `0x5fc5360d0400a0fd4f2af552add042d716f1d168`. Each is valued at `value_usd: 0.0117789` with `price_confidence: "low"`. - An app that matched by symbol would show $50 of stablecoins here. The API values both at about a cent each: `holdings_value_usd: 0.0235578`. - `profile.funded_by` is a Relay solver (`label: "bridge:Relay solver"`): the wallet’s first ETH was bridged in. [Wallet profile reference](https://docs.crius.sh/reference/wallets/wallet-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20smart%20account%20holding%20ETH%20and%20two%20fake%20USDG%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fwallets-and-portfolio-apps%2F%23portfolio%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Prices for balances you already know Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/batch-prices/) ### Batch prices for a watchlist or a wallet's tokens What are CHARGE (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) and WETH (0x0bd7d308f8e1639fab988df18a8011f41eacad73) worth right now? GET/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8,0x0bd7d308f8e1639fab988df18a8011f41eacad73 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8,0x0bd7d308f8e1639fab988df18a8011f41eacad73" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8,0x0bd7d308f8e1639fab988df18a8011f41eacad73"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8,0x0bd7d308f8e1639fab988df18a8011f41eacad73", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 34 lines (arrays trimmed)** ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "change_24h_pct": 0.286017, "confidence": "high", "eth": 1, "liquidity_usd": 9953382, "logo": null, "source_pool": "0xbac3aa3b91584a53a579b3c999a56756e954e59247e497bad1d25a4334bde551", "symbol": "WETH", "usd": 2355.49 }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "change_24h_pct": -0.171971, "confidence": "medium", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "usd": 0.00000388948 } }, "meta": { "block": 100406775, "block_age_ms": 907, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 35, "missing": [], "safe_block": 100401329 } } ``` What this tells you - Results are keyed by address: WETH has `usd: 2355.49` with `confidence: "high"` and `liquidity_usd: 9953382`; CHARGE has `usd: 0.00000388948` with `confidence: "medium"`. - `change_24h_pct` is ready for the green or red number next to each row (0.286017 for WETH, −0.171971 for CHARGE). - `logo` is a ready-to-use image URL for CHARGE and `null` for WETH: keep your own icons for the chain’s base assets. - `meta.missing: []`: an address without a price would be listed there rather than failing the call. [Batch prices reference](https://docs.crius.sh/reference/tokens/batch-prices/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Batch%20prices%20for%20a%20watchlist%20or%20a%20wallet's%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fuse-cases%2Fwallets-and-portfolio-apps%2F%23batch-prices%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fprices%3Ftokens%3D0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2C0x0bd7d308f8e1639fab988df18a8011f41eacad73%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ```js // Value a wallet from balances you already read over RPC (anonymous: no key needed). async function valuePortfolio(balances /* { [tokenAddress]: amount } */) { const res = await fetch("https://api.crius.sh/v1/robinhood/prices", { method: "POST", headers: { "content-type": "application/json" }, body: JSON.stringify({ tokens: Object.keys(balances).slice(0, 100) }), }); const { data } = await res.json(); let total = 0; const unpriced = []; for (const [token, amount] of Object.entries(balances)) { const p = data[token.toLowerCase()]; if (!p || p.confidence === "low") unpriced.push(token); else total += amount * p.usd; } return { totalUsd: total, unpriced }; } ``` The balance × price above isn’t capped by pool depth, so a very large holding of a small token can still look worth more than its market could pay: use `/wallet/{address}` when that matters. How PnL is worked out is on the [PnL page](https://docs.crius.sh/concepts/pnl/), and the guides cover [holdings and PnL](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) and [trade history](https://docs.crius.sh/guides/get-wallet-trade-history/). ## Frequently asked questions **How do I spot fake USDG and spam tokens in a wallet?** Match tokens by address, never by symbol: the real USDG is `0x5fc5360d0400a0fd4f2af552add042d716f1d168`. Then use `price_confidence` on each holding (`low` means the token has no real market behind its price) and the `/security` check (`risk`, `flags`) before you count a token in the total or offer a swap. **Does the wallet API work with EIP-7702 smart accounts?** Yes. The wallet profile reports `account_type` (`eoa`, `smart_account` or `contract`) and, for smart accounts, the `delegate` contract. Trades made through the account's delegate are attributed to the account itself. **Which plan does a portfolio app need?** If your app already knows the balances (a wallet reads them from its own RPC), batch prices are enough: anonymous, 1 credit per 100 tokens. The wallet profile and wallet trades (holdings, PnL, history) need a Starter key and cost 5 credits per call. **Can I get a wallet's portfolio value over time?** There is no single portfolio-history call. Rebuild it from the wallet's trades (`/wallet/{address}/trades`) and each token's candles (`/token/{address}/candles`), or store the profile's `holdings_value_usd` yourself each day. ## Related [Guide **Wallet holdings & PnL** Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Read](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) [Guide **Wallet trade history** List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time. Read](https://docs.crius.sh/guides/get-wallet-trade-history/) [Guide **Prices for many tokens** Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed. Read](https://docs.crius.sh/guides/get-prices-for-many-tokens/) [Concept **PnL** How the Crius API computes realized and unrealized PnL, ROI, cost basis and win rate for Robinhood Chain traders and wallets, worked through on real trades. Read](https://docs.crius.sh/concepts/pnl/) [Concept **Token prices** How the Crius API prices Robinhood Chain tokens from on-chain pools, how the price pool is picked, and what confidence and thin\_liquidity mean. Read](https://docs.crius.sh/concepts/token-prices/) [API reference **Wallet profile API** Holdings with USD value, realized and unrealized PnL over a window (1d, 7d, 30d, all), win rate and wallet tags. Read](https://docs.crius.sh/reference/wallets/wallet-profile/) --- # Robinhood Chain API reference > All 35 Crius REST endpoints for Robinhood Chain (chain id 4663) with parameters, plan, credit cost, code in cURL, JavaScript and Python, and real responses, plus the WebSocket stream. Source: https://docs.crius.sh/reference/ · Updated 2026-10-28 ## Base URL and auth Every endpoint lives under `https://api.crius.sh/v1/{chain}`, where `{chain}` is `robinhood` or the chain id `4663`. Send your key in the `x-api-key` header. Endpoints marked *Anonymous* also work without a key at a low per-IP rate. Responses are JSON with `data` and `meta` (block, finality, lag); see [Responses & conventions](https://docs.crius.sh/conventions/). ## [Tokens & prices](https://docs.crius.sh/reference/tokens/) Token profiles, live USD prices, batch prices, sparse batch profiles and every market a token trades in on Robinhood Chain. [GET /token/{address} Token profile Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/) [GET /token/{address}/price Token price Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/) [GET /prices Batch prices Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/) [POST /prices Batch prices (POST) Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/) [POST /tokens/batch Batch token profiles Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET /token/{address}/pools Token markets Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) ## [Trades & candles](https://docs.crius.sh/reference/trades/) Trade tape with real-trader attribution, OHLCV candles from 1 second to 1 day, and a unified activity feed for any Robinhood Chain token. [GET /token/{address}/trades Trade tape Anonymous · 2 cr](https://docs.crius.sh/reference/trades/trade-tape/) [GET /token/{address}/candles OHLCV candles Anonymous · 2 cr](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET /token/{address}/transactions Activity feed Free · 2 cr](https://docs.crius.sh/reference/trades/activity-feed/) ## [Holders & traders](https://docs.crius.sh/reference/holders/) Live holder lists, holder snapshots at any past block, time or market cap, diamond-hand cohorts, holder count history and top traders with PnL. [GET /token/{address}/holders Live holders Free · 2 cr](https://docs.crius.sh/reference/holders/live-holders/) [GET /token/{address}/holders/snapshot Holder snapshot Free · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET /token/{address}/holders/cohort Holder cohort Starter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/) [GET /token/{address}/holders/history Holder count history Starter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/) [GET /token/{address}/traders Top traders Free · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) ## [Security & liquidity](https://docs.crius.sh/reference/security/) Realized buy and sell tax, simulated honeypot checks, contract flags and LP lock status for any Robinhood Chain token. [GET /token/{address}/security Security checks Anonymous · 1 cr](https://docs.crius.sh/reference/security/security-checks/) [GET /token/{address}/liquidity Liquidity & locks Free · 5 cr](https://docs.crius.sh/reference/security/liquidity-locks/) ## [Launchpads & fees](https://docs.crius.sh/reference/launchpads/) Launchpad lifecycle (bonding curve progress, graduation), live launchpad stats, and fees, claims and receivers for Robinhood Chain tokens. [GET /launchpads Launchpads Anonymous · 1 cr](https://docs.crius.sh/reference/launchpads/launchpads/) [GET /launchpads/{id} Launchpad detail Anonymous · 2 cr](https://docs.crius.sh/reference/launchpads/launchpad-detail/) [GET /token/{address}/launch Launch lifecycle Free · 2 cr](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [GET /token/{address}/fees Fees & claims Starter · 5 cr](https://docs.crius.sh/reference/launchpads/fees-claims/) ## [Pools & hooks](https://docs.crius.sh/reference/pools/) Pool details for Uniswap v2, v3 and v4 on Robinhood Chain, and Uniswap v4 hooks with decoded permissions and risk flags. [GET /pool/{pool} Pool detail Anonymous · 1 cr](https://docs.crius.sh/reference/pools/pool-detail/) [GET /hooks Uniswap v4 hooks Free · 2 cr](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) [GET /hook/{address} Hook detail Free · 2 cr](https://docs.crius.sh/reference/pools/hook-detail/) ## [Wallets & devs](https://docs.crius.sh/reference/wallets/) Wallet profiles with holdings and PnL, wallet trade history, funding connections and token developer profiles on Robinhood Chain. [GET /wallet/{address} Wallet profile Starter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-profile/) [GET /wallet/{address}/trades Wallet trades Starter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-trades/) [GET /wallet/{address}/connections Wallet connections Starter · 10 cr](https://docs.crius.sh/reference/wallets/wallet-connections/) [GET /dev/{address} Developer profile Free · 5 cr](https://docs.crius.sh/reference/wallets/developer-profile/) ## [Bundles & bubble maps](https://docs.crius.sh/reference/wallet-graph/) Sniper, bundle and cluster detection and holder bubble-map graphs for Robinhood Chain tokens. [GET /token/{address}/bundles Snipers, bundles & clusters Starter · 10 cr](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) [GET /token/{address}/bubblemap Bubble map Starter · 10 cr](https://docs.crius.sh/reference/wallet-graph/bubble-map/) ## [Discovery & search](https://docs.crius.sh/reference/discovery/) Token lists (new, bonding, graduating, trending, top gainers and losers) and search across tokens, pools, wallets and hooks on Robinhood Chain. [GET /tokens Token lists Anonymous · 1 cr](https://docs.crius.sh/reference/discovery/token-lists/) [GET /search Search Anonymous · 1 cr](https://docs.crius.sh/reference/discovery/search/) ## [Chain stats & status](https://docs.crius.sh/reference/chain/) Chain-wide Robinhood Chain numbers (volume, trades, TVL, launches, gas) and the API's own health and supported chains. [GET /stats Chain stats Anonymous · 1 cr](https://docs.crius.sh/reference/chain/chain-stats/) [GET /volume Volume history Anonymous · 1 cr](https://docs.crius.sh/reference/chain/volume-history/) [GET /v1/status Service status Anonymous · 0 cr](https://docs.crius.sh/reference/chain/service-status/) [GET /v1/chains Supported chains Anonymous · 0 cr](https://docs.crius.sh/reference/chain/supported-chains/) ## Stream, account, billing [**WebSocket stream** Real-time trades, prices, new tokens, pool and launchpad events over one WebSocket connection. Read](https://docs.crius.sh/reference/stream/) [**Account API** Sign up, API keys, usage and linked wallets, over the same API host. Read](https://docs.crius.sh/reference/account/) [**Billing & payments** Pay for a plan on-chain and claim control of the account. Read](https://docs.crius.sh/reference/billing/) --- # Account API > Manage your Crius account programmatically - email and wallet sign-in, usage and quota, API keys (create, update, rotate, revoke), dashboard sessions and linked wallets. Source: https://docs.crius.sh/reference/account/ · Updated 2026-10-28 The Account API lives at **`https://account.crius.sh`** (the same paths also work on `api.crius.sh`, which forwards them). Account calls are **free**: they never cost credits and have their own limit of 10 requests per second. | Access | Endpoints | | --- | --- | | No key | sign-up and sign-in (`/v1/account/signup/*`) | | Any key of the account | `GET /v1/account/usage` | | Dashboard session only | everything else: profile, keys, sessions, wallets, billing | API keys can read usage but can never manage the account. Management needs a **session key** from a dashboard sign-in, which lasts 7 days and can’t call data endpoints. This is what [dashboard.crius.sh](https://dashboard.crius.sh) uses; you only need these endpoints to build your own tooling. ## Sign up and sign in ### Email code Terminal window ```bash # 1. Ask for a one-time code (the dashboard also sends a Cloudflare Turnstile token). curl -X POST https://account.crius.sh/v1/account/signup/email \ -H "content-type: application/json" \ -d '{"email": "you@example.com", "turnstile_token": "…"}' # 2. Verify it. "session": true returns a 7-day dashboard session instead of a new API key. curl -X POST https://account.crius.sh/v1/account/signup/email/verify \ -H "content-type: application/json" \ -d '{"email": "you@example.com", "code": "123456", "session": true}' ``` A new email creates an account on the Free plan; a known email signs in. Codes expire after 10 minutes and five wrong attempts void a code. One account per inbox: `+tags`, dots in Gmail addresses and `googlemail.com` are folded together, and disposable inboxes are refused. ### Wallet A wallet [linked to your account](#wallets) can sign in without email: 1. `GET /v1/account/signup/challenge?address=0x…` returns a message to sign (valid 10 minutes). 2. Sign it with `personal_sign` (EIP-191). Nothing is sent on-chain and it costs nothing. 3. `POST /v1/account/signup/wallet` with `{"address", "signature", "session": true}`. ## Account and usage | Method | Path | Returns | | --- | --- | --- | | GET | `/v1/account` | Account id, email, plan, status, linked wallets, limits | | GET | `/v1/account/usage` | Month-to-date credits used and remaining, rate limit, current subscription, daily usage for 30 days, top endpoints this month | Terminal window ```bash curl https://account.crius.sh/v1/account/usage -H "x-api-key: $CRIUS_API_KEY" ``` Usage is flushed every few seconds, so a request you just made appears almost immediately. ## API keys | Method | Path | Does | | --- | --- | --- | | GET | `/v1/account/keys` | List keys (prefix, name, scopes, restrictions, status, last used) | | POST | `/v1/account/keys` | Create a key; the response contains the secret, **once** | | PATCH | `/v1/account/keys/{key_id}` | Change name, scopes, IP allow-list, allowed origins, rate limit or expiry | | POST | `/v1/account/keys/{key_id}/rotate` | New secret; the old one works for `grace_period_s` (default 3,600, max 7 days) | | DELETE | `/v1/account/keys/{key_id}` | Revoke immediately | Body fields for create and update: ```json { "name": "trading-bot", "scopes": ["read", "stream"], "ip_allowlist": ["203.0.113.7", "10.0.0.0/8"], "allowed_origins": [], "expires_in_days": 90, "limits": { "rps": 5 }, "env": "live" } ``` `scopes` accepts `read`, `stream`, `simulate` and `export`. A key with `allowed_origins` is read-only. `limits.rps` can’t exceed your plan. An account can have 20 active keys. ## Sessions | Method | Path | Does | | --- | --- | --- | | GET | `/v1/account/sessions` | Dashboard sign-ins that are still valid | | DELETE | `/v1/account/sessions/{key_id}` | Sign one out | ## Wallets Linked wallets are a sign-in method and are used to pay and control your [subscription on-chain](https://docs.crius.sh/reference/billing/). A wallet belongs to one account, and an account can link up to 10. | Method | Path | Does | | --- | --- | --- | | GET | `/v1/account/wallets` | List linked wallets | | POST | `/v1/account/wallets` | Link: `{"address", "signature"}` over a fresh challenge | | DELETE | `/v1/account/wallets/{address}` | Unlink | We email you when a key is created, rotated or revoked and when a wallet is linked or unlinked, with the IP that did it. If you didn’t, revoke your keys and sign out every session. --- # Billing & payments > How Crius plans are paid on-chain on Robinhood Chain in USDG, ETH or WETH - pricing, 6 and 12 month discounts, auto-renew with a price cap, upgrades with credit, and the billing endpoints. Source: https://docs.crius.sh/reference/billing/ · Updated 2026-10-28 Crius plans are paid **on-chain on Robinhood Chain** through the CriusPayments contract at [`0xee4ce8614BCd9D910Ae0e4f0995B26eDC017A8ec`](https://robin.etherscan.io/address/0xee4ce8614BCd9D910Ae0e4f0995B26eDC017A8ec). You pay from your own wallet; we never hold your funds, and there are no cards or stored payment details. Payments go straight to the Crius treasury. The easiest way to pay is the **Billing** page of the [dashboard](https://dashboard.crius.sh), which does every step below for you. ## Prices | Plan | 1 month | 6 months (10% off) | 12 months (20% off) | | --- | --- | --- | --- | | Starter | $19 | $102.60 | $182.40 | | Pro | $79 | $426.60 | $758.40 | | Business | $249 | $1,344.60 | $2,390.40 | - **USDG** is charged exactly at the USD price. - **ETH and WETH** amounts follow the Chainlink ETH/USD feed on Robinhood Chain at the moment you pay. You send a little more than the quote (about 1%) as a maximum, the contract charges the live quote, and any extra ETH is refunded in the same transaction. - Enterprise plans are arranged with us: [support@crius.sh](mailto:support@crius.sh). ## How a payment works 1. **Get your payment reference.** `GET /v1/account/billing` (dashboard session) returns your account’s private `account_ref` (a bytes32 only your account can derive), the contract and token addresses, live quotes for every plan, period and token, and your on-chain subscription. 2. **Pay.** Call `pay(account_ref, plan, months, token, maxAmount, minExpiresAt)` on the contract with `plan` 2 (Starter), 3 (Pro) or 4 (Business) and `months` 1, 6 or 12. For USDG and WETH, approve the amount first. 3. **Done.** About 20 blocks later our watcher sees the `PaymentReceived` event, moves your account to the plan until the expiry the contract set, and emails you a receipt. ## Renewals, upgrades and credit - **Paying again extends** your subscription from its current end date, so you never lose days by renewing early. - **Changing plan** converts the unused time of your current plan into credit on the new one; nothing is lost. - **Auto-renew** (USDG or WETH) is opt-in: you approve a maximum price per renewal, and the renewal can be charged from 3 days before expiry. You can cancel any time from the wallet that set it up. If a renewal fails (low balance or allowance), we email you; after 7 days past expiry, auto-renew switches itself off. - When a subscription ends, the account returns to the Free plan. We email you 7 days and 1 day before (unless auto-renew is on). ## Controller wallet The first wallet that pays for an account becomes its on-chain **controller**: the only wallet that can turn auto-renew on or off. If someone else paid for your account first, `POST /v1/account/billing/claim` with `{"wallet": "0x…"}` (one of your [linked wallets](https://docs.crius.sh/reference/account/#wallets)) returns a one-hour signed claim; submit it with `claimController(account_ref, wallet, issued_at, signature)` to take control. One claim per account per hour. Refunds are described in the [Refund policy](https://crius.sh/refunds/). On-chain transactions are final, so check the plan, period and amount before you confirm in your wallet. --- # Chain stats & status API > Chain-wide Robinhood Chain numbers (volume, trades, TVL, launches, gas) and the API's own health and supported chains. Source: https://docs.crius.sh/reference/chain/ · Updated 2026-10-28 Chain-wide numbers and the API's own health. `/v1/status` and `/v1/chains` are public and never count against your credits' rate limit tiers. ## Endpoints [GET /stats Chain stats Anonymous · 1 cr](https://docs.crius.sh/reference/chain/chain-stats/) [GET /volume Volume history Anonymous · 1 cr](https://docs.crius.sh/reference/chain/volume-history/) [GET /v1/status Service status Anonymous · 0 cr](https://docs.crius.sh/reference/chain/service-status/) [GET /v1/chains Supported chains Anonymous · 0 cr](https://docs.crius.sh/reference/chain/supported-chains/) --- # Chain stats > DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (1h,… Source: https://docs.crius.sh/reference/chain/chain-stats/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/stats DEX volume and trades (per DEX), traders, TVL and locked liquidity, launches and graduations per launchpad, pools, gas costs and block times over a window (`1h`, `24h`, `7d`). > DEX volume by DEX, txs, active wallets, gas (L2 + L1 base fee), TVL, new tokens / pools, launchpads, reorgs. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `window`string Default `24h` Stats window. One of `1h`, `24h`, `7d`. ## Guides that use this endpoint [**Build a Robinhood Chain stats dashboard**Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code.](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/)[**Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume**Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades.](https://docs.crius.sh/guides/robinhood-chain-dex-data/)[**Robinhood Chain RPC, chain ID 4663 and network settings**Robinhood Chain network settings: chain ID 4663 (0x1237), public RPC URLs, ETH gas, the block explorer, an eth\_chainId check and what an indexed API adds.](https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More chain stats & status endpoints [GET/volumeVolume historyAnonymous · 1 cr](https://docs.crius.sh/reference/chain/volume-history/)[GET/v1/statusService statusAnonymous · 0 cr](https://docs.crius.sh/reference/chain/service-status/)[GET/v1/chainsSupported chainsAnonymous · 0 cr](https://docs.crius.sh/reference/chain/supported-chains/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/stats?window=24h" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/stats?window=24h", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/stats?window=24h", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "blocks": { "active_wallets": 194641, "avg_block_time_ms": 101, "tps_1m": 44.6833, "txs": 2430221 }, "chain": "robinhood", "chain_id": 4663, "dex": { "by_dex": { "launch_curve": 114839, "pons_curve": 6920073, "uniswap_v2": 6992610, "uniswap_v3": 235116790, "uniswap_v4": 286137338 }, "traders": 148079, "trades": 1769098, "volume_usd": 535281650, "wash_volume_usd": 100833980 }, "eth_usd": 2355.49, "finalized_block": 100397649, "gas": { "avg_swap_cost_eth": 0.00000791235, "avg_swap_cost_usd": 0.0186374, "l1_base_fee_gwei": 0, "l2_gas_price_gwei": 0.021042 }, "head_block": 100406547, "l1_block": 26294099, "launchpads": [ { "graduated": 16, "launches": 1780, "launchpad": "pons", "launchpad_name": "Pons", "volume_usd": 25485280 }, { "graduated": 0, "launches": 508, "launchpad": "long", "launchpad_name": "Long.xyz", "volume_usd": 10784246 }, { "graduated": 0, "launches": 20, "launchpad": "bankr", "launchpad_name": "Bankr", "volume_usd": 595435 } ], "liquidity": { "locked_lp_usd": 44712347, "method": "2x quote side (ETH/WETH/USDG) of every pool; V3/V4 in-range", "tvl_usd": 322714989 }, "pools": { "by_dex": { "launch_curve": 1201, "pons_curve": 1780, "uniswap_v2": 1483, "uniswap_v3": 224, "uniswap_v4": 5457 }, "new": 10145 }, "reorgs": { "count": 0, "max_depth": 0 }, "safe_block": 100401329, "tokens": { "by_attribution": { "known_launchpad": 3527, "other": 4095 }, "new": 7622, "new_1h": 418 }, "window": "24h" }, "meta": { "block": 100406547, "block_age_ms": 1026, "block_ts": 1793225052000, "chain": "robinhood", "coverage": { "note": "aggregates cover blocks indexed since start_block until backfill completes", "since_block": 0 }, "finalized_block": 100397649, "lag_ms": 26, "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fstats&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fchain%2Fchain-stats%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Service status > Per-chain index health: status (live, catching_up, stalled, starting), indexed block, lag behind the chain head, safe and finalized blocks, and how many… Source: https://docs.crius.sh/reference/chain/service-status/ · Updated 2026-10-28 GET https://api.crius.sh/v1/status Per-chain index health: `status` (`live`, `catching_up`, `stalled`, `starting`), indexed block, lag behind the chain head, safe and finalized blocks, and how many tokens, pools and addresses are indexed. Public. For uptime history and incidents see [status.crius.sh](https://status.crius.sh). > Public, no key. ## Guides that use this endpoint [**Build a Robinhood Chain stats dashboard**Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code.](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/)[**What is the best Robinhood Chain data API? How to choose one**How to choose a Robinhood Chain data API: nine criteria, from launchpads and realized taxes to WebSockets and free plans, and a sourced provider comparison.](https://docs.crius.sh/guides/choose-a-robinhood-chain-data-api/)[**Robinhood Chain RPC, chain ID 4663 and network settings**Robinhood Chain network settings: chain ID 4663 (0x1237), public RPC URLs, ETH gas, the block explorer, an eth\_chainId check and what an indexed API adds.](https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More chain stats & status endpoints [GET/statsChain statsAnonymous · 1 cr](https://docs.crius.sh/reference/chain/chain-stats/)[GET/volumeVolume historyAnonymous · 1 cr](https://docs.crius.sh/reference/chain/volume-history/)[GET/v1/chainsSupported chainsAnonymous · 0 cr](https://docs.crius.sh/reference/chain/supported-chains/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/status" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/status", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/status", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "chains": { "robinhood": { "addresses": 29509881, "block_age_ms": 1203, "chain_id": 4663, "finalized_block": 100397649, "indexed_block": 100406757, "lag_ms": 50, "pools": 2780862, "safe_block": 100401329, "start_block": 0, "status": "live", "tokens": 2406786 } }, "region": "rigel", "version": "0.1.0" } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2Fstatus&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fchain%2Fservice-status%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Supported chains > Chains this API serves, with chain id, native symbol and block time. Supported chains on Robinhood Chain: parameters, plan, credits, code and a real response. Source: https://docs.crius.sh/reference/chain/supported-chains/ · Updated 2026-10-28 GET https://api.crius.sh/v1/chains Chains this API serves, with chain id, native symbol and block time. ## Guides that use this endpoint [**Robinhood Chain RPC, chain ID 4663 and network settings**Robinhood Chain network settings: chain ID 4663 (0x1237), public RPC URLs, ETH gas, the block explorer, an eth\_chainId check and what an indexed API adds.](https://docs.crius.sh/guides/robinhood-chain-rpc-and-chain-id/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More chain stats & status endpoints [GET/statsChain statsAnonymous · 1 cr](https://docs.crius.sh/reference/chain/chain-stats/)[GET/volumeVolume historyAnonymous · 1 cr](https://docs.crius.sh/reference/chain/volume-history/)[GET/v1/statusService statusAnonymous · 0 cr](https://docs.crius.sh/reference/chain/service-status/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/chains" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/chains", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/chains", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "block_time_ms": 100, "chain_id": 4663, "name": "Robinhood Chain", "native": "ETH", "regions": [ "rigel" ], "slug": "robinhood", "type": "arbitrum_orbit_l2" } ] } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2Fchains&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fchain%2Fsupported-chains%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Volume history > On-chain volume per hour or per day, in your time zone (tz), plus a weekday × hour pattern over pattern_days. Source: https://docs.crius.sh/reference/chain/volume-history/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/volume On-chain volume per hour or per day, in your time zone (`tz`), plus a weekday × hour pattern over `pattern_days`. > Organic DEX volume (wash round trips and mispriced outliers excluded, reported separately) for 1s, 30s, 1m, 5m, 1h, 6h, 24h, 7d, 30d, 90d, 180d with the previous window and change %; hourly and daily series; average volume by day of week and hour of day with the peak / quietest day and hour. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `tz`string Default `UTC` IANA time zone for series and patterns, e.g. Asia/Dubai `hours`integer Default `48` Hourly series length (max 4320) `days`integer Default `30` Daily series length (max 365) `pattern_days`integer Default `90` Lookback for weekday / hour-of-day patterns (7..365) ## Guides that use this endpoint [**Build a Robinhood Chain stats dashboard**Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code.](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More chain stats & status endpoints [GET/statsChain statsAnonymous · 1 cr](https://docs.crius.sh/reference/chain/chain-stats/)[GET/v1/statusService statusAnonymous · 0 cr](https://docs.crius.sh/reference/chain/service-status/)[GET/v1/chainsSupported chainsAnonymous · 0 cr](https://docs.crius.sh/reference/chain/supported-chains/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/volume?days=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/volume?days=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/volume?days=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "as_of_ts": 1793225074000, "by_hour": { "lookback_days": 90, "peak_hour": 14, "quietest_hour": 4, "rows": [ { "avg_trades": 171529, "avg_volume_usd": 37907414, "days_counted": 89, "hour": 0, "share_pct": 3.69344 }, { "avg_trades": 160908, "avg_volume_usd": 37815486, "days_counted": 89, "hour": 1, "share_pct": 3.68448 }, { "avg_trades": 154787, "avg_volume_usd": 36420348, "days_counted": 89, "hour": 2, "share_pct": 3.54855 } ] }, "by_weekday": { "lookback_days": 90, "peak_day": "wednesday", "quietest_day": "saturday", "rows": [ { "avg_trades": 4116146, "avg_volume_usd": 1013038326, "day": "monday", "days_counted": 13, "share_pct": 14.4174, "total_volume_usd": 13169498233 }, { "avg_trades": 4180257, "avg_volume_usd": 1002030520, "day": "tuesday", "days_counted": 13, "share_pct": 14.2607, "total_volume_usd": 13026396763 }, { "avg_trades": 4330613, "avg_volume_usd": 1440396094, "day": "wednesday", "days_counted": 12, "share_pct": 18.9226, "total_volume_usd": 17284753124 } ] }, "chain": "robinhood", "daily": { "busiest_day": { "ts": 1792972800000, "volume_usd": 556198238 }, "days": 3, "rows": [ { "buy_volume_usd": 247729766, "sell_volume_usd": 218992798, "trades": 1389513, "ts": 1792886400000, "volume_usd": 466722564, "wash_volume_usd": 50319274 }, { "buy_volume_usd": 286515806, "sell_volume_usd": 269682432, "trades": 1621146, "ts": 1792972800000, "volume_usd": 556198238, "wash_volume_usd": 50493821 }, { "buy_volume_usd": 237548924, "sell_volume_usd": 204145666, "trades": 1521812, "ts": 1793059200000, "volume_usd": 441694590, "wash_volume_usd": 50553407 } ] }, "hourly": { "busiest_hour": { "ts": 1793210400000, "volume_usd": 60323335 }, "hours": 48, "rows": [ { "buy_volume_usd": 6716118, "sell_volume_usd": 6323281, "trades": 53655, "ts": 1793052000000, "volume_usd": 13039399, "wash_volume_usd": 105689 }, { "buy_volume_usd": 9419407, "sell_volume_usd": 7621334, "trades": 59499, "ts": 1793055600000, "volume_usd": 17040740, "wash_volume_usd": 12295.4 }, { "buy_volume_usd": 8410243, "sell_volume_usd": 7053796, "trades": 60264, "ts": 1793059200000, "volume_usd": 15464040, "wash_volume_usd": 75408.9 } ] }, "method": { "caught_up": true, "data_since_ts": 1779484440000, "live": "windows up to 1h from the live trade flow (chain time); longer windows from complete minutes plus the live flow", "outliers": "excluded: single trades valued above $25000000 (mispriced quotes), counted in outlier_trades", "table_through_ts": 1793224500000, "volume": "organic DEX volume in USD at trade time (Uniswap V2/V3/V4, launchpad curves)", "wash": "excluded: same-tx round trips — buys and sells of one token in one pool inside one tx that cancel within 2%" }, "tz": "UTC", "windows": { "180d": { "buy_volume_usd": 54358559462, "buys": 253826654, "change_pct": null, "complete": false, "outlier_trades": 762, "prev_volume_usd": null, "sell_volume_usd": 52435524640, "sells": 204573895, "tokens": 1738934, "traders": 8246046, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 458400549, "volume_usd": 106794084102, "wash_trades": 1140815, "wash_volume_usd": 43228252019 }, "1h": { "buy_volume_usd": 13832591, "buys": 73433, "change_pct": -12.0881, "complete": true, "outlier_trades": 0, "prev_volume_usd": 31025009, "sell_volume_usd": 13442088, "sells": 75039, "tokens": 1747, "traders": 20684, "trades": 148472, "volume_usd": 27274679, "wash_trades": 27, "wash_volume_usd": 2621.56 }, "1m": { "buy_volume_usd": 437276, "buys": 2297, "change_pct": -6.49047, "complete": true, "outlier_trades": 0, "prev_volume_usd": 912411, "sell_volume_usd": 415915, "sells": 2293, "tokens": 181, "traders": 1326, "trades": 4590, "volume_usd": 853191, "wash_trades": 0, "wash_volume_usd": 0 }, "1s": { "buy_volume_usd": 3078.99, "buys": 36, "change_pct": -50.5284, "complete": true, "outlier_trades": 0, "prev_volume_usd": 22701.8, "sell_volume_usd": 8151.96, "sells": 52, "tokens": 21, "traders": 49, "trades": 88, "volume_usd": 11230.9, "wash_trades": 0, "wash_volume_usd": 0 }, "24h": { "buy_volume_usd": 286730820, "buys": 902381, "change_pct": 20.2008, "complete": true, "outlier_trades": 0, "prev_volume_usd": 445610023, "sell_volume_usd": 248895996, "sells": 868651, "tokens": 13008, "traders": 153221, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 1771032, "volume_usd": 535626816, "wash_trades": 17601, "wash_volume_usd": 100833980 }, "30d": { "buy_volume_usd": 12247569095, "buys": 34846699, "change_pct": -51.5393, "complete": true, "outlier_trades": 69, "prev_volume_usd": 48875200678, "sell_volume_usd": 11437699166, "sells": 31074225, "tokens": 291323, "traders": 2263899, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 65920924, "volume_usd": 23685268262, "wash_trades": 296158, "wash_volume_usd": 5483273594 }, "30s": { "buy_volume_usd": 185288, "buys": 1118, "change_pct": -25.6305, "complete": true, "outlier_trades": 0, "prev_volume_usd": 489301, "sell_volume_usd": 178603, "sells": 1202, "tokens": 124, "traders": 790, "trades": 2320, "volume_usd": 363891, "wash_trades": 0, "wash_volume_usd": 0 }, "5m": { "buy_volume_usd": 1526559, "buys": 7394, "change_pct": 45.1834, "complete": true, "outlier_trades": 0, "prev_volume_usd": 2700471, "sell_volume_usd": 2394075, "sells": 9124, "tokens": 464, "traders": 4438, "trades": 16518, "volume_usd": 3920634, "wash_trades": 0, "wash_volume_usd": 0 }, "6h": { "buy_volume_usd": 105598591, "buys": 321121, "change_pct": 52.3693, "complete": true, "outlier_trades": 0, "prev_volume_usd": 133649465, "sell_volume_usd": 98042204, "sells": 329945, "tokens": 5441, "traders": 63519, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 651066, "volume_usd": 203640796, "wash_trades": 541, "wash_volume_usd": 359759 }, "7d": { "buy_volume_usd": 1909691103, "buys": 5753033, "change_pct": -31.3766, "complete": true, "outlier_trades": 0, "prev_volume_usd": 5322350520, "sell_volume_usd": 1742687772, "sells": 5560924, "tokens": 58647, "traders": 500833, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 11313957, "volume_usd": 3652378875, "wash_trades": 66125, "wash_volume_usd": 453119545 }, "90d": { "buy_volume_usd": 46760389080, "buys": 208523175, "change_pct": null, "complete": true, "outlier_trades": 343, "prev_volume_usd": null, "sell_volume_usd": 45143857321, "sells": 166892984, "tokens": 1441104, "traders": 7052878, "traders_note": "unique traders / tokens: approximate (HyperLogLog), up to the last complete minute", "trades": 375416159, "volume_usd": 91904246401, "wash_trades": 953623, "wash_volume_usd": 41341982607 } } }, "meta": { "block": 100406767, "block_age_ms": 1146, "block_ts": 1793225074000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 3, "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fvolume&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fchain%2Fvolume-history%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Discovery & search API > Token lists (new, bonding, graduating, trending, top gainers and losers) and search across tokens, pools, wallets and hooks on Robinhood Chain. Source: https://docs.crius.sh/reference/discovery/ · Updated 2026-10-28 Find tokens: curated lists with filters, and a fast search box backend. ## Endpoints [GET /tokens Token lists Anonymous · 1 cr](https://docs.crius.sh/reference/discovery/token-lists/) [GET /search Search Anonymous · 1 cr](https://docs.crius.sh/reference/discovery/search/) --- # Search > Prefix search over token names and symbols, and exact match on token, pool, wallet and hook addresses and v4 pool ids. Source: https://docs.crius.sh/reference/discovery/search/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/search Prefix search over token names and symbols, and exact match on token, pool, wallet and hook addresses and v4 pool ids. `type` narrows the result kind; up to 20 results. > Prefix on name / symbol, exact on address / pool id. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `q`string Default `shoot` Search text: a name or symbol prefix, or an exact address / pool id. `type`string Filter by item type. Comma list of `token`, `pool`, `wallet`, `hook`. `limit`integer Default `10` Maximum number of items to return. Up to 20. ## Guides that use this endpoint [**Build a Telegram token scanner bot for Robinhood Chain**Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples.](https://docs.crius.sh/guides/build-a-telegram-token-scanner/)[**Search Robinhood Chain tokens, pools and wallets by name or address**Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included.](https://docs.crius.sh/guides/search-tokens/)[**Use the Crius API from AI agents (OpenAPI, llms.txt, MCP)**Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips.](https://docs.crius.sh/guides/use-crius-with-ai-agents/)[**How to create a token on Robinhood Chain (launchpads compared)**The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data.](https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More discovery & search endpoints [GET/tokensToken listsAnonymous · 1 cr](https://docs.crius.sh/reference/discovery/token-lists/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/search?q=charge&limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/search?q=charge&limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/search?q=charge&limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeairh", "website": "https://chargeai.bid/" }, "liquidity_usd": 5611.81, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "name": "Charge AI", "price_usd": 0.00000388948, "symbol": "CHARGE", "type": "token" }, { "address": "0x202e72dcbc815ca222f1a0674dd08755545b1329", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeitdotfun", "website": "https://chargeit.fun/" }, "liquidity_usd": 4869.43, "logo": "https://api.crius.sh/v1/robinhood/logo/0x202e72dcbc815ca222f1a0674dd08755545b1329.png?size=128", "name": "CHARGE", "price_usd": 0.00000293605, "symbol": "CHARGE", "type": "token" }, { "address": "0xc15f9324d2742387f98e2dba6b3745e5390113ec", "label": null, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeitdotfun", "website": "https://chargeit.fun/" }, "liquidity_usd": 2490.27, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc15f9324d2742387f98e2dba6b3745e5390113ec.png?size=128", "name": "CHARGE", "price_usd": 0.00000683926, "symbol": "CHARGE", "type": "token" } ], "meta": { "block": 100406952, "block_age_ms": 1260, "block_ts": 1793225093000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 11, "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fsearch&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fdiscovery%2Fsearch%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Token lists > Lists: new, bonding, graduating, graduated, trending, top_volume, top_gainers, top_losers, top_market_cap (tokens traded in the last 30 days by market cap;… Source: https://docs.crius.sh/reference/discovery/token-lists/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/tokens Lists: `new`, `bonding`, `graduating`, `graduated`, `trending`, `top_volume`, `top_gainers`, `top_losers`, `top_market_cap` (tokens traded in the last 30 days by market cap; prices from thin markets don't rank). Filter by `launchpad`, `quote`, `min_liquidity_usd`, `min_volume_usd`, `min_market_cap_usd` / `max_market_cap_usd` (e.g. `min_market_cap_usd=100000`) and `created_after_ts`; `window` picks the stats window. Up to 100 per page. `trending` only lists clean tokens: no crash (price under 90% below its peak in the window), $1,000+ liquidity, real holders (20+, and at least 10% of the window's traders), no insider or wallet-farm launch, no bot distribution, no single wallet holding 40%+ of the liquidity unlocked. `clean=true` applies the same checks to any other list, e.g. `list=top_volume&clean=true` for volume leaders without rugs or wash trading. > trending ranks real demand: a token needs a price less than 90% below its peak in the window (rugs drop out), $1,000+ liquidity, 20+ holders, and holders at least 10% of the window's traders (wash trading spreads volume over wallets that don't keep the token), no insider launch (one wallet sniping 50%+ of supply in the first 10 blocks, or a wallet farm holding the supply), no bot distribution (25+ of the top 100 holders with near-identical balances), and no single wallet holding 40%+ of the liquidity unlocked (it could pull the market); see /security launch. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `list`string Default `trending` Which list to return. One of `new`, `bonding`, `graduating`, `graduated`, `trending`, `top_volume`, `top_gainers`, `top_losers`, `top_market_cap`. `window`string Stats window. From `1s` to `24h`. `launchpad`string Launchpad id, such as `pons` or `flap` (see /launchpads). `quote`string Quote asset of the token's main pool. One of `eth`, `usdg`. `min_liquidity_usd`number Only tokens with at least this much liquidity (USD). `min_volume_usd`number Only tokens with at least this much volume in the window (USD). `min_market_cap_usd`number E.g. 100000. `max_market_cap_usd`number `created_after_ts`integer Only tokens created after this time (unix ms). `clean`boolean Default `false` Trending's quality filters on any list (no rugs, wash trading or insider launches) `limit`integer Default `50` Maximum number of items to return. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Build a Robinhood Chain token screener**Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code.](https://docs.crius.sh/guides/build-a-token-screener/)[**Find new tokens on Robinhood Chain as they launch**List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API.](https://docs.crius.sh/guides/find-new-tokens/)[**Get trending Robinhood Chain tokens (without rugs and wash trading)**Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses.](https://docs.crius.sh/guides/find-trending-tokens/)[**Get new Robinhood Chain tokens and graduations in real time**Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token.](https://docs.crius.sh/guides/stream-new-tokens/)[**Find Robinhood Chain tokens above a market cap**Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses.](https://docs.crius.sh/guides/find-tokens-by-market-cap/)[**Build a Robinhood Chain stats dashboard**Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code.](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/)[**Track Robinhood Chain bonding-curve tokens about to graduate**Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation.](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/)[**Get Robinhood Chain launchpad stats (launches, graduations, volume)**Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses.](https://docs.crius.sh/guides/get-launchpad-stats/)[**Market cap, FDV and circulating supply of a Robinhood Chain token (token supply API)**Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed.](https://docs.crius.sh/guides/market-cap-fdv-and-supply/)[**How to create a token on Robinhood Chain (launchpads compared)**The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data.](https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More discovery & search endpoints [GET/searchSearchAnonymous · 1 cr](https://docs.crius.sh/reference/discovery/search/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=trending&window=24h&limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "address": "0xd086f891229cd123aadfcae7c4b40150a80fd9d7", "buy_volume_usd": { "1h": 846676, "24h": 1760953, "5m": 213539, "6h": 1760953 }, "buyers": { "1h": 2862, "24h": 4951, "5m": 893, "6h": 4951 }, "buys": { "1h": 5160, "24h": 10660, "5m": 1143, "6h": 10660 }, "change_pct": { "1h": 219.677, "24h": 34319.8, "5m": 3.97796, "6h": 34319.8 }, "created_block": 100319502, "created_ts": 1793216058240, "decimals": 18, "fdv_usd": 2836574, "holders": 2857, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/search?q=0xd086f891229cd123aadfcae7c4b40150a80fd9d7&src=typed_query&f=live", "website": "https://xdcoinsol.lol" }, "liquidity_usd": 723990, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd086f891229cd123aadfcae7c4b40150a80fd9d7.png?size=128", "market_cap_usd": 2552917, "name": "Pizza", "price_eth": 0.00000120424, "price_usd": 0.00283657, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 706205, "24h": 1465984, "5m": 207484, "6h": 1465984 }, "sellers": { "1h": 1951, "24h": 3642, "5m": 630, "6h": 3642 }, "sells": { "1h": 7995, "24h": 17196, "5m": 1833, "6h": 17196 }, "status": null, "symbol": "PIZZA", "traders": { "1h": 3401, "24h": 5197, "5m": 1288, "6h": 5197 }, "txns": { "1h": 8316, "24h": 17544, "5m": 1915, "6h": 17544 }, "volume_usd": { "1h": 1552881, "24h": 3226937, "5m": 421023, "6h": 3226937 } }, { "address": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", "buy_volume_usd": { "1h": 68152.3, "24h": 3574310, "5m": 1310.32, "6h": 2375164 }, "buyers": { "1h": 168, "24h": 2815, "5m": 15, "6h": 1546 }, "buys": { "1h": 369, "24h": 11920, "5m": 17, "6h": 5582 }, "change_pct": { "1h": 0.783146, "24h": 25.2392, "5m": -1.01199, "6h": 21.3351 }, "created_block": 9721433, "created_ts": 1784051310300, "decimals": 18, "fdv_usd": 80269321, "holders": 58015, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/artificiallyinu", "website": "https://artificialinu.com/" }, "liquidity_usd": 4181412, "logo": "https://api.crius.sh/v1/robinhood/logo/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18.png?size=128", "market_cap_usd": 80102641, "name": "Artificial Inu", "price_eth": 0.0000343898, "price_usd": 0.0810048, "progress_pct": null, "quote": "PONS", "sell_volume_usd": { "1h": 50026.5, "24h": 3026550, "5m": 4390.97, "6h": 1840520 }, "sellers": { "1h": 151, "24h": 3051, "5m": 15, "6h": 1664 }, "sells": { "1h": 287, "24h": 12095, "5m": 20, "6h": 5933 }, "status": "launched", "symbol": "AI", "traders": { "1h": 272, "24h": 4132, "5m": 27, "6h": 2294 }, "txns": { "1h": 454, "24h": 14552, "5m": 28, "6h": 6627 }, "volume_usd": { "1h": 118179, "24h": 6600860, "5m": 5701.29, "6h": 4215684 } }, { "address": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "buy_volume_usd": { "1h": 305614, "24h": 5466111, "5m": 20057.3, "6h": 2772574 }, "buyers": { "1h": 229, "24h": 1996, "5m": 56, "6h": 790 }, "buys": { "1h": 847, "24h": 16482, "5m": 104, "6h": 6874 }, "change_pct": { "1h": 0.3314, "24h": -1.40466, "5m": -0.235953, "6h": -1.21643 }, "created_block": 153563, "created_ts": 1782222069300, "decimals": 18, "fdv_usd": 18876187, "holders": 192283, "launchpad": null, "launchpad_name": null, "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 5815054, "logo": null, "market_cap_usd": 18876064, "name": "NVIDIA • Robinhood Token", "price_eth": 0.0911626, "price_usd": 214.732, "progress_pct": null, "quote": "USDG", "sell_volume_usd": { "1h": 159139, "24h": 6030012, "5m": 54077.9, "6h": 3340517 }, "sellers": { "1h": 224, "24h": 2645, "5m": 57, "6h": 1101 }, "sells": { "1h": 678, "24h": 18554, "5m": 151, "6h": 8629 }, "status": null, "symbol": "NVDA", "traders": { "1h": 325, "24h": 3519, "5m": 83, "6h": 1422 }, "txns": { "1h": 1413, "24h": 32946, "5m": 240, "6h": 14457 }, "volume_usd": { "1h": 464753, "24h": 11496124, "5m": 74135.1, "6h": 6113091 } } ], "meta": { "block": 100406892, "block_age_ms": 1238, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 117, "list": "trending", "next_cursor": "3", "safe_block": 100401329, "stats_since": "chain_start", "window": "24h" } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fdiscovery%2Ftoken-lists%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Holders & traders API > Live holder lists, holder snapshots at any past block, time or market cap, diamond-hand cohorts, holder count history and top traders with PnL. Source: https://docs.crius.sh/reference/holders/ · Updated 2026-10-28 Holder data for every ERC-20 on the chain, live and historical. Points in time (`at`, `from`, `to`) accept several forms: | Form | Meaning | | --- | --- | | `block:95000000` | an exact L2 block | | `ts:1792000000000` | the last block at or before that time (unix ms) | | `mcap:50000` | the block where market cap first crossed $50k (`mcap_crossing=first|last`) | | `launch`, `graduation`, `ath`, `now` | lifecycle labels | ## Endpoints [GET /token/{address}/holders Live holders Free · 2 cr](https://docs.crius.sh/reference/holders/live-holders/) [GET /token/{address}/holders/snapshot Holder snapshot Free · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/) [GET /token/{address}/holders/cohort Holder cohort Starter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/) [GET /token/{address}/holders/history Holder count history Starter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/) [GET /token/{address}/traders Top traders Free · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) --- # Holder cohort > Wallets that held through a window. A holder qualifies when it stayed above a size threshold (min_usd, min_balance or min_pct); with continuous=true it must… Source: https://docs.crius.sh/reference/holders/holder-cohort/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/holders/cohort Wallets that held through a window. A holder qualifies when it stayed above a size threshold (`min_usd`, `min_balance` or `min_pct`); with `continuous=true` it must hold for the whole window, and `reset_on` decides what breaks continuity (`sell` by default). `entered_before=mcap:20000` keeps only wallets that first qualified before that point. Sort by hold time, balance or entry market cap (`sort=hold_time|balance|entry_mcap`). > Continuity with reset on sell / decrease / below threshold. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `from`string Default `trading_open` Start of the window (`block:`, `ts:`, `mcap:` or a label). `to`string Default `now` End of the window (same forms as `from`). `min_usd`number Default `50` Only items worth at least this many USD. `min_balance`number Minimum balance in token units. `min_pct`number Minimum share of supply, in percent. `continuous`boolean Default `false` `true`: the holder must stay above the threshold for the whole window. `reset_on`string Default `sell` One of `sell`, `any_decrease`, `below_threshold`, `none`. `min_hold_s`integer Minimum continuous hold time inside the window, in seconds. `entered_before`string Only holders that first qualified before this point (e.g. `mcap:20000`). `exclude`string Comma list of holder classes to leave out, such as `infra` (pools, lockers, burn) or `bots`. Comma list of `infra`, `dev`, `snipers`. `sort`string Default `hold_time` Sort order. One of `hold_time`, `balance`, `entry_mcap`. `limit`integer Default `100` Maximum number of items to return. ## Guides that use this endpoint [**Get a token's holders at a past block, time or market cap**Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder.](https://docs.crius.sh/guides/get-historical-holders/)[**Find holders who held through a run (holder cohorts)**Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example.](https://docs.crius.sh/guides/find-diamond-hand-holders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More holders & traders endpoints [GET/token/{address}/holdersLive holdersFree · 2 cr](https://docs.crius.sh/reference/holders/live-holders/)[GET/token/{address}/holders/snapshotHolder snapshotFree · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/)[GET/token/{address}/holders/historyHolder count historyStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/)[GET/token/{address}/tradersTop tradersFree · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap%3A10000&to=now&min_usd=50&continuous=true&reset_on=sell&exclude=infra" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap%3A10000&to=now&min_usd=50&continuous=true&reset_on=sell&exclude=infra", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/cohort?from=mcap%3A10000&to=now&min_usd=50&continuous=true&reset_on=sell&exclude=infra", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "criteria": { "continuous": false, "exclude": [], "min_balance": null, "min_hold_s": null, "min_pct": null, "min_usd": null, "reset_on": "sell" }, "holders": [ { "address": "0xfee5fee50000062bd986e86502c5acdf989067a0", "balance_at_from": 5758.56, "balance_now": 47534.9, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 5758.56, "pnl_usd": null, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [ "contract" ], "value_usd_now": 0.183244 }, { "address": "0xb823bd7738b61547221f54bb3410b94326aae1eb", "balance_at_from": 497321, "balance_now": 497321, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 497321, "pnl_usd": -22.1233, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 1.91714 }, { "address": "0x38c16e94e79383a5906449fc84477c1a7b19b613", "balance_at_from": 8344519, "balance_now": 0.00000000214748, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 0.00000000214748, "pnl_usd": -298.108, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 0.00000000000000827841 }, { "address": "0x8e56f6476d1361cdc6e75798c83354e70d033f23", "balance_at_from": 57.0322, "balance_now": 57.0322, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 57.0322, "pnl_usd": -0.00219735, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [ "smart_account" ], "value_usd_now": 0.000219856 }, { "address": "0xfd2a475d7ce02ec077867d72177063b5c2ab01b6", "balance_at_from": 429.912, "balance_now": 429.912, "entry_mcap_usd": 51583.8, "hold_time_s": 1234652, "min_balance_in_window": 429.912, "pnl_usd": -0.396922, "qualified_since_block": 88461359, "qualified_since_ts": 1791990426900, "reset_history": [], "resets": 0, "sells_in_window": 0, "tags": [], "value_usd_now": 0.00165728 } ], "never_reached_threshold": 0, "qualified": 224, "reset_out": 942, "started_qualified": 229, "window": { "from": { "at": "mcap:50000", "block": 88461359, "ts": 1791990426900 }, "to": { "at": "now", "block": 100406815, "ts": 1793225079000 } } }, "meta": { "block": 100406816, "block_age_ms": 1088, "block_ts": 1793225079000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 86, "next_cursor": "5", "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fholders%2Fcohort&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fholders%2Fholder-cohort%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Holder count history > Holder count over time at a chosen interval, with your own definition of a holder (min_balance or min_usd). Source: https://docs.crius.sh/reference/holders/holder-count-history/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/holders/history Holder count over time at a chosen interval, with your own definition of a holder (`min_balance` or `min_usd`). Answers "what was the minimum and maximum number of holders during a period". > min / max / new / exited per interval. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `interval`string Default `1h` Bucket size. One of `1m`, `5m`, `15m`, `1h`, `4h`, `1d`. `from`string Start of the window (`block:`, `ts:`, `mcap:` or a label). `to`string End of the window (same forms as `from`). `min_balance`number Minimum balance in token units. `min_usd`number Only items worth at least this many USD. `exclude`string Comma list of holder classes to leave out, such as `infra` (pools, lockers, burn) or `bots`. ## Guides that use this endpoint [**Track a token's holder count over time**Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example.](https://docs.crius.sh/guides/track-holder-count/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More holders & traders endpoints [GET/token/{address}/holdersLive holdersFree · 2 cr](https://docs.crius.sh/reference/holders/live-holders/)[GET/token/{address}/holders/snapshotHolder snapshotFree · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/)[GET/token/{address}/holders/cohortHolder cohortStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/)[GET/token/{address}/tradersTop tradersFree · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1h&from=launch&to=now" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1h&from=launch&to=now", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/history?interval=1h&from=launch&to=now", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "exited": [ 3082, 1030, 462, 216, 148 ], "history": "complete", "holder_definition": { "exclude": [], "min_balance": null, "min_usd": null, "note": "" }, "holders": [ 421, 381, 359, 309, 294 ], "interval": "1d", "max": [ 476, 429, 382, 359, 313 ], "min": [ 1, 378, 353, 306, 294 ], "new": [ 3503, 990, 440, 166, 133 ], "summary": { "max": 476, "max_ts": 1791936000000, "min": 1, "min_ts": 1791936000000, "now": 238 }, "t": [ 1791936000000, 1792022400000, 1792108800000, 1792195200000, 1792281600000 ] }, "meta": { "block": 100406819, "block_age_ms": 372, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 41, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fholders%2Fhistory&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fholders%2Fholder-count-history%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Holder snapshot > Holders as they were at a past point, valued at that moment's price. Holder snapshot on Robinhood Chain: parameters, plan, credits, code and a real response. Source: https://docs.crius.sh/reference/holders/holder-snapshot/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/holders/snapshot Holders **as they were at a past point**, valued at that moment's price. `compare_to=now` adds each holder's balance change since then, which answers "who bought before $50k market cap, and are they still holding?". > Valued at that moment's price; compare\_to=now adds change per holder. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `at`string Default `trading_open` The point in time to look at (see the forms above). One of `block:N`, `ts:MS`, `mcap:USD`, `launch`, `trading_open`, `graduation`, `ath`, `now`. `mcap_crossing`string Default `first` Which crossing of the market cap level to use. One of `first`, `last`. `compare_to`string Default `now` Add each holder's change since another point (`now` or any `at` form). `exclude`string Comma list of holder classes to leave out, such as `infra` (pools, lockers, burn) or `bots`. `min_usd`number Only items worth at least this many USD. `min_pct`number Minimum share of supply, in percent. `tag`string Only wallets with this tag (`sniper`, `bot`, `whale`, `fresh`, `dev`, `insider`, `bundler`, `top_trader`). `limit`integer Default `100` Maximum number of items to return. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Get the holders of a Robinhood Chain token (token holders API)**Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share.](https://docs.crius.sh/guides/get-token-holders/)[**Get a token's holders at a past block, time or market cap**Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder.](https://docs.crius.sh/guides/get-historical-holders/)[**Find holders who held through a run (holder cohorts)**Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example.](https://docs.crius.sh/guides/find-diamond-hand-holders/)[**What is the best Robinhood Chain data API? How to choose one**How to choose a Robinhood Chain data API: nine criteria, from launchpads and realized taxes to WebSockets and free plans, and a sourced provider comparison.](https://docs.crius.sh/guides/choose-a-robinhood-chain-data-api/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More holders & traders endpoints [GET/token/{address}/holdersLive holdersFree · 2 cr](https://docs.crius.sh/reference/holders/live-holders/)[GET/token/{address}/holders/cohortHolder cohortStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/)[GET/token/{address}/holders/historyHolder count historyStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/)[GET/token/{address}/tradersTop tradersFree · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=mcap%3A50000&compare_to=now&exclude=infra" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=mcap%3A50000&compare_to=now&exclude=infra", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders/snapshot?at=mcap%3A50000&compare_to=now&exclude=infra", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "distribution": { "top10_ex_infra_pct": 20.2394, "top10_incl_infra_pct": 88.256, "top10_pct": 20.2394 }, "history": "complete", "holders": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "balance": 599611856.72294939695548577, "cost_basis_usd": null, "label": "uniswap_v4_pool_manager", "pct": 59.9612, "rank": 1, "tags": [ "pool" ], "unrealized_pnl_usd": null, "value_eth": 1.4505, "value_usd": 3617.23 }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "balance": 81632653.061224486519511236, "cost_basis_usd": null, "label": "pons_v2_launch_locker", "pct": 8.16327, "rank": 2, "tags": [ "lp_locker" ], "unrealized_pnl_usd": null, "value_eth": 0.197474, "value_usd": 492.459 }, { "address": "0xcae68632857541d7b625f5af57149a77c80b15f7", "balance": 40394446.124537182821971423, "cost_basis_usd": 437.688, "label": null, "pct": 4.03944, "rank": 3, "tags": [ "smart_account", "fomo" ], "unrealized_pnl_usd": -194.003, "value_eth": 0.0977165, "value_usd": 243.684 }, { "address": "0xe683eb5c66b0c55c54ce45d46a3bf0a69d809c8f", "balance": 29879481.370714222341354462, "cost_basis_usd": 515.975, "label": null, "pct": 2.98795, "rank": 4, "tags": [ "smart_account" ], "unrealized_pnl_usd": -335.724, "value_eth": 0.0722802, "value_usd": 180.252 }, { "address": "0x000000000000000000000000000000000000dead", "balance": 29840058.774195638068253872, "cost_basis_usd": null, "label": "burn", "pct": 2.98401, "rank": 5, "tags": [ "burn" ], "unrealized_pnl_usd": null, "value_eth": 0.0721848, "value_usd": 180.014 } ], "holders_count": 203, "price_at_snapshot": { "eth": 0.00000000241906, "eth_usd": 2493.79, "usd": 0.00000603262 }, "snapshot": { "at": "ts:1792620279327", "block": 94616288, "ts": 1792620279800 }, "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "total_value_usd": 6032.62 }, "meta": { "block": 100406812, "block_age_ms": 701, "block_ts": 1793225079000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 38, "next_cursor": "5", "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fholders%2Fsnapshot&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fholders%2Fholder-snapshot%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Live holders > The current holder list, ranked by balance, with each holder's share of supply, USD value and labels (pools, lockers, burn addresses, the dev). Source: https://docs.crius.sh/reference/holders/live-holders/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/holders The current holder list, ranked by balance, with each holder's share of supply, USD value and labels (pools, lockers, burn addresses, the dev). Also returns the holder count and top-10 concentration. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `limit`integer Default `100` Maximum number of items to return. Up to 500. `exclude`string Comma list of holder classes to leave out, such as `infra` (pools, lockers, burn) or `bots`. ## Key response fields - `count`, `top10_pct` - `holders[]`: `rank`, `address`, `balance`, `pct`, `value_usd`, `value_eth`, `label` ## Guides that use this endpoint [**Get the holders of a Robinhood Chain token (token holders API)**Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share.](https://docs.crius.sh/guides/get-token-holders/)[**Get a token's holders at a past block, time or market cap**Get a Robinhood Chain token's holders at any past block, time, market cap or launch stage, valued at that moment's price, with cost basis per holder.](https://docs.crius.sh/guides/get-historical-holders/)[**Track a token's holder count over time**Chart a Robinhood Chain token's holder count over time: min, max, new and exited holders per interval, with your own definition of a holder. Real example.](https://docs.crius.sh/guides/track-holder-count/)[**Move from raw RPC calls to the Crius API on Robinhood Chain**Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs.](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/)[**Get wallet token balances on Robinhood Chain (balances API)**Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices.](https://docs.crius.sh/guides/get-wallet-token-balances/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More holders & traders endpoints [GET/token/{address}/holders/snapshotHolder snapshotFree · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/)[GET/token/{address}/holders/cohortHolder cohortStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/)[GET/token/{address}/holders/historyHolder count historyStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/)[GET/token/{address}/tradersTop tradersFree · 5 cr](https://docs.crius.sh/reference/holders/top-traders/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "balances": "verified_onchain", "count": 178, "distribution": { "top10_pct": 13.436 }, "history": "complete", "holders": [ { "address": "0x1860e8b874ed7742ae5459af731687ecb576c9fd", "balance": 28729479.389247917189540117, "label": null, "pct": 2.87295, "rank": 1, "value_eth": 0.0474081, "value_usd": 111.806 }, { "address": "0x346f5777f5652bd561dcd830e638bc40d3e1cf3d", "balance": 25566954.227971953484331514, "label": null, "pct": 2.5567, "rank": 2, "value_eth": 0.0421894, "value_usd": 99.4981 }, { "address": "0xa975e46d6552fb0ef85f7e9f7b640a058dc368bd", "balance": 23260835.335709034922247096, "label": null, "pct": 2.32608, "rank": 3, "value_eth": 0.038384, "value_usd": 90.5235 }, { "address": "0xf4e322c50010e00878b8d6bbb2c495d90097e58f", "balance": 19090692.939108585371870819, "label": null, "pct": 1.90907, "rank": 4, "value_eth": 0.0315026, "value_usd": 74.2947 }, { "address": "0x8e6be350c1276d3276cead49859aa435d77ac9eb", "balance": 12214695.452807030766083489, "label": null, "pct": 1.22147, "rank": 5, "value_eth": 0.0201561, "value_usd": 47.5356 } ], "ledger_reliable": true }, "meta": { "block": 100436633, "block_age_ms": 414, "block_ts": 1793228150000, "chain": "robinhood", "finalized_block": 100427397, "lag_ms": 17, "safe_block": 100431079 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fholders&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fholders%2Flive-holders%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Top traders > Traders of the token ranked by PnL, realized PnL, volume, buys or ROI over a window (1h, 24h, 7d, all), with wallet tags: dev, sniper, whale, smart_account… Source: https://docs.crius.sh/reference/holders/top-traders/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/traders Traders of the token ranked by PnL, realized PnL, volume, buys or ROI over a window (`1h`, `24h`, `7d`, `all`), with wallet tags: `dev`, `sniper`, `whale`, `smart_account` (EIP-7702 wallets), the app for app wallets (`fomo`), `exchange`, `contract`. - `tag`: only traders with any of these tags (comma list), e.g. `tag=smart_account` or `tag=fomo`. - `exclude`: leave out traders with any of these tags, e.g. `exclude=dev,sniper,exchange` for outside traders only. - Program contracts (bots, vaults, routers) are left out by default: top traders are wallets. `include_contracts=true` adds them back (or `tag=contract` for contracts only). Smart accounts are wallets and always included unless excluded. > Average cost; USD at trade time; unrealized at current price. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `sort`string Default `pnl` Sort order. One of `pnl`, `realized_pnl`, `volume`, `buys`, `roi`. `window`string Default `all` Stats window. One of `1h`, `24h`, `7d`, `all`. `tag`string Only wallets with this tag (`sniper`, `bot`, `whale`, `fresh`, `dev`, `insider`, `bundler`, `top_trader`). Only these tags, comma list: dev, sniper, whale, smart\_account, fomo, exchange, contract, …. `exclude`string Comma list of holder classes to leave out, such as `infra` (pools, lockers, burn) or `bots`. Leave out these tags, comma list, e.g. dev,sniper,exchange. `include_contracts`boolean Default `false` Program contracts are excluded by default. `limit`integer Default `50` Maximum number of items to return. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Find holders who held through a run (holder cohorts)**Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example.](https://docs.crius.sh/guides/find-diamond-hand-holders/)[**Find a token's top traders and their PnL**Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained.](https://docs.crius.sh/guides/get-top-traders-pnl/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More holders & traders endpoints [GET/token/{address}/holdersLive holdersFree · 2 cr](https://docs.crius.sh/reference/holders/live-holders/)[GET/token/{address}/holders/snapshotHolder snapshotFree · 5 cr](https://docs.crius.sh/reference/holders/holder-snapshot/)[GET/token/{address}/holders/cohortHolder cohortStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-cohort/)[GET/token/{address}/holders/historyHolder count historyStarter · 10 cr](https://docs.crius.sh/reference/holders/holder-count-history/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?sort=pnl&window=all&limit=20" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?sort=pnl&window=all&limit=20", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?sort=pnl&window=all&limit=20", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "address": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "avg_buy_usd": 0.00000842823, "avg_sell_usd": 0.0000532304, "balance": 0, "bought": 29080767.335830362668108408, "bought_eth": 0.099, "bought_usd": 245.099, "buys": 1, "cost_basis": "complete", "first_trade_ts": 1791983208000, "gas_spent_usd": 0.0875722, "holding_time_s": 118676, "last_trade_ts": 1792101884000, "pnl_usd": 1302.88, "rank": 1, "realized_pnl_usd": 1302.88, "roi_pct": 531.573, "sells": 7, "sold": 29080767.335830362668108408, "sold_eth": 0.635695, "sold_usd": 1547.98, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x7c79ad74d36dea424d08a5d326271bf03da81f6a", "avg_buy_usd": 0.00000790248, "avg_sell_usd": 0.0000343631, "balance": 0, "bought": 46475393.982901663958413733, "bought_eth": 0.1485, "bought_usd": 367.271, "buys": 2, "cost_basis": "complete", "first_trade_ts": 1791983183000, "gas_spent_usd": 0.0712204, "holding_time_s": 125872, "last_trade_ts": 1792109055000, "pnl_usd": 994.45, "rank": 2, "realized_pnl_usd": 994.45, "roi_pct": 270.767, "sells": 4, "sold": 37582304.39247174197236032, "sold_eth": 0.528147, "sold_usd": 1291.44, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x83055f3e7be4e289733bbc8c7bd42a6443177f07", "avg_buy_usd": 0.000023621, "avg_sell_usd": 0.0000471805, "balance": 0, "bought": 35569497.20243776424709037, "bought_eth": 0.3465, "bought_usd": 840.189, "buys": 3, "cost_basis": "complete", "first_trade_ts": 1791988168000, "gas_spent_usd": 0.0631376, "holding_time_s": 4039, "last_trade_ts": 1791992207000, "pnl_usd": 838, "rank": 3, "realized_pnl_usd": 838, "roi_pct": 99.7395, "sells": 3, "sold": 35569497.20243776424709037, "sold_eth": 0.691944, "sold_usd": 1678.19, "tags": [], "unrealized_pnl_usd": 0 } ], "meta": { "block": 100406823, "block_age_ms": 829, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 64, "next_cursor": "3", "pnl_method": "average cost; USD at trade time; unrealized at current price", "safe_block": 100401329, "window": "all" } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Ftraders&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fholders%2Ftop-traders%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Launchpads & fees API > Launchpad lifecycle (bonding curve progress, graduation), live launchpad stats, and fees, claims and receivers for Robinhood Chain tokens. Source: https://docs.crius.sh/reference/launchpads/ · Updated 2026-10-28 Robinhood Chain launchpads such as **Pons**, **Flap.sh**, **Bankr**, **Long.xyz**, **Flywheel** and **King of the Markets** are attributed automatically. Every response that mentions a launchpad carries a stable id (`launchpad`, use it in filters) and a display name (`launchpad_name`). ## Endpoints [GET /launchpads Launchpads Anonymous · 1 cr](https://docs.crius.sh/reference/launchpads/launchpads/) [GET /launchpads/{id} Launchpad detail Anonymous · 2 cr](https://docs.crius.sh/reference/launchpads/launchpad-detail/) [GET /token/{address}/launch Launch lifecycle Free · 2 cr](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [GET /token/{address}/fees Fees & claims Starter · 5 cr](https://docs.crius.sh/reference/launchpads/fees-claims/) --- # Fees & claims > Fees paid around a token over a window: gas (L2 and L1), LP fees, Uniswap protocol fees, hook fees and taxes, launchpad and creator fees and token tax, plus… Source: https://docs.crius.sh/reference/launchpads/fees-claims/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/fees Fees paid around a token over a window: gas (L2 and L1), LP fees, Uniswap protocol fees, hook fees and taxes, launchpad and creator fees and token tax, plus who claimed them and where they went. > Gas, LP fees, hook fees, creator tax, bonding-curve fees, token tax; Pons sweeps. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `window`string Default `24h` Stats window. One of `1h`, `24h`, `7d`, `all`. ## Guides that use this endpoint [**Get a Robinhood Chain token's fees, taxes and creator rewards**See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response.](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More launchpads & fees endpoints [GET/launchpadsLaunchpadsAnonymous · 1 cr](https://docs.crius.sh/reference/launchpads/launchpads/)[GET/launchpads/{id}Launchpad detailAnonymous · 2 cr](https://docs.crius.sh/reference/launchpads/launchpad-detail/)[GET/token/{address}/launchLaunch lifecycleFree · 2 cr](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees?window=7d" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees?window=7d", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/fees?window=7d", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "by_pool": [ { "dex": "uniswap_v4", "lp_usd": 0, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "token_tax_usd": 0, "volume_usd": 5.92732 } ], "claims": [], "launchpad": { "bonding_curve": { "fee_a": 0, "fee_a_usd": 0, "fee_b": 0, "fee_b_usd": 0 }, "creator_tax_usd": 0.119245, "hook_fee_usd": 0.0596227, "pending": { "buyback": "0", "creator_tax": "1037358686757100", "fees": "518679343378549" }, "swept_usd": { "buyback": 0, "creator": 0, "protocol": 0 } }, "receivers": [ { "address": "0x14a6f00bad1f4e21e2af4e317383c3d550378996", "creator_tax_bps": 200, "role": "creator_fee_recipient" }, { "address": "0x31ea5b453a6cd60f36203830de046ff32dec2cdb", "role": "launchpad_protocol", "share_bps": 3000 }, { "address": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "role": "launchpad_fee_escrow" } ], "totals_usd": { "bonding_curve": 0, "creator": 0.119245, "gas": 0.0365916, "hook": 0.0596227, "lp": 0, "token_tax": 0, "total": 0.21546, "uniswap_protocol": null }, "window": "24h" }, "meta": { "block": 100406855, "block_age_ms": 1148, "block_ts": 1793225083000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "notes": [ "USD at the current ETH price", "uniswap_protocol: protocol fee switch not indexed yet (null)" ], "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Ffees&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Flaunchpads%2Ffees-claims%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Launch lifecycle > A launchpad token's lifecycle: creator, curve, bonding progress, raised amount, graduation block and the pool it graduated into. Source: https://docs.crius.sh/reference/launchpads/launch-lifecycle/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/launch A launchpad token's lifecycle: creator, curve, bonding progress, raised amount, graduation block and the pool it graduated into. Tokens from unattributed factories return `data: null` with `meta.attribution = "unattributed_factory"`. > Pons config & fees read live from the chain, graduation details. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Guides that use this endpoint [**Get new Robinhood Chain tokens and graduations in real time**Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token.](https://docs.crius.sh/guides/stream-new-tokens/)[**Track Robinhood Chain bonding-curve tokens about to graduate**Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation.](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/)[**Get a Robinhood Chain token's fees, taxes and creator rewards**See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response.](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More launchpads & fees endpoints [GET/launchpadsLaunchpadsAnonymous · 1 cr](https://docs.crius.sh/reference/launchpads/launchpads/)[GET/launchpads/{id}Launchpad detailAnonymous · 2 cr](https://docs.crius.sh/reference/launchpads/launchpad-detail/)[GET/token/{address}/feesFees & claimsStarter · 5 cr](https://docs.crius.sh/reference/launchpads/fees-claims/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_stats": { "buys": 482, "first_indexed_block": 88385895, "history": "complete", "sells": 280, "unique_traders": 61, "volume_quote": 21.053399701262936019 }, "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fees": { "buyback_burn_bps": 5000, "buyback_enabled": false, "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "creator_fee_recipient": "0x14a6f00bad1f4e21e2af4e317383c3d550378996", "creator_tax_bps": 200, "escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook_fee_bps": 100, "pending": { "buyback": 0, "creator_tax": 0.0010373586867571, "currency": "ETH", "fees": 0.000518679343378549 }, "protocol_fee_recipient": "0x31ea5b453a6cd60f36203830de046ff32dec2cdb", "protocol_fee_share_bps": 3000, "snipe_tax": { "start_bps": 9900, "window_s": 3 } }, "graduation": { "block": 88461321, "blocks_to_graduate": 75435, "graduated_block_recorded": 88461321, "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "lp_position_id": 3790055, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_to_pool": 4.200000000000000236, "tokens_to_pool": 204081632.653061227766208523, "ts": 1791990423100 }, "launch_tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747", "launched_block": 88385886, "launched_ts": 1791982833600, "launched_via": "factory", "launchpad": "pons", "launchpad_name": "Pons", "pair_token": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "progress": { "pct": 100, "raised": 4.200000000000000236, "threshold": 4.2 }, "status": "graduated", "version": "v2" }, "meta": { "block": 100406852, "block_age_ms": 778, "block_ts": 1793225083000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 86, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Flaunch&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Flaunchpads%2Flaunch-lifecycle%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Launchpad detail > One launchpad: the list entry (lifetime launches and graduations, last 24h launches, graduations, trades, traders, volume by quote currency and fees) plus a… Source: https://docs.crius.sh/reference/launchpads/launchpad-detail/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/launchpads/{id} One launchpad: the list entry (lifetime launches and graduations, last 24h launches, graduations, trades, traders, volume by quote currency and fees) plus a daily history and its top 10 tokens by 24h volume. `days` sets the history length (default 30). Ids: `pons`, `flap`, `bankr`, `long`, `flywheel`, `standard_reserve`. > The list's entry plus a daily history (launches, graduations, trades, traders, volume, fees) and the top 10 tokens by 24h volume. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `id`stringrequired One of `pons`, `flap`, `bankr`, `long`, `flywheel`, `standard_reserve`. ## Query parameters `days`integer Default `30` 1..90 ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More launchpads & fees endpoints [GET/launchpadsLaunchpadsAnonymous · 1 cr](https://docs.crius.sh/reference/launchpads/launchpads/)[GET/token/{address}/launchLaunch lifecycleFree · 2 cr](https://docs.crius.sh/reference/launchpads/launch-lifecycle/)[GET/token/{address}/feesFees & claimsStarter · 5 cr](https://docs.crius.sh/reference/launchpads/fees-claims/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/pons?days=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/pons?days=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/pons?days=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 170878, "graduated": 14, "launches": 1430, "traders": 42760, "trades": 206278, "volume_usd": 19271245 }, { "date": "2026-10-27", "fees_usd": 177036, "graduated": 15, "launches": 1452, "traders": 57144, "trades": 263793, "volume_usd": 19464449 }, { "date": "2026-10-28", "fees_usd": 232042, "graduated": 16, "launches": 1690, "traders": 52250, "trades": 266666, "volume_usd": 23630413 } ] }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 110954, "tax": 144615, "total": 255569 }, "graduated": 10480, "graduated_24h": 17, "graduation_rate_pct": 1.46318, "launches_24h": 1781, "median_blocks_to_graduate": 2491, "tokens_launched": 716247, "traders_24h": 55079, "trades_24h": 285952, "volume_by_quote_usd_24h": { "eth": 13328235, "other": 1946513, "stock": 3097444, "usdg": 7490650 }, "volume_usd_24h": 25862841 }, "top_tokens_24h": [ { "address": "0xedbf91223639800bcd5756815caf908df3b890be", "buy_volume_usd": { "1h": 13166.8, "24h": 1501301, "5m": 708.542, "6h": 514376 }, "buyers": { "1h": 55, "24h": 1901, "5m": 6, "6h": 745 }, "buys": { "1h": 81, "24h": 4653, "5m": 6, "6h": 1464 }, "change_pct": { "1h": -6.26568, "24h": 65.1479, "5m": -0.773021, "6h": 13.4944 }, "created_block": 67325240, "created_ts": 1789845345000, "decimals": 18, "fdv_usd": 14106689, "holders": 4820, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/priors_trade", "website": "https://priors.trade/" }, "liquidity_usd": 942584, "logo": "https://api.crius.sh/v1/robinhood/logo/0xedbf91223639800bcd5756815caf908df3b890be.png?size=128", "market_cap_usd": 14106678, "name": "Priors Agents", "price_eth": 0.00000598885, "price_usd": 0.0141067, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 34344.3, "24h": 1401242, "5m": 462.802, "6h": 485007 }, "sellers": { "1h": 73, "24h": 1888, "5m": 6, "6h": 755 }, "sells": { "1h": 130, "24h": 4995, "5m": 8, "6h": 1535 }, "status": "graduated", "symbol": "PRIORS", "traders": { "1h": 119, "24h": 2579, "5m": 12, "6h": 1060 }, "txns": { "1h": 161, "24h": 7142, "5m": 13, "6h": 2096 }, "volume_usd": { "1h": 47511.1, "24h": 2902542, "5m": 1171.34, "6h": 999383 } }, { "address": "0x94641b97010608c3827fb058074889f19868ff33", "buy_volume_usd": { "1h": 15562.1, "24h": 529864, "5m": 815.808, "6h": 87540.8 }, "buyers": { "1h": 44, "24h": 1372, "5m": 5, "6h": 228 }, "buys": { "1h": 90, "24h": 3345, "5m": 5, "6h": 621 }, "change_pct": { "1h": 4.85445, "24h": 37.4979, "5m": 1.70944, "6h": 9.96024 }, "created_block": 76051465, "created_ts": 1790724560500, "decimals": 18, "fdv_usd": 4988990, "holders": 7132, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/VraxVerify", "twitter": "https://x.com/RobinhoodApp/status/2105077426481222125", "website": "https://vraxthecommander.cat/" }, "liquidity_usd": 586772, "logo": "https://api.crius.sh/v1/robinhood/logo/0x94641b97010608c3827fb058074889f19868ff33.png?size=128", "market_cap_usd": 4988889, "name": "Commander Vrax", "price_eth": 0.00000211802, "price_usd": 0.00498899, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 9369.91, "24h": 472466, "5m": 1189.91, "6h": 70634.6 }, "sellers": { "1h": 73, "24h": 1263, "5m": 8, "6h": 277 }, "sells": { "1h": 119, "24h": 3171, "5m": 12, "6h": 595 }, "status": "graduated", "symbol": "VRAX", "traders": { "1h": 96, "24h": 1859, "5m": 11, "6h": 408 }, "txns": { "1h": 128, "24h": 3830, "5m": 12, "6h": 635 }, "volume_usd": { "1h": 24932, "24h": 1002331, "5m": 2005.72, "6h": 158175 } }, { "address": "0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725", "buy_volume_usd": { "1h": 12089.9, "24h": 501099, "5m": 97.5853, "6h": 68251.9 }, "buyers": { "1h": 60, "24h": 1263, "5m": 1, "6h": 223 }, "buys": { "1h": 112, "24h": 3157, "5m": 1, "6h": 435 }, "change_pct": { "1h": -0.98306, "24h": 47.0227, "5m": -0.64655, "6h": -4.92164 }, "created_block": 47404695, "created_ts": 1787829863500, "decimals": 18, "fdv_usd": 7669642, "holders": 19014, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/MicroDuckNVDA", "website": "https://microduck.net/" }, "liquidity_usd": 643248, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725.png?size=128", "market_cap_usd": 7669633, "name": "microduck", "price_eth": 0.00000325607, "price_usd": 0.00766964, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 14193, "24h": 447864, "5m": 1441.41, "6h": 76639.5 }, "sellers": { "1h": 39, "24h": 1042, "5m": 3, "6h": 248 }, "sells": { "1h": 65, "24h": 2757, "5m": 5, "6h": 543 }, "status": "graduated", "symbol": "microduck", "traders": { "1h": 92, "24h": 1783, "5m": 4, "6h": 400 }, "txns": { "1h": 126, "24h": 4314, "5m": 4, "6h": 694 }, "volume_usd": { "1h": 26282.9, "24h": 948962, "5m": 1538.99, "6h": 144891 } } ], "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, "meta": { "block": 100410808, "block_age_ms": 623, "block_ts": 1793225487000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 257, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Flaunchpads%2F%7Bid%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Flaunchpads%2Flaunchpad-detail%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Launchpads > Every supported launchpad with its live stats: launches, graduations and volume. Source: https://docs.crius.sh/reference/launchpads/launchpads/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/launchpads Every supported launchpad with its live stats: launches, graduations and volume. > Lifetime launches and graduations; last 24h: launches, graduations, trades, traders, volume (every trade of the launchpad's tokens in any pool, before and after graduation) by quote currency (eth, usdg, stock tokens, other) and fees (LP fees and measured taxes). ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Guides that use this endpoint [**Build a Robinhood Chain stats dashboard**Build a Robinhood Chain analytics dashboard with the Crius API: DEX volume, trades, TVL, launches, gas and volume history in your time zone, with code.](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/)[**Get Robinhood Chain launchpad stats (launches, graduations, volume)**Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses.](https://docs.crius.sh/guides/get-launchpad-stats/)[**What is the best Robinhood Chain data API? How to choose one**How to choose a Robinhood Chain data API: nine criteria, from launchpads and realized taxes to WebSockets and free plans, and a sourced provider comparison.](https://docs.crius.sh/guides/choose-a-robinhood-chain-data-api/)[**How to create a token on Robinhood Chain (launchpads compared)**The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data.](https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More launchpads & fees endpoints [GET/launchpads/{id}Launchpad detailAnonymous · 2 cr](https://docs.crius.sh/reference/launchpads/launchpad-detail/)[GET/token/{address}/launchLaunch lifecycleFree · 2 cr](https://docs.crius.sh/reference/launchpads/launch-lifecycle/)[GET/token/{address}/feesFees & claimsStarter · 5 cr](https://docs.crius.sh/reference/launchpads/fees-claims/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 109888, "tax": 139840, "total": 249728 }, "graduated": 10479, "graduated_24h": 16, "graduation_rate_pct": 1.46306, "launches_24h": 1781, "median_blocks_to_graduate": 2490, "tokens_launched": 716241, "traders_24h": 54793, "trades_24h": 282607, "volume_by_quote_usd_24h": { "eth": 13311920, "other": 1629236, "stock": 3076503, "usdg": 7488610 }, "volume_usd_24h": 25506268 }, "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, { "contracts": { "launch_contracts": [ "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" ] }, "id": "flap", "name": "Flap.sh", "since_block": 4227932, "stats": { "fees_usd_24h": { "lp": 2011.32, "tax": 7332.7, "total": 9344.02 }, "graduated": 338, "graduated_24h": 1, "graduation_rate_pct": 0.0872587, "launches_24h": 1200, "median_blocks_to_graduate": 8533, "tokens_launched": 387354, "traders_24h": 3257, "trades_24h": 7870, "volume_by_quote_usd_24h": { "eth": 364111, "other": 16.2147, "stock": 5051.86, "usdg": 11553.7 }, "volume_usd_24h": 380733 }, "type": "config_driven", "website": "https://flap.sh" }, { "contracts": { "launch_contracts": [ "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" ] }, "id": "bankr", "name": "Bankr", "since_block": 1565844, "stats": { "fees_usd_24h": { "lp": 5006.22, "tax": 12930.7, "total": 17937 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 20, "median_blocks_to_graduate": null, "tokens_launched": 98672, "traders_24h": 1966, "trades_24h": 7282, "volume_by_quote_usd_24h": { "eth": 220967, "other": 25109.3, "stock": 262823, "usdg": 86535.8 }, "volume_usd_24h": 595435 }, "type": "config_driven", "website": "https://bankr.bot" } ], "meta": { "block": 100406698, "block_age_ms": 1356, "block_ts": 1793225067000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 202, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Flaunchpads&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Flaunchpads%2Flaunchpads%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Pools & hooks API > Pool details for Uniswap v2, v3 and v4 on Robinhood Chain, and Uniswap v4 hooks with decoded permissions and risk flags. Source: https://docs.crius.sh/reference/pools/ · Updated 2026-10-28 Pools are addressed by their pair/pool address (Uniswap v2 and v3) or their 32-byte pool id (Uniswap v4). Every v4 **hook** on chain is inspected, and re-inspected every 30 minutes: - **Permissions**, decoded from the hook address itself (its low 14 bits, as in Uniswap's `Hooks.sol`). - **Code**: what sits at the address (no code, a delegated wallet, a minimal or upgradeable proxy, a contract), its owner, and the admin functions in its logic (fee setter, pause, blacklist, withdraw, upgrade). - **Observed**: what happened in its pools: honeypots (10+ buys and no sells), liquidity pulled, real buy and sell tax per pool, tax swings. - **Family**: hooks with the same function set share a family, so a new hook carries its family's history. Each finding is a flag with a severity (`medium`, `high`, `critical`) and its evidence; the hook's `risk_level` is its worst flag. Hooks verified in our registry (launchpads, known protocols) are judged only on what was observed. ## Endpoints [GET /pool/{pool} Pool detail Anonymous · 1 cr](https://docs.crius.sh/reference/pools/pool-detail/) [GET /hooks Uniswap v4 hooks Free · 2 cr](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) [GET /hook/{address} Hook detail Free · 2 cr](https://docs.crius.sh/reference/pools/hook-detail/) --- # Hook detail > One hook: decoded permissions, code (kind, owner, admin functions), what happened in its pools, its code family's history, flags with evidence and risk level,… Source: https://docs.crius.sh/reference/pools/hook-detail/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/hook/{address} One hook: decoded permissions, code (kind, owner, admin functions), what happened in its pools, its code family's history, flags with evidence and risk level, and the events it emits. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Guides that use this endpoint [**Check the risk of a Uniswap v4 hook**Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks.](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More pools & hooks endpoints [GET/pool/{pool}Pool detailAnonymous · 1 cr](https://docs.crius.sh/reference/pools/pool-detail/)[GET/hooksUniswap v4 hooksFree · 2 cr](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "abi_events": [ "Collect(bytes32,uint256,uint256)", "Create(address,address,address)", "DelegateAuthority(address,address)" ], "address": "0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", "attribution": "unattributed", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143998, "code_hash": "0xc41a91106002f15bf70ae266824317f3f3ac638ac72ca5253bae395fa47ee631", "family": "0xaa37a5a3457a", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 25533 }, "events": [ { "emitted_in_scan": 7796, "event": "Swap(address,(address,address,uint24,int24,address),bytes32,(bool,int256,uint160),int128,int128,bytes)", "topic0": "0x1d9f7b5e406d8c887155e1a78e070d2d41c5d0444dab8b21612f846835c27183" }, { "emitted_in_scan": 1724, "event": "ModifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32))", "topic0": "0xdb675a606e5aa8f039e93c54673258dc875053bdaa5dbb96de1670bfdece53b3" }, { "emitted_in_scan": 545, "event": "Create(address,address,address)", "topic0": "0xb224da6575b2c2ffd42454faedb236f7dbe5f92a0c96bb99c0273dbe98464c7e" } ], "family": { "honeypot_pct": 0.0318652, "hooks": 1, "id": "0xaa37a5a3457a", "liquidity_pulled_pct": 0.0389463, "pools_traded": 28244, "taxed_pct": 1.78091, "verified_hooks": 1 }, "fee_tiers_in_scan": [ { "fee": 10000, "pools": 3 }, { "fee": 15000, "pools": 2 }, { "fee": 16000, "pools": 1 } ], "flags": [], "flags_hex": "0x2544", "launchpad": null, "launchpad_name": null, "name": "DopplerHookInitializer", "observed": { "dynamic_tax_pools": 24, "first_trade_ts": 1782922953000, "honeypot_pools": 9, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.0389463, "liquidity_pulled_pools": 11, "max_buy_tax_pct": 99.52, "max_sell_tax_pct": 93.49, "median_pool_life_min": 2138, "pools": 224061, "pools_traded": 28244, "tax_measured_pools": 5814, "taxed_10pct_pools": 29, "taxed_pools": 503, "volume_usd": 1968346259 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "afterRemoveLiquidity" ], "pools": 224090, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "pools_created_24h": 1181, "trades_24h": 59387, "volume_usd_24h": 7478239 }, "verified": true }, "meta": { "block": 100406861, "block_age_ms": 985, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "intel_computed_ts": 1793223685333, "lag_ms": 107, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fhook%2F%7Baddress%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fpools%2Fhook-detail%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Pool detail > Tokens, reserves and in-range liquidity, fee tier (dynamic fee for v4), hook, price, TVL and recent activity of one pool. Source: https://docs.crius.sh/reference/pools/pool-detail/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/pool/{pool} Tokens, reserves and in-range liquidity, fee tier (dynamic fee for v4), hook, price, TVL and recent activity of one pool. > Real reserves, prices both ways, TVL, stats per window, hook, LP status. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `pool`stringrequired Pool address (Uniswap v2/v3) or 32-byte pool id (Uniswap v4). ## Guides that use this endpoint [**Find every pool and the liquidity of a Robinhood Chain token (liquidity API)**Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key.](https://docs.crius.sh/guides/get-token-pools-and-liquidity/)[**Move from raw RPC calls to the Crius API on Robinhood Chain**Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs.](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/)[**Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume**Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades.](https://docs.crius.sh/guides/robinhood-chain-dex-data/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More pools & hooks endpoints [GET/hooksUniswap v4 hooksFree · 2 cr](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/)[GET/hook/{address}Hook detailFree · 2 cr](https://docs.crius.sh/reference/pools/hook-detail/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/pool/0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "created_block": 88461321, "created_ts": 1791990423100, "currency0": { "address": "0x0000000000000000000000000000000000000000", "decimals": 18, "logo": null, "price_usd": 2355.49, "symbol": "ETH" }, "currency1": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "decimals": 18, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "price_usd": 0.00000388948, "symbol": "CHARGE" }, "dex": "uniswap_v4", "dynamic_fee": false, "factory": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "fee": 0, "fee_bps": 0, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "PonsV2MemeHook", "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ] }, "lp": { "locked_pct": 100, "locker": "pons_v2_launch_locker", "permanent": true, "status": "locked" }, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "pool_manager": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "state": { "initialized_ticks": 2, "last_block": 100128111, "liquidity": 29277002188455996438188, "price_0_in_1": 605604460, "price_1_in_0": 0.00000000165124, "real_quote_raised": null, "reserve0": 0, "reserve1": 0, "reserves": { "currency0": 1.18969, "currency1": 720478686, "kind": "real" }, "sqrt_price_x96": 1949728392666469411451966154432124, "tick": 202227 }, "stats": { "all_time": { "buy_volume_usd": 107700, "buys": 2159, "first_trade_ts": 1791990423000, "sell_volume_usd": 114903, "sells": 1767, "since": "chain_start", "trades": 3926, "volume_usd": 222603 }, "avg_trade_usd": { "1h": null, "1m": null, "1s": null, "24h": 2.96366, "30s": null, "4h": null, "5m": null, "6h": null }, "buy_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "last_trade_ts": 1793196204000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "trades": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_eth": { "1h": 0, "1m": 0, "1s": 0, "24h": 0.00252958, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 } }, "swaps_indexed": 432, "tick_spacing": 200, "tvl_usd": 5604.57 }, "meta": { "block": 100406786, "block_age_ms": 1080, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 48, "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fpool%2F%7Bpool%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fpools%2Fpool-detail%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Uniswap v4 hooks > Every v4 hook seen on chain, with pool count, volume, verification, risk level and flags. Source: https://docs.crius.sh/reference/pools/uniswap-v4-hooks/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/hooks Every v4 hook seen on chain, with pool count, volume, verification, risk level and flags. Filter by `risk_level` (e.g. `high,critical`), `flag`, `verified` or `launchpad`; `sort=risk` lists the worst first. > Permissions decoded from the hook address; code, observed outcomes and code-family history (refreshed every 30 min); live pool counts. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `sort`string Default `pools` Sort order. One of `pools`, `volume_24h`, `risk`. `verified`boolean `true` or `false`: only verified (or unverified) hooks. `risk`string Only hooks with this risk flag. `risk_level`string Low | medium | high | critical (comma-separated) `flag`string E.g. honeypot\_family. `launchpad`string Launchpad id, such as `pons` or `flap` (see /launchpads). `limit`integer Default `50` Maximum number of items to return. ## Guides that use this endpoint [**Check the risk of a Uniswap v4 hook**Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks.](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/)[**Robinhood Chain API for launchpad and DEX builders**How launchpad, DEX and v4 hook teams use the Crius API for launch lifecycles, launchpad stats, creator fees, hook records and pool data on Robinhood Chain.](https://docs.crius.sh/use-cases/launchpad-and-dex-builders/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More pools & hooks endpoints [GET/pool/{pool}Pool detailAnonymous · 1 cr](https://docs.crius.sh/reference/pools/pool-detail/)[GET/hook/{address}Hook detailFree · 2 cr](https://docs.crius.sh/reference/pools/hook-detail/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/hooks?sort=pools&limit=20" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/hooks?sort=pools&limit=20", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/hooks?sort=pools&limit=20", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "address": "0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", "attribution": "unattributed", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143998, "code_hash": "0xc41a91106002f15bf70ae266824317f3f3ac638ac72ca5253bae395fa47ee631", "family": "0xaa37a5a3457a", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 25533 }, "events_sample": [ "Swap", "ModifyLiquidity", "Create" ], "family": { "honeypot_pct": 0.0318652, "hooks": 1, "id": "0xaa37a5a3457a", "liquidity_pulled_pct": 0.0389463, "pools_traded": 28244, "taxed_pct": 1.78091, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x2544", "launchpad": null, "launchpad_name": null, "name": "DopplerHookInitializer", "observed": { "dynamic_tax_pools": 24, "first_trade_ts": 1782922953000, "honeypot_pools": 9, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.0389463, "liquidity_pulled_pools": 11, "max_buy_tax_pct": 99.52, "max_sell_tax_pct": 93.49, "median_pool_life_min": 2138, "pools": 224061, "pools_traded": 28244, "tax_measured_pools": 5814, "taxed_10pct_pools": 29, "taxed_pools": 503, "volume_usd": 1968346259 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "afterRemoveLiquidity" ], "pools": 224090, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "trades_24h": 59387, "volume_usd_24h": 7478239 }, "verified": true }, { "address": "0x48b8f6ad3a1b4aa477314c9a23035b8f84dde8cc", "attribution": "unattributed", "capabilities": { "can_block_swaps": true, "can_gate_liquidity": true, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143709, "code_hash": "0x0883056c4856f8fe464ff49f9c1c028455459dad8ceddcc6d5159259fe51e07f", "family": "0x8f75b80c2683", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 16405 }, "events_sample": [ "ClaimProtocolFees", "PoolInitialized", "PoolCreatedFactory" ], "family": { "honeypot_pct": 3.67232, "hooks": 1, "id": "0x8f75b80c2683", "liquidity_pulled_pct": 1.41243, "pools_traded": 354, "taxed_pct": 0, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x28cc", "launchpad": null, "launchpad_name": null, "name": "ClankerHookStaticFeeV2", "observed": { "dynamic_tax_pools": 0, "first_trade_ts": 1783535745000, "honeypot_pools": 13, "last_trade_ts": 1793222422000, "liquidity_pulled_pct": 1.41243, "liquidity_pulled_pools": 5, "max_buy_tax_pct": 0.99, "max_sell_tax_pct": 0.395, "median_pool_life_min": 6549.5, "pools": 15412, "pools_traded": 354, "tax_measured_pools": 276, "taxed_10pct_pools": 0, "taxed_pools": 0, "volume_usd": 14554905 }, "pattern": { "description": "hooks that can block swaps and change swap amounts", "honeypot_pct": 0.608377, "id": "before_swap_with_delta", "liquidity_pulled_pct": 21.5893, "pools_traded": 18574, "taxed_pct": 4.55475 }, "permissions": [ "beforeInitialize", "beforeAddLiquidity", "beforeSwap" ], "pools": 15412, "risk": [ "can_block_or_reprice_swaps", "can_modify_swap_amounts", "can_gate_liquidity_add" ], "risk_level": "low", "stats": { "trades_24h": 335, "volume_usd_24h": 29851.6 }, "verified": true }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "attribution": "known_launchpad", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "events_sample": [ "HookFeeCollected", "PoolFeesSwept", "PoolRegistered" ], "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "flags_hex": "0x2044", "launchpad": "pons", "launchpad_name": "Pons", "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "pools": 10479, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "trades_24h": 118712, "volume_usd_24h": 11871071 }, "verified": true } ], "meta": { "block": 100406858, "block_age_ms": 657, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "intel_computed_ts": 1793223685333, "lag_ms": 221, "next_cursor": "3", "safe_block": 100401329, "total": 29952 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fhooks&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fpools%2Funiswap-v4-hooks%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Security & liquidity API > Realized buy and sell tax, simulated honeypot checks, contract flags and LP lock status for any Robinhood Chain token. Source: https://docs.crius.sh/reference/security/ · Updated 2026-10-28 Is the token safe to trade, and can its liquidity be pulled? Tax is measured from **real trades** (what the pool sent versus what the wallet received, which also catches Uniswap v4 hook taxes), backed by **simulation** of a real buy → transfer → sell sequence at the head block, and **static** checks of the contract. A fresh simulation on demand (`fresh=1`) costs 20 credits and needs the Starter plan or higher. ## Endpoints [GET /token/{address}/security Security checks Anonymous · 1 cr](https://docs.crius.sh/reference/security/security-checks/) [GET /token/{address}/liquidity Liquidity & locks Free · 5 cr](https://docs.crius.sh/reference/security/liquidity-locks/) --- # Liquidity & locks > Who owns the token's liquidity, per pool: burned, locked (which locker, until when, who can withdraw) or held by wallets. Source: https://docs.crius.sh/reference/security/liquidity-locks/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/liquidity Who owns the token's liquidity, per pool: burned, locked (which locker, until when, who can withdraw) or held by wallets. After an unlock the LP keeps being followed: withdrawn → to whom → removed or still held. Supported lockers include the Pons launch locker, UNCX v2/v3/v4, Team Finance, TitanLocker and HoodLock. > V2 LP-token holders, V3/V4 position NFT owners, decoded locker events (UNCX, Team Finance, Titan, HoodLock, Pons). ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Guides that use this endpoint [**Get a Robinhood Chain token security score**Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples.](https://docs.crius.sh/guides/token-security-score/)[**Add safety checks to a Robinhood Chain trading bot**Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts.](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/)[**Check if a token's liquidity is locked or burned**Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens.](https://docs.crius.sh/guides/check-liquidity-locked/)[**Find every pool and the liquidity of a Robinhood Chain token (liquidity API)**Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key.](https://docs.crius.sh/guides/get-token-pools-and-liquidity/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More security & liquidity endpoints [GET/token/{address}/securitySecurity checksAnonymous · 1 cr](https://docs.crius.sh/reference/security/security-checks/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/liquidity", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "pools": [ { "breakdown": [ { "holder": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "kind": "lp_locker", "locker": "pons_v2_launch_locker", "pct": 100, "position_id": "3790055", "tags": [ "lp_locker" ] } ], "dex": "uniswap_v4", "liquidity_usd": 5604.57, "locks": [ { "amount_raw": 81632653061224486519505762, "last_block": 88461321, "last_event": "TokenSupplyLocked", "lock_id": null, "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" }, { "last_block": 88461321, "last_event": "PositionLocked", "lock_id": "3790055", "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" } ], "lp_type": "nft_positions", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "summary": { "burned_pct": 0, "locked_pct": 100, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0 } }, { "breakdown": [ { "holder": "0x2d424d69b1ead72b30de4c7fe4c53e4853e1419d", "kind": "wallet", "locker": null, "pct": 49.1677, "position_id": "3807218", "tags": [] }, { "holder": "0x7aa15762e68e0f0574f1032663502d23d8b7c7e7", "kind": "wallet", "locker": null, "pct": 38.0286, "position_id": "3846225", "tags": [] }, { "holder": "0x0e6710b35de6960a3e4140d10e9f94e0c5a855d1", "kind": "wallet", "locker": null, "pct": 7.61082, "position_id": "3850136", "tags": [] } ], "dex": "uniswap_v4", "liquidity_usd": 6.29539, "locks": [ { "amount_raw": 81632653061224486519505762, "last_block": 88461321, "last_event": "TokenSupplyLocked", "lock_id": null, "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" }, { "last_block": 88461321, "last_event": "PositionLocked", "lock_id": "3790055", "locked_block": 88461321, "locker": "pons_v2_launch_locker", "locker_address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "permanent": true, "status": "locked" } ], "lp_type": "nft_positions", "pool": "0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3", "summary": { "burned_pct": 0, "locked_pct": 0, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 100 } } ], "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 99.8878, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.1122, "weighting": "by pool liquidity_usd" } }, "meta": { "block": 100406846, "block_age_ms": 1266, "block_ts": 1793225082000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 100, "note": "V2 LP shares from LP-token balances (complete once history backfill finishes); V3/V4 by position NFT owner (live ownerOf)", "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fliquidity&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fsecurity%2Fliquidity-locks%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Security checks > Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's… Source: https://docs.crius.sh/reference/security/security-checks/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/security Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. `amount_usd` sets the simulated trade size (default 100). Limits: what this endpoint can miss A `low` risk means no trap was found by these checks, not that the token is safe. The honeypot simulation runs only for tokens with a Uniswap v2 WETH pair (`meta.simulation` says when it didn't), from a fresh wallet at the current block, so traps that whitelist new wallets, switch on later or depend on size can pass. Realized taxes need recent trades (`tax.confidence`, `tax.realized.samples`); `tax.source: "none"` means unknown, not zero. Results are cached 15 seconds. See [Security score: confidence and limitations](https://docs.crius.sh/concepts/security-score-limits/). > Realized tax (30 d), eth\_simulateV1 buy → transfer → sell for V2-routed tokens, owner / proxy / capabilities / limits, hook risk, LP status, flags, score. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `amount_usd`number Default `100` Simulated trade size in USD. `fresh`integer `1` runs a new simulation now (Starter plan and up, 20 credits). ## Key response fields - `risk` (`low` / `medium` / `high`) and `score` (0–100), plus `flags` - `honeypot.is_honeypot`, `honeypot.selective` (only some wallets can sell), `honeypot.reason` - `tax.buy_pct`, `tax.sell_pct` and their `source`; `tax.realized` (from real trades, with sample counts and the highest sell tax seen) and `tax.simulated` - `tax_history`: every tax change with the block it took effect - `contract`: ownership, mintable, pausable, blacklist, proxy / upgradeable, can change tax or limits - `hook`: the v4 pool hook's name, permissions, capabilities, risk level and flags (with evidence), code, observed outcomes and code-family history. The score loses 60, 30 or 10 points for a critical, high or medium hook - `liquidity.summary`: locked, burned and unlocked shares of LP ## Guides that use this endpoint [**Build a Robinhood Chain token screener**Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code.](https://docs.crius.sh/guides/build-a-token-screener/)[**Find new tokens on Robinhood Chain as they launch**List new Robinhood Chain tokens seconds after they are created, filter by launchpad, liquidity and creation time, with real responses from the Crius API.](https://docs.crius.sh/guides/find-new-tokens/)[**Get a Robinhood Chain token security score**Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples.](https://docs.crius.sh/guides/token-security-score/)[**Build a Telegram token scanner bot for Robinhood Chain**Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples.](https://docs.crius.sh/guides/build-a-telegram-token-scanner/)[**How to check a Robinhood Chain token's buy and sell tax**Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax.](https://docs.crius.sh/guides/check-token-taxes/)[**Get new Robinhood Chain tokens and graduations in real time**Get new Robinhood Chain launchpad tokens, graduations and pools the moment they happen, with the Crius WebSocket and a Node.js client that checks each token.](https://docs.crius.sh/guides/stream-new-tokens/)[**Add safety checks to a Robinhood Chain trading bot**Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts.](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/)[**Build Robinhood Chain price alerts with the WebSocket stream**Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first.](https://docs.crius.sh/guides/build-price-alerts/)[**How to detect a honeypot token on Robinhood Chain**Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence.](https://docs.crius.sh/guides/detect-honeypot/)[**Find Robinhood Chain tokens above a market cap**Rank Robinhood Chain tokens by market cap, filter by a minimum or a range, and drop fake market caps from dust pools and insider launches. Real responses.](https://docs.crius.sh/guides/find-tokens-by-market-cap/)[**Check if a token's liquidity is locked or burned**Find out whether a Robinhood Chain token's liquidity is locked, burned or held by wallets that can pull it, pool by pool, with the locker and unlock date. Real examples from Pons tokens.](https://docs.crius.sh/guides/check-liquidity-locked/)[**Check the risk of a Uniswap v4 hook**Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks.](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/)[**Use the Crius API from AI agents (OpenAPI, llms.txt, MCP)**Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips.](https://docs.crius.sh/guides/use-crius-with-ai-agents/)[**Detect bundled launches, snipers and insiders**Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%.](https://docs.crius.sh/guides/detect-bundles-and-snipers/)[**What is the best Robinhood Chain data API? How to choose one**How to choose a Robinhood Chain data API: nine criteria, from launchpads and realized taxes to WebSockets and free plans, and a sourced provider comparison.](https://docs.crius.sh/guides/choose-a-robinhood-chain-data-api/)[**How to create a token on Robinhood Chain (launchpads compared)**The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data.](https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More security & liquidity endpoints [GET/token/{address}/liquidityLiquidity & locksFree · 5 cr](https://docs.crius.sh/reference/security/liquidity-locks/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x2d424d69b1ead72b30de4c7fe4c53e4853e1419d", "liquidity_usd": 3.0953, "pct": 0.0551662 }, "sniper_supply_pct": 6.09195, "sniper_top_wallet_pct": 6.09195, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 99.8878, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.1122, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 95, "tax": { "buy_pct": 2.99, "confidence": "high", "realized": { "buy_pct": 2.99, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793196204000, "max_sell_pct_seen": 96.64, "samples": { "buys": 2539, "sells": 1873 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 88385895, "pct": 0, "side": "buy" }, { "from_block": 88387118, "pct": 0, "side": "sell" }, { "from_block": 88461329, "pct": 3, "side": "buy" } ], "tax_history_total": 29, "tax_mode": "dynamic", "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" }, "meta": { "block": 100406827, "block_age_ms": 1163, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 64, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fsecurity&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fsecurity%2Fsecurity-checks%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # WebSocket stream > Real-time Robinhood Chain data over one WebSocket - trades, prices, live candles, new launches, graduations, new pools, LP and tax changes, wallet activity, with replay and reorg handling. Source: https://docs.crius.sh/reference/stream/ · Updated 2026-10-28 WS `wss://api.crius.sh/v1/{chain}/stream` **Plan:** Free and above, key with the `stream` scope · **Cost:** 1 credit per connection One connection carries many subscriptions. Messages are pushed as soon as a block is decoded, typically well under a second after it was produced. | Plan | WebSocket connections | Subscriptions per connection | | --- | --- | --- | | Anonymous (no key) | none | none | | Free | 1 | 10 | | Starter | 3 | 100 | | Pro | 10 | 1,000 | | Business | 50 | 10,000 | | Enterprise | custom | custom | See [Plans & limits](https://docs.crius.sh/plans-and-limits/) for the rest of each plan. ## Connecting Authenticate with the `x-api-key` header, or with `?api_key=` where a client can’t set headers (browsers): ```js const ws = new WebSocket(`wss://api.crius.sh/v1/robinhood/stream?api_key=${key}`); ``` The key is checked before the upgrade, like any REST call: no key returns `403 plan_required`, and a key without the `stream` scope returns `403 scope_required`. On connect the server sends a greeting with your limits (`max_subscriptions` is your plan’s subscriptions per connection): ```json {"ch": "hello", "data": {"chain": "robinhood", "heartbeat_s": 15, "max_subscriptions": 10}} ``` ## Operations Send JSON messages with an `op`: | Op | Message | Reply | | --- | --- | --- | | Subscribe | `{"op": "subscribe", "channels": ["trades:0x…", "launches:all"]}` | `{"ch": "subscribed", "data": {"channels": […], "finality": "latest"}}` | | Unsubscribe | `{"op": "unsubscribe", "channels": ["trades:0x…"]}` | `{"ch": "unsubscribed", "data": {"channels": […]}}` | | Settled data only | `{"op": "subscribe", "channels": […], "finality": "safe"}` | events are held until their block is `safe` | | Resume after a reconnect | `{"op": "resume", "seqs": {"trades:0x…": 90455}}` | missed messages (up to 60 s), then `{"ch": "resumed"}` | | Ping | `{"op": "ping"}` | `{"ch": "pong", "ts": …}` | - **Subscribe** adds channels to the connection; the `subscribed` and `unsubscribed` replies list every channel the connection now has, not only the ones in the message. - Channel names are lowercased by the server, and messages carry the lowercase name in `ch`. Send lowercase addresses so the names you match on are the ones you receive. - **Price snapshot.** For each `price:` channel in a `subscribe` message, the current price is sent right away, before the `subscribed` reply: `{"ch": "price:0x…", "snapshot": true, "data": {"usd": …, "eth": …, "liquidity_usd": …}}`. A snapshot has no `seq`, `block` or `ts`, its `ch` is the name exactly as you sent it, and it is only sent for tokens that have a price. - **Finality.** `"finality": "safe"` (or `"finalized"`, which behaves the same) applies to the whole connection, for every channel, from that message on; the reply says `"safe"`. Without it, events are sent at `latest`. - **Resume.** `seqs` maps a channel to the last `seq` you saw on it; you receive the newer messages still in the replay buffer (the last 60 seconds) for channels you’re subscribed to, then `{"ch": "resumed"}`. `from_seq` (a number) is used for subscribed channels missing from `seqs`. Channels with neither are not replayed, and resume only covers channels already subscribed on this connection: send `subscribe` first. ## Errors Errors arrive as messages on the `error` channel; the connection stays open. | `data.code` | When | Other fields | | --- | --- | --- | | `channel_denied` | A `firehose:` channel on a plan below Enterprise, or subscribing past `max_subscriptions` | `channels` (the ones refused), `message`, `max_subscriptions` | | `lagged` | Your client read too slowly and the server dropped messages for it | `dropped` (how many), `hint: "resume with your last seq"` | | `bad_message` | The message wasn’t valid JSON, or had no `op` | `message` | | `unknown_op` | `op` is not `subscribe`, `unsubscribe`, `resume` or `ping` | `op` | ```json {"ch": "error", "data": {"code": "lagged", "dropped": 120, "hint": "resume with your last seq"}} ``` On `lagged`, send `resume` with your last `seq` per channel to get the dropped messages back (if they’re still in the 60-second buffer). ## Channels | Channel | Pushes | | --- | --- | | `trades:` | Every trade of a token, in any pool | | `trades:pool:` | Every trade in one pool (v2/v3 pool address or v4 pool id) | | `price:` | Price updates (`usd`, `eth`, `liquidity_usd`) when the token trades, at most every 100 ms per token; a snapshot is sent right after subscribing | | `candles::` | The live candle for `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h` or `1d`, after every trade | | `token:` | Price and holder count (`price_usd`, `holders`), with the same timing as `price:` | | `tax:` / `tax:all` | Realized buy or sell tax changes of one token, or of every token | | `lp:` / `lp:all` | Liquidity added or removed in the token’s pools, or in every pool | | `launches:` / `launches:all` | New launches (`pons`, `flap`, `bankr`, `long`, `flywheel`, `standard_reserve`) | | `graduations:` / `graduations:all` | Graduations, with the new pool | | `pools:new` | Every new Uniswap v2 / v3 / v4 pool, with hook permissions | | `wallet:
` | Trades the wallet made and token transfers to or from it | | `dev:
` | New tokens launched by a creator | | `firehose:trades` | Every trade on the chain (Enterprise) | `finality`, `reorg` and `heartbeat` messages reach every connection without subscribing. Every message has the same envelope: `ch`, `seq`, `block`, `ts` (unix ms: the block’s time for chain events, the server’s time on `finality`, `reorg` and `removed` re-sends) and `data`. This is the [trade tape](https://docs.crius.sh/reference/trades/trade-tape/) sample’s trade `100410183-9-12` as the stream sends it: ```json { "ch": "trades:0x322f0929c4625ed5bad873c95208d54e1c003b2d", "seq": 90455, "block": 100410183, "ts": 1793225424000, "data": { "id": "100410183-9-12", "type": "sell", "ts": 1793225424000, "block": 100410183, "token": "0x322f0929c4625ed5bad873c95208d54e1c003b2d", "symbol": "TSLA", "logo": null, "pool": "0x3ea70ce0b34473692549f97e630a1d82dc05cea94fa55f81b50f10c8c6d8186f", "dex": "uniswap_v4", "trader": "0x278d858f05b94576c1e6f73285886876ff6ef8d2", "signer": "0xe07ba3acee529ff1d4f7290cbae32fa065e18acd", "amount_base": 0.68873541086638403, "amount_quote": 0.358712450309036398, "price_usd": 402.641, "value_usd": 277.313, "tax_pct": 0 } } ``` `seq` increases by one per channel. Keep the last `seq` you saw for each channel and send them in a `resume` op after reconnecting to receive what you missed (60-second replay buffer). ### Message data per channel | Channel | `data` fields | | --- | --- | | `trades:`, `trades:pool:`, `firehose:trades`, and trades on `wallet:` | `id` (`block-tx-log`), `type` (`buy` / `sell`), `ts`, `block`, `token`, `symbol`, `logo`, `pool`, `dex`, `trader`, `signer`, `amount_base`, `amount_quote` (human units), `price_usd`, `value_usd`, `tax_pct` (`null` when no tax was measured) | | Transfers on `wallet:` | `type: "transfer"`, `token`, `from`, `to`, `amount`, `id`. Mints and burns are not sent | | `price:` | `usd`, `eth`, `liquidity_usd` | | `candles:` | `t` (bucket start, unix ms), `o`, `h`, `l`, `c`, `v` (USD volume), `n` (trades) | | `token:` | `price_usd`, `holders` (`null` until the token’s holder history is complete) | | `tax:` | `token`, `side` (`buy` / `sell`), `from`, `to` (whole percent), `source: "realized"` | | `lp:` | `type` (`add_liquidity` / `remove_liquidity`), `pool`, `dex`, `provider`, `token0`, `token1`, `amount0`, `amount1` | | `launches:`, `dev:` | `address`, `launchpad`, `creator`, `curve`, `quote` (the quote token’s symbol, e.g. `ETH`), `tx` | | `graduations:` | `token`, `launchpad`, `pool`, `position_id` | | `pools:new` | `pool`, `dex`, `token0`, `token1`, `fee`, `tick_spacing`, `hook` (`null`, or `address` and `permissions`, e.g. `beforeSwap`) | A stream trade is a compact version of a trade tape row, with the same `id`. It doesn’t carry `tx`, `tx_index`, `executor`, `via`, `fees`, `finality`, `quote`, `quote_symbol`, `value_eth`, `price_eth`, `eth_usd_at_trade`, `market_cap_usd_at_trade` or the `trader_label` / `signer_label` / `trader_app` labels: fetch the trade tape for those. Notes on timing: - `price:` and `token:` are only sent when the token trades, and at most once per 100 ms per token. - `candles:` channels have no snapshot: the first message comes with the token’s next trade, and a bucket without trades sends nothing. A new candle opens at the previous close, and a small trade far from the token’s current price counts in `v` and `n` without moving `h`, `l` or `c`. - `tax:` fires when the realized tax on one side, rounded to a whole percent, differs from that side’s previous trade. ## Heartbeats, finality and reorgs - `{"ch": "heartbeat", "ts": …, "uptime_s": …}` arrives every 15 seconds (`uptime_s` is how long this connection has been open); reconnect if you hear nothing for 45 seconds. - `{"ch": "finality", "seq": …, "block": 0, "ts": …, "data": {"safe_block": …, "finalized_block": …}}` arrives on every connection whenever the safe or finalized block moves. - If blocks are replaced, a `{"ch": "reorg", "data": {"common_ancestor", "removed_blocks", "depth"}}` message comes first (`removed_blocks` lists the replaced blocks that had messages, `depth` how many there are), then every affected event is re-sent on its channel with `"removed": true` added to its `data` (same `id`, a new `seq`), then the replacement events as their blocks are decoded. - With `"finality": "safe"`, events are held until the `finality` message that makes their block safe, then delivered in order. The `removed` re-sends of a reorg are held the same way, so keep handling `removed: true`. A complete reconnecting client is in the [real-time stream example](https://docs.crius.sh/examples/stream/). --- # Tokens & prices API > Token profiles, live USD prices, batch prices, sparse batch profiles and every market a token trades in on Robinhood Chain. Source: https://docs.crius.sh/reference/tokens/ · Updated 2026-10-28 Everything about one token, or many at once. The **token profile** is the richest call (metadata, socials, supply, launch, market, holders summary, liquidity locks, security summary, rolling stats). The **price** call is the smallest and fastest: use it in hot loops. For many tokens, use **batch prices** (up to 100 per call) or **batch profiles** with a field list. Prices are derived on-chain: token → its deepest pool's quote (ETH, WETH, USDG or another token) → USD through the deepest ETH/USDG pool. Tokenized stocks follow the same path, using on-chain pools only. `confidence` and `thin_liquidity` tell you how much to trust a price. ## Endpoints [GET /token/{address} Token profile Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/) [GET /token/{address}/price Token price Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/) [GET /prices Batch prices Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/) [POST /prices Batch prices (POST) Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/) [POST /tokens/batch Batch token profiles Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/) [GET /token/{address}/pools Token markets Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) --- # Batch prices (POST) > Same as the GET form, with the list in a JSON body. Batch prices (POST) on Robinhood Chain: parameters, plan, credits, code and a real response. Source: https://docs.crius.sh/reference/tokens/batch-prices-post/ · Updated 2026-10-28 POST https://api.crius.sh/v1/{chain}/prices Same as the GET form, with the list in a JSON body. Use it when the list would make the URL too long. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Request body ```json { "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ] } ``` ## Guides that use this endpoint [**Get prices for many Robinhood Chain tokens in one call**Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed.](https://docs.crius.sh/guides/get-prices-for-many-tokens/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}Token profileAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/)[GET/token/{address}/priceToken priceAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/)[GET/pricesBatch pricesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/)[POST/tokens/batchBatch token profilesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/)[GET/token/{address}/poolsToken marketsAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) Request No key needed **cURL** ```bash curl -X POST "https://api.crius.sh/v1/robinhood/prices" \ -H "x-api-key: $CRIUS_API_KEY" \ -H "content-type: application/json" \ -d '{"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"]}' ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/prices", { method: "POST", headers: { "x-api-key": process.env.CRIUS_API_KEY, "content-type": "application/json", }, body: JSON.stringify({ "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ] }), }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.post( "https://api.crius.sh/v1/robinhood/prices", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, json={"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "change_24h_pct": 0.286017, "confidence": "high", "eth": 1, "liquidity_usd": 9953382, "logo": null, "source_pool": "0xbac3aa3b91584a53a579b3c999a56756e954e59247e497bad1d25a4334bde551", "symbol": "WETH", "usd": 2355.49 }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "change_24h_pct": -0.171971, "confidence": "medium", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "usd": 0.00000388948 } }, "meta": { "block": 100406777, "block_age_ms": 1160, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 4, "missing": [], "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20POST%20%2Fv1%2F%7Bchain%7D%2Fprices&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Fbatch-prices-post%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Batch prices > Prices for up to 100 tokens in one call. Pass a comma-separated list in tokens. Batch prices on Robinhood Chain: parameters, plan, credits, code and a real response. Source: https://docs.crius.sh/reference/tokens/batch-prices/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/prices Prices for up to **100 tokens** in one call. Pass a comma-separated list in `tokens`. Unknown addresses are listed in `meta.missing` instead of failing the request. > Also POST with {"tokens": \[...\]}. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Query parameters `tokens`string Default `0x8ac48210be19378229f12060d499c3b0eae5e14e,0x7b8892cea949bc60d494681d1bc3ea96071ab0b8` Comma-separated token addresses (up to 100). ## Guides that use this endpoint [**Build a Robinhood Chain token screener**Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code.](https://docs.crius.sh/guides/build-a-token-screener/)[**Get a Robinhood Chain token's live USD price**Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key.](https://docs.crius.sh/guides/get-token-price/)[**Build Robinhood Chain price alerts with the WebSocket stream**Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first.](https://docs.crius.sh/guides/build-price-alerts/)[**Get a token's all-time high and price change**Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change.](https://docs.crius.sh/guides/get-all-time-high-and-price-change/)[**Get prices for many Robinhood Chain tokens in one call**Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed.](https://docs.crius.sh/guides/get-prices-for-many-tokens/)[**Get wallet token balances on Robinhood Chain (balances API)**Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices.](https://docs.crius.sh/guides/get-wallet-token-balances/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}Token profileAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/)[GET/token/{address}/priceToken priceAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/)[POST/pricesBatch prices (POST)Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/)[POST/tokens/batchBatch token profilesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/)[GET/token/{address}/poolsToken marketsAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2C0x0bd7d308f8e1639fab988df18a8011f41eacad73" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2C0x0bd7d308f8e1639fab988df18a8011f41eacad73", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/prices?tokens=0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2C0x0bd7d308f8e1639fab988df18a8011f41eacad73", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "change_24h_pct": 0.286017, "confidence": "high", "eth": 1, "liquidity_usd": 9953382, "logo": null, "source_pool": "0xbac3aa3b91584a53a579b3c999a56756e954e59247e497bad1d25a4334bde551", "symbol": "WETH", "usd": 2355.49 }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "change_24h_pct": -0.171971, "confidence": "medium", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "usd": 0.00000388948 } }, "meta": { "block": 100406775, "block_age_ms": 907, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 35, "missing": [], "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fprices&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Fbatch-prices%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Batch token profiles > Token profiles for up to 100 tokens, trimmed to the fields you ask for. Batch token profiles on Robinhood Chain: parameters, plan, credits, code and a real response. Source: https://docs.crius.sh/reference/tokens/batch-token-profiles/ · Updated 2026-10-28 POST https://api.crius.sh/v1/{chain}/tokens/batch Token profiles for up to **100 tokens**, trimmed to the fields you ask for. `fields` takes dot paths into the profile above (`price.usd`, `market.market_cap_usd`, `holders.count`…); an empty list returns full profiles. > fields: dotted paths of the token profile. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). ## Request body ```json { "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ], "fields": [ "symbol", "price.usd", "price.change_pct.24h", "market.market_cap_usd", "market.liquidity_usd" ] } ``` ## Guides that use this endpoint [**Build a Robinhood Chain token screener**Build a Robinhood Chain token screener with the Crius API: clean token lists, batch profiles, a risk check per token, credits per refresh and working code.](https://docs.crius.sh/guides/build-a-token-screener/)[**How to get Robinhood Chain token data (token profile API)**Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed.](https://docs.crius.sh/guides/get-token-data/)[**Get prices for many Robinhood Chain tokens in one call**Price up to 100 Robinhood Chain tokens in one request with the batch prices API, or get chosen profile fields for many tokens. Real responses, no key needed.](https://docs.crius.sh/guides/get-prices-for-many-tokens/)[**Market cap, FDV and circulating supply of a Robinhood Chain token (token supply API)**Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed.](https://docs.crius.sh/guides/market-cap-fdv-and-supply/)[**Move from raw RPC calls to the Crius API on Robinhood Chain**Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs.](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}Token profileAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/)[GET/token/{address}/priceToken priceAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/)[GET/pricesBatch pricesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/)[POST/pricesBatch prices (POST)Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/)[GET/token/{address}/poolsToken marketsAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) Request No key needed **cURL** ```bash curl -X POST "https://api.crius.sh/v1/robinhood/tokens/batch" \ -H "x-api-key: $CRIUS_API_KEY" \ -H "content-type: application/json" \ -d '{"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}' ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens/batch", { method: "POST", headers: { "x-api-key": process.env.CRIUS_API_KEY, "content-type": "application/json", }, body: JSON.stringify({ "tokens": [ "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "0x0bd7d308f8e1639fab988df18a8011f41eacad73" ], "fields": [ "symbol", "price.usd", "price.change_pct.24h", "market.market_cap_usd", "market.liquidity_usd" ] }), }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.post( "https://api.crius.sh/v1/robinhood/tokens/batch", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, json={"tokens":["0x7b8892cea949bc60d494681d1bc3ea96071ab0b8","0x0bd7d308f8e1639fab988df18a8011f41eacad73"],"fields":["symbol","price.usd","price.change_pct.24h","market.market_cap_usd","market.liquidity_usd"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "0x0bd7d308f8e1639fab988df18a8011f41eacad73": { "market": { "liquidity_usd": 73135530, "market_cap_usd": 90409474 }, "price": { "change_pct": { "24h": 0.286017 }, "usd": 2355.49 }, "symbol": "WETH" }, "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8": { "market": { "liquidity_usd": 5611.8, "market_cap_usd": 3773.42 }, "price": { "change_pct": { "24h": -0.171971 }, "usd": 0.00000388948 }, "symbol": "CHARGE" } }, "meta": { "block": 100406780, "block_age_ms": 575, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 196, "missing": [], "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20POST%20%2Fv1%2F%7Bchain%7D%2Ftokens%2Fbatch&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Fbatch-token-profiles%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Token markets > Every market the token trades in: Uniswap v2 pairs, v3 pools (all fee tiers), v4 pools (with their hook) and launchpad bonding curves, with liquidity and 24h… Source: https://docs.crius.sh/reference/tokens/token-markets/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/pools Every market the token trades in: Uniswap v2 pairs, v3 pools (all fee tiers), v4 pools (with their hook) and launchpad bonding curves, with liquidity and 24h activity. Paginate with `cursor`. > Uniswap V2/V3/V4, Pons and launchpad curves, ranked by USD liquidity (2 x quote side, from each pool's own state). is\_price\_pool marks the market the token price comes from. meta.total = all pools. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `limit`integer Default `50` Maximum number of items to return. Up to 200. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Find every pool and the liquidity of a Robinhood Chain token (liquidity API)**Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key.](https://docs.crius.sh/guides/get-token-pools-and-liquidity/)[**Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume**Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades.](https://docs.crius.sh/guides/robinhood-chain-dex-data/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}Token profileAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/)[GET/token/{address}/priceToken priceAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/)[GET/pricesBatch pricesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/)[POST/pricesBatch prices (POST)Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/)[POST/tokens/batchBatch token profilesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/pools?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "amounts": { "token0": 1.18969, "token1": 720478686 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461321, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 0, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "name": "pons_v2_meme_hook" }, "is_price_pool": true, "liquidity_usd": 5604.57, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "price_usd": 0.00000388948, "quote": { "address": "0x0000000000000000000000000000000000000000", "logo": null, "symbol": "ETH" }, "quote_liquidity_usd": 2802.29, "state": { "liquidity": 29277002188455996438188, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 1949728392666469411451966154432124, "tick": 202227 }, "swaps_indexed": 432, "tick_spacing": 200 }, { "amounts": { "token0": 3.1477, "token1": 115029 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88461495, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 850000, "hook": null, "is_price_pool": false, "liquidity_usd": 6.29539, "pool": "0xe928234e515b0c000dd6aa1c60cf5a009082367cda4775a5b63b4ff0c83dcdd3", "price_usd": 0.0000273644, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 3.1477, "state": { "liquidity": 601728037770030, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 15145615706034675540349663040887263187, "tick": 381391 }, "swaps_indexed": 3, "tick_spacing": 60 }, { "amounts": { "token0": 0.328859, "token1": 35779.5 }, "base": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" }, "created_block": 88466617, "dex": "uniswap_v4", "dynamic_fee": false, "fee": 450000, "hook": null, "is_price_pool": false, "liquidity_usd": 0.657719, "pool": "0x1a184f0aa1978e7b543ee944a30df88dd34fcb667aa5a9142bb399ef582481b8", "price_usd": 0.00000919127, "quote": { "address": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "logo": null, "symbol": "USDG" }, "quote_liquidity_usd": 0.328859, "state": { "liquidity": 108473206521826, "reserve0": 0, "reserve1": 0, "sqrt_price_x96": 26133147987752847079481471382601445977, "tick": 392302 }, "swaps_indexed": 4, "tick_spacing": 4500 } ], "meta": { "block": 100406784, "block_age_ms": 826, "block_ts": 1793225076000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 11, "next_cursor": "3", "safe_block": 100401329, "total": 10 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fpools&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Ftoken-markets%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Token price > The fastest call: USD and ETH price, the pool it came from, that pool's liquidity and a confidence level. Source: https://docs.crius.sh/reference/tokens/token-price/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/price The fastest call: USD and ETH price, the pool it came from, that pool's liquidity and a confidence level. Ideal for bots, widgets and portfolio valuation. > Deepest pool against ETH / WETH / USDG (real reserves), ETH/USD from the deepest ETH/USDG pool. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Key response fields - `usd`, `eth`: price per whole token - `source_pool`, `dex`, `quote`: where the price comes from - `liquidity_usd` (2 × the quote side, DEX-screener convention) and `quote_liquidity_usd` (the real quote side) - `confidence` (`high` / `medium` / `low`) and `thin_liquidity` ## Guides that use this endpoint [**Get a Robinhood Chain token's live USD price**Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key.](https://docs.crius.sh/guides/get-token-price/)[**Add safety checks to a Robinhood Chain trading bot**Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts.](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/)[**Build Robinhood Chain price alerts with the WebSocket stream**Build Robinhood Chain price alerts on the Crius WebSocket price channel, with a runnable Node.js alert bot that checks liquidity and token security first.](https://docs.crius.sh/guides/build-price-alerts/)[**Move from raw RPC calls to the Crius API on Robinhood Chain**Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs.](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}Token profileAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-profile/)[GET/pricesBatch pricesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/)[POST/pricesBatch prices (POST)Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/)[POST/tokens/batchBatch token profilesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/)[GET/token/{address}/poolsToken marketsAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "eth_usd": 2355.49, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "thin_liquidity": false, "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "usd": 0.00000388948 }, "meta": { "block": 100406772, "block_age_ms": 654, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 66, "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fprice&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Ftoken-price%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Token profile > Full profile of any ERC-20 on the chain: name, symbol, decimals, supply (total, burned, locked, circulating), creation and launchpad lifecycle, metadata and… Source: https://docs.crius.sh/reference/tokens/token-profile/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address} Full profile of any ERC-20 on the chain: name, symbol, decimals, supply (total, burned, locked, circulating), creation and launchpad lifecycle, metadata and socials (with their source), price with change per window and all-time high, market (market cap, FDV, liquidity), holder summary (count, top-10 share, dev holding), liquidity lock status, contract verification and rolling trade stats. Heavier sections link to their own endpoints (`security.see`, `bundles.see`) so the profile stays fast. > Identity, supply, metadata & socials, creation, verification, launch, price + change + ATH, market (FDV, market cap, liquidity), stats per window, holders summary, liquidity summary, dexscreener (dex paid, community takeover, boosts; confirmed against DexScreener orders). ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Key response fields - `price.usd`, `price.change_pct` (per window), `price.ath_usd`, `price.confidence` - `market.market_cap_usd`, `market.fdv_usd`, `market.liquidity_usd`, `market.quote_liquidity_usd`, `market.pools_count` - `holders.count`, `holders.top10_pct`, `holders.dev_pct`, `holders.burned_pct`, `holders.locked_pct` - `launch`: launchpad id and name, creator, curve, `status` (`bonding` / `graduated`), `progress_pct`, launch and graduation blocks - `liquidity`: lock status, lockers, next unlock time - `stats`: trades, buys, sells, traders, volume per window plus `all_time` - `metadata`: `logo`, `banner`, `description` and `links` (website, twitter, telegram, discord, farcaster, github), the same shape on every endpoint, with their `sources` (see [Conventions](https://docs.crius.sh/conventions/#token-logo-and-links)) ## Guides that use this endpoint [**How to get Robinhood Chain token data (token profile API)**Get a Robinhood Chain token's name, supply, price, market cap, holders, launchpad, liquidity lock and links in one API call. Real response, no API key needed.](https://docs.crius.sh/guides/get-token-data/)[**Build a Telegram token scanner bot for Robinhood Chain**Build a Telegram bot that scans Robinhood Chain tokens: price, liquidity, holders, taxes and a security score from two Crius API calls, with real examples.](https://docs.crius.sh/guides/build-a-telegram-token-scanner/)[**How to detect a honeypot token on Robinhood Chain**Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence.](https://docs.crius.sh/guides/detect-honeypot/)[**Get a token's all-time high and price change**Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change.](https://docs.crius.sh/guides/get-all-time-high-and-price-change/)[**Search Robinhood Chain tokens, pools and wallets by name or address**Find a Robinhood Chain token's address by name or symbol, or look up any address or Uniswap v4 pool id, with one search call. Real responses included.](https://docs.crius.sh/guides/search-tokens/)[**Use the Crius API from AI agents (OpenAPI, llms.txt, MCP)**Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips.](https://docs.crius.sh/guides/use-crius-with-ai-agents/)[**Market cap, FDV and circulating supply of a Robinhood Chain token (token supply API)**Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed.](https://docs.crius.sh/guides/market-cap-fdv-and-supply/)[**How to create a token on Robinhood Chain (launchpads compared)**The ways to create a token on Robinhood Chain: Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets or your own ERC-20, compared with real launch data.](https://docs.crius.sh/guides/create-a-token-on-robinhood-chain/)[**Check a token developer's history (past launches and rugs)**Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling.](https://docs.crius.sh/guides/check-developer-history/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More tokens & prices endpoints [GET/token/{address}/priceToken priceAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-price/)[GET/pricesBatch pricesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices/)[POST/pricesBatch prices (POST)Anonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-prices-post/)[POST/tokens/batchBatch token profilesAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/batch-token-profiles/)[GET/token/{address}/poolsToken marketsAnonymous · 1 cr](https://docs.crius.sh/reference/tokens/token-markets/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "admin_flags": null, "bundles": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/bundles" }, "burned": 29840058.774195638068253872, "chain_id": 4663, "circulating_supply": 970159941.225804361931746128, "creation": { "attribution": "known_launchpad", "block": 88385886, "deployed_via": "pons_v2", "deployer": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "launchpad_name": "Pons", "tx": "0x4d9536e81ce418070e93b72f46f1d91afdd6a9ed34141b8e3773926b0d863747" }, "decimals": 18, "dexscreener": { "boosts": { "active_amount": null, "active_seen_ts": null, "count": 0, "last_ts": null, "total_amount": 0 }, "checked_ts": 1793040659244, "community_takeover": false, "community_takeover_ts": null, "confirmed": true, "dex_paid": true, "dex_paid_ts": 1791988981764, "orders": [ { "payment_ts": 1791988981764, "status": "approved", "type": "tokenProfile" } ], "profile": { "description": null, "header": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "icon": "https://cdn.dexscreener.com/cms/images/DjTh8_NirbFrIzjW?width=800&height=800&quality=95&format=auto", "links": [ { "label": "Website", "type": "website", "url": "https://chargeai.bid/" }, { "type": "twitter", "url": "https://x.com/chargeairh" } ] }, "url": "https://dexscreener.com/robinhood/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" }, "first_seen_block": 88385886, "history": "complete", "holders": { "burned_pct": 2.98401, "count": 179, "dev_holding": false, "dev_pct": 0, "locked_pct": 8.16327, "top10_pct": 13.436 }, "launch": { "creator": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "creator_label": null, "curve": "0x2b0943bf947b54df526047b6fec8183a4fdeb3c3", "curve_state": null, "graduated_block": 88461321, "graduation_threshold": 4.2, "launched_block": 88385886, "launchpad": "pons", "launchpad_name": "Pons", "pair_token": "0x0000000000000000000000000000000000000000", "progress_pct": 100, "raised": null, "status": "graduated" }, "liquidity": { "locked_pct": 100, "lockers": [ "pons_v2_launch_locker" ], "next_unlock_ts": null, "permanent": true, "status": "locked" }, "locked": 81632653.061224486519511236, "market": { "fdv_usd": 3889.48, "liquidity_usd": 5611.8, "market_cap_usd": 3773.42, "pools_count": 10, "quote_liquidity_usd": 2805.9 }, "metadata": { "banner": "https://cdn.dexscreener.com/cms/images/JcxosvISKHoUITBu?width=1500&height=500&quality=95&format=auto", "description": "hf:charge-ai/charge-30b@9ff2ef1e98ea4d9745a70b33ea02b80dba26c582", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/chargeairh", "website": "https://chargeai.bid/" }, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "logo_original": "https://api.surplusllm.com/api/launchpad/logos/bb4315cb9506ef872830b1dab25ffdb6694df1b8b8e32cc2c8d083208f26baab.png", "socials": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": { "source": "pons_launch", "url": "https://x.com/chargeairh" }, "website": { "source": "pons_launch", "url": "https://chargeai.bid/" } }, "source": "pons_launch", "sources": { "links": "pons_launch", "logo": "pons_launch" } }, "name": "Charge AI", "price": { "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "ath_ts": 1792055400000, "ath_usd": 0.0000707881, "change_pct": { "1h": 0.896103, "1m": 0.896103, "1s": 0.896103, "24h": -0.171971, "30s": 0.896103, "4h": 0.896103, "5m": 0.896103, "6h": 0.896103 }, "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "thin_liquidity": false, "usd": 0.00000388948 }, "security": { "see": "/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security" }, "standard": "erc20", "stats": { "all_time": { "buy_volume_usd": 143046, "buys": 2893, "first_trade_ts": 1791982835000, "sell_volume_usd": 137621, "sells": 2250, "since": "chain_start", "trades": 5143, "volume_usd": 280667 }, "avg_trade_usd": { "1h": null, "1m": null, "1s": null, "24h": 2.96366, "30s": null, "4h": null, "5m": null, "6h": null }, "buy_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "1m": 0, "1s": 0, "24h": 0, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "last_trade_ts": 1793196204000, "sell_volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "traders": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "trades": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "1m": 0, "1s": 0, "24h": 2, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_eth": { "1h": 0, "1m": 0, "1s": 0, "24h": 0.00252958, "30s": 0, "4h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "1m": 0, "1s": 0, "24h": 5.92732, "30s": 0, "4h": 0, "5m": 0, "6h": 0 } }, "symbol": "CHARGE", "total_supply": 1000000000, "type": "launchpad", "ui_multiplier": null, "verification": { "compiler": null, "contract_name": null, "implementation": null, "is_proxy": null, "sourcify": null } }, "meta": { "block": 100406769, "block_age_ms": 400, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 38, "pending": [], "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftokens%2Ftoken-profile%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Trades & candles API > Trade tape with real-trader attribution, OHLCV candles from 1 second to 1 day, and a unified activity feed for any Robinhood Chain token. Source: https://docs.crius.sh/reference/trades/ · Updated 2026-10-28 The trade tape, candles and the full activity feed of a token. **Who actually traded.** On-chain, `tx.from` and the swap's sender are often infrastructure: routers, aggregators, Relay solvers, ERC-4337 bundlers, launchpad helpers, bot contracts. Every trade is attributed to the address whose balance actually changed (the **trader**), and the infrastructure that sent it is reported separately as `executor` and `signer`. One transaction can contain several trades. ## Endpoints [GET /token/{address}/trades Trade tape Anonymous · 2 cr](https://docs.crius.sh/reference/trades/trade-tape/) [GET /token/{address}/candles OHLCV candles Anonymous · 2 cr](https://docs.crius.sh/reference/trades/ohlcv-candles/) [GET /token/{address}/transactions Activity feed Free · 2 cr](https://docs.crius.sh/reference/trades/activity-feed/) --- # Activity feed > One chronological feed of everything that happened to the token: buys and sells, liquidity adds and removes, plain transfers, mints and burns, LP lock events,… Source: https://docs.crius.sh/reference/trades/activity-feed/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/transactions One chronological feed of everything that happened to the token: buys and sells, liquidity adds and removes, plain transfers, mints and burns, LP lock events, fee claims, owner actions on the contract (`renounceOwnership`, `openTrading`, setters, upgrades) and launchpad lifecycle events. Filter with `type` (comma list), `wallet`, `min_usd`, `from`/`to` and `finality`. > Trades, liquidity adds/removes, transfers, mints/burns, owner actions (decoded), locks, fee claims, launch / graduation. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `type`string Filter by item type. Comma list of `buy`, `sell`, `add_liquidity`, `remove_liquidity`, `transfer`, `mint`, `burn`, `owner_action`, `lock`, `fee_claim`, `launch`, `graduation`. `wallet`string Only events involving this wallet. `min_usd`number Only items worth at least this many USD. `from`string Start of the window (`block:`, `ts:`, `mcap:` or a label). One of `block:N`, `ts:MS`, `mcap:USD`, `launch`, `trading_open`, `graduation`, `ath`. `to`string End of the window (same forms as `from`). `finality`string Only rows at or below this finality level. One of `latest`, `safe`, `finalized`. `limit`integer Default `50` Maximum number of items to return. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Get every trade of a Robinhood Chain token (trade tape)**Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key.](https://docs.crius.sh/guides/get-token-trades/)[**Get a token's full activity feed (trades, transfers, liquidity)**Get every event of a Robinhood Chain token in one feed, from trades and transfers to liquidity, burns, owner actions, locks and graduation, with real examples.](https://docs.crius.sh/guides/get-token-activity-feed/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More trades & candles endpoints [GET/token/{address}/tradesTrade tapeAnonymous · 2 cr](https://docs.crius.sh/reference/trades/trade-tape/)[GET/token/{address}/candlesOHLCV candlesAnonymous · 2 cr](https://docs.crius.sh/reference/trades/ohlcv-candles/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/transactions?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "actor": "0xffb51d3cc36b1356d5b9418198adee9f29283c58", "actor_tags": [], "amount_base": 788818.58267172958349331, "amount_quote": 0.001303958643843039, "block": 100128111, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "100128111-7-34", "method": "dagSwapTo(uint256,address,(uint256,address,uint256,uint256,uint256),(address[],address[],uint256[],bytes[],uint256)[])", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0xffb51d3cc36b1356d5b9418198adee9f29283c58", "trader_tags": [], "ts": 1793196203320, "tx": "0x8d68dc0ee4294bf07b052c4684ccc7211e9944438fa23c0866ccadb1aa1a0999", "type": "sell", "value_usd": 3.04084 }, { "actor": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c", "actor_tags": [], "amount_base": 740848.926745217054477405, "amount_quote": 0.001227267922525477, "block": 99713565, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "99713565-9-26", "method": null, "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0x06386c82d3d4be2704f9ca7da3b0b7422cf7472c", "trader_tags": [], "ts": 1793152958500, "tx": "0x74cd5b3dd10ab859b6e6da32e9352880cce954a8702378879f078c76936dc489", "type": "sell", "value_usd": 2.88648 }, { "actor": "0x4337044e8b7a221d141fe622eb2460f050a6b6c2", "actor_tags": [], "amount_base": 3467283.726496635780002732, "amount_quote": 0.005777579700862946, "block": 99235194, "dex": "uniswap_v4", "fees": { "token_tax": { "pct": 0 } }, "finality": "finalized", "id": "99235194-5-13", "method": "handleOps((address,uint256,bytes,bytes,bytes32,uint256,bytes32,bytes,bytes)[],address)", "pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "quote_symbol": "ETH", "trader": "0x4498f864313237eb18f593fecd47181979551376", "trader_tags": [ "smart_account", "fomo" ], "ts": 1793103300400, "tx": "0x504e29889e0ff0dd2a4a5e70f4e47d2fe0f9c48eed33604fad83a199efd10c94", "type": "sell", "value_usd": 13.3484 } ], "meta": { "block": 100406803, "block_age_ms": 823, "block_ts": 1793225078000, "chain": "robinhood", "finalized_block": 100397649, "history": "complete", "lag_ms": 80, "next_cursor": "99235194-13", "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Ftransactions&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftrades%2Factivity-feed%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # OHLCV candles > Candles in columnar form (one array per field, aligned by index), which is compact and maps straight onto charting libraries. Source: https://docs.crius.sh/reference/trades/ohlcv-candles/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/candles Candles in **columnar** form (one array per field, aligned by index), which is compact and maps straight onto charting libraries. Intervals: `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h`, `1d`. Up to 1,500 candles per call; buckets without trades are omitted. By default (USD) candles merge the token's real markets: every pool with at least $1k or 2% of its liquidity, plus its launch curve for launchpad tokens. Thin side pools stay out, so a $1 trade there can't draw a wick. `pool=main` charts the main market only (the default with `currency=quote`, prices in the pool's quote token), `pool=` one pool, `pool=all` every pool. Each candle opens at the previous close (`continuous=false` for first-trade opens), and `fill=true` adds flat candles for buckets without trades so the time axis is evenly spaced. Dust trades (under 10,000 raw units on either side) never set a price. **Which trades set a candle's price.** Candles are drawn from real market prices, so a few trades on the tape don't move them. They still count in volume and trade counts, so OHLC can differ from aggregating the raw tape: - trades under $1, and a buy and sell of the same size in one pool and block (round trips); - trades in a minor pool (under 5% of the token's volume) more than 1.1x away from the main market's last price, and any pool's trade more than 1.3x away from the dominant market's recent price; - a trade more than 5x away from its 10-minute value-weighted median, and an isolated spike (both neighbours agreeing with each other, the trade far from both); - a launch ladder: trades in the launch block, or among the first 50 trades within 20 blocks of it, more than 10x away from the median of the first 20 trades after those 20 blocks. For the exact tape, use the [trade tape](https://docs.crius.sh/reference/trades/trade-tape/) for the same window. See the [chart example](https://docs.crius.sh/examples/chart/) for a complete TradingView Lightweight Charts integration. > Default (usd): the token's real markets merged (pools with >= $1k or >= 2% of its liquidity) plus its launch curve; ?pool=main its main market only; ?pool=all every pool. Candles open at the previous close. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `interval`string Default `1m` Bucket size. One of `1s`, `30s`, `1m`, `5m`, `15m`, `1h`, `4h`, `6h`, `1d`. `limit`integer Default `500` Maximum number of items to return. `from_ts`integer Start of the time range, unix milliseconds (inclusive). `to_ts`integer End of the time range, unix milliseconds (inclusive). `currency`string Default `usd` Price unit. One of `usd`, `quote`. `pool`string Pool address (Uniswap v2/v3) or 32-byte pool id (Uniswap v4). Markets (default for usd) | main (default for quote) | all | a pool id. `continuous`boolean Default `true` `true`: the holder must stay above the threshold for the whole window. Open = previous close. `fill`boolean Default `false` Flat candles for buckets without trades. ## Key response fields - `t`: bucket start (unix ms) · `o` `h` `l` `c`: open, high, low, close - `v`: USD volume · `bv`: buy volume (sell volume = `v − bv`) · `n`: number of trades · `mc`: market cap at close ## Guides that use this endpoint [**Get OHLCV candles for Robinhood Chain tokens (OHLCV API)**Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code.](https://docs.crius.sh/guides/get-ohlcv-candles/)[**Get a token's all-time high and price change**Get a Robinhood Chain token's all-time high, when it was set, its market cap at the peak and its price change from 1 second to 24 hours, plus 7-day change.](https://docs.crius.sh/guides/get-all-time-high-and-price-change/)[**Stream live candles for a Robinhood Chain token chart**Keep a Robinhood Chain candlestick chart live: load candles over REST, update the last bar from the Crius WebSocket, with a runnable Node.js relay.](https://docs.crius.sh/guides/stream-live-candles/)[**Use the Crius API from AI agents (OpenAPI, llms.txt, MCP)**Give an AI agent Robinhood Chain data: Crius docs as llms.txt and Markdown, tool definitions from the OpenAPI document, an MCP server, and accuracy tips.](https://docs.crius.sh/guides/use-crius-with-ai-agents/)[**Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume**Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades.](https://docs.crius.sh/guides/robinhood-chain-dex-data/)[**Robinhood Chain API for AI agents**Give an AI agent Robinhood Chain data with the Crius API: which endpoints to expose as tools, the OpenAPI document, structured errors and citing the block.](https://docs.crius.sh/use-cases/ai-agents/)[**Robinhood Chain API for analytics dashboards**Build Robinhood Chain dashboards with the Crius API: DEX volume without wash trades, TVL, launches per launchpad, hourly patterns and token charts.](https://docs.crius.sh/use-cases/analytics-dashboards/)[**Robinhood Chain API for Telegram and Discord bots**Build a Robinhood Chain token scanner, buy bot or launch-alert channel for Telegram or Discord with the Crius API, with real replies and credit costs.](https://docs.crius.sh/use-cases/telegram-and-discord-bots/)[**Robinhood Chain API for token screeners**Build a Robinhood Chain token screener with the Crius API: new, trending and graduating lists, batch profiles, candles and risk badges, with credit costs.](https://docs.crius.sh/use-cases/token-screeners/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More trades & candles endpoints [GET/token/{address}/tradesTrade tapeAnonymous · 2 cr](https://docs.crius.sh/reference/trades/trade-tape/)[GET/token/{address}/transactionsActivity feedFree · 2 cr](https://docs.crius.sh/reference/trades/activity-feed/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/candles?interval=1h&limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "bv": [ 7719250, 3592353, 454055 ], "c": [ 2358.89, 2361.93, 2357.69 ], "currency": "usd", "h": [ 2389.5, 2369.36, 2363.53 ], "interval": "1h", "l": [ 2345.91, 2345.98, 2353.91 ], "mc": [ 90541111, 90657707, 90494986 ], "n": [ 21263, 23756, 3140 ], "o": [ 2369.35, 2358.89, 2361.93 ], "t": [ 1793217600000, 1793221200000, 1793224800000 ], "v": [ 15761872, 7055129, 1053224 ] }, "meta": { "block": 100406798, "block_age_ms": 1271, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "from_ts": 1793217600000, "lag_ms": 78, "note": "default (usd) = the token's real markets merged plus its launch curve; ?pool=main its main market only (the default with currency=quote), ?pool= one pool, ?pool=all every pool. Candles open at the previous close (?continuous=false for first-trade opens); buckets without trades are omitted unless ?fill=true", "pools": [ "0xa9188730fe85be88ad499d7d52b099e800fb0334", "0x69bfaf19c9f377bb306a89aed9f6b07e2c1a8d9a", "0xd42a491087a15e5afd51feb3606066cc152d2b09" ], "safe_block": 100401329, "to_ts": 1793225077000 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fcandles&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftrades%2Fohlcv-candles%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Trade tape > Newest first. Each trade carries side, amounts in human units, USD and ETH value, the price, pool and DEX, the attributed trader, gas and token tax, and its… Source: https://docs.crius.sh/reference/trades/trade-tape/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/trades Newest first. Each trade carries side, amounts in human units, USD and ETH value, the price, pool and DEX, the attributed trader, gas and token tax, and its `finality` (`latest` → `safe` → `finalized`). Filter by `side`, `trader`, `min_usd` and a time range; paginate with `cursor`. USD values are computed when the trade is indexed: the quote amount times the quote's USD price at that block, from on-chain markets (ETH via the WETH/USDG pool). `eth_usd_at_trade` is that block's ETH/USD (exact for ETH and WETH-quoted trades: `value_usd / value_eth`); `price_eth` comes from the amounts for ETH-quoted trades, else from `price_usd` and that rate. In the chain's first days (before about June 24, 2026) the WETH/USDG pool was new and thin, so USD values from then are estimates from its spot price. > Real trader attribution, USD at trade time, realized tax, gas (L2 + L1). ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `limit`integer Default `50` Maximum number of items to return. Up to 500. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. `side`string `buy` or `sell`. `trader`string Only trades by this trader address. `min_usd`number Only items worth at least this many USD. `from_ts`integer Start of the time range, unix milliseconds (inclusive). `to_ts`integer End of the time range, unix milliseconds (inclusive). `app`string Fomo: only trades made through this app, executed by its relayers (the relayer shows as signer\_label; trader\_app marks the app's own smart wallets) ## Guides that use this endpoint [**Get OHLCV candles for Robinhood Chain tokens (OHLCV API)**Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code.](https://docs.crius.sh/guides/get-ohlcv-candles/)[**Stream Robinhood Chain trades over WebSocket**Stream every trade of a Robinhood Chain token, pool or wallet over the Crius WebSocket, with Node.js and Python clients that reconnect, resume and backfill.](https://docs.crius.sh/guides/stream-trades-websocket/)[**Get every trade of a Robinhood Chain token (trade tape)**Get every buy and sell of a Robinhood Chain token with USD value, price, gas, tax and the real trader behind routers and smart wallets. Real examples, no key.](https://docs.crius.sh/guides/get-token-trades/)[**Stream live candles for a Robinhood Chain token chart**Keep a Robinhood Chain candlestick chart live: load candles over REST, update the last bar from the Crius WebSocket, with a runnable Node.js relay.](https://docs.crius.sh/guides/stream-live-candles/)[**Get a token's full activity feed (trades, transfers, liquidity)**Get every event of a Robinhood Chain token in one feed, from trades and transfers to liquidity, burns, owner actions, locks and graduation, with real examples.](https://docs.crius.sh/guides/get-token-activity-feed/)[**Find a token's top traders and their PnL**Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained.](https://docs.crius.sh/guides/get-top-traders-pnl/)[**Move from raw RPC calls to the Crius API on Robinhood Chain**Replace eth\_getLogs scans, slot0 math and Transfer replays with Crius API calls on Robinhood Chain: a mapping table, before/after code and credit costs.](https://docs.crius.sh/guides/migrate-from-rpc-to-crius/)[**Get a wallet's trade history**List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time.](https://docs.crius.sh/guides/get-wallet-trade-history/)[**Robinhood Chain DEX data: which DEXs trade, and how to get their trades, pools and volume**Which DEXs trade on Robinhood Chain (Uniswap v2, v3, v4 with hooks, launchpad curves), their real 24h volume and pools, and the API calls for DEX trades.](https://docs.crius.sh/guides/robinhood-chain-dex-data/)[**Robinhood Chain API for trading bots**What a Robinhood Chain trading bot needs from the Crius API: new launches, live prices, pools and safety checks before every buy, with credit costs.](https://docs.crius.sh/use-cases/trading-bots/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More trades & candles endpoints [GET/token/{address}/candlesOHLCV candlesAnonymous · 2 cr](https://docs.crius.sh/reference/trades/ohlcv-candles/)[GET/token/{address}/transactionsActivity feedFree · 2 cr](https://docs.crius.sh/reference/trades/activity-feed/) Request No key needed **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0bd7d308f8e1639fab988df18a8011f41eacad73/trades?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [ { "amount_base": 0.241346083005198446, "amount_quote": 569.019791, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 239930, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000503853, "total_eth": 0.00000503853, "usd": 0.0118753 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-6-44", "market_cap_usd_at_trade": 90494155, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00034, "price_usd": 2357.69, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "signer_label": null, "trader": "0xe950337f36e45c316c53c69a5f285487b54f0bad", "trader_app": null, "trader_label": "fomo_relayer_3", "ts": 1793225076000, "tx": "0x5b474612139f91cb226cf9e5097244dbb896a86834d8adbd263641c96d67b9f7", "tx_index": 6, "type": "buy", "value_eth": 0.241428, "value_usd": 569.02, "via": [] }, { "amount_base": 0.021222351350879784, "amount_quote": 50.025498, "block": 100406784, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.021, "gas_used": 455557, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.0000095667, "total_eth": 0.0000095667, "usd": 0.0225477 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406784-1-12", "market_cap_usd_at_trade": 90475571, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00013, "price_usd": 2357.21, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x800539138ff0510191277f6b5c58fb94ae700064", "signer_label": null, "trader": "0x800539138ff0510191277f6b5c58fb94ae700064", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0x0bde8abf03edce0f2ba13a3398ec2575b177c3f2d85eef77c25c7899a9949311", "tx_index": 1, "type": "sell", "value_eth": 0.0212252, "value_usd": 50.0255, "via": [ "uniswap_universal_router" ] }, { "amount_base": 0.011210844980975568, "amount_quote": 26.431588, "block": 100406782, "dex": "uniswap_v3", "eth_usd_at_trade": 2356.9, "executor": null, "fees": { "gas": { "gas_price_gwei": 0.020904, "gas_used": 315171, "gas_used_l1": 0, "l1_eth": 0, "l2_eth": 0.00000658833, "total_eth": 0.00000658833, "usd": 0.015528 }, "token_tax": { "pct": null } }, "finality": "latest", "id": "100406782-10-32", "market_cap_usd_at_trade": 90493695, "pool": "0x52e65b17fb6e5ba00ed806f37afcd2daa50271ca", "price_eth": 1.00033, "price_usd": 2357.68, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_symbol": "USDG", "signer": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "signer_label": null, "trader": "0x8a2a3d6fcefd9427ac46b07c91d21207aaa0e168", "trader_app": null, "trader_label": null, "ts": 1793225076000, "tx": "0xa3a9ddaaa96d7cc4d300eb5ae37d174755cee56aec3e5e15ae7c3adf437a113b", "tx_index": 10, "type": "buy", "value_eth": 0.0112146, "value_usd": 26.4316, "via": [ "gmgn_swap_router" ] } ], "meta": { "block": 100406789, "block_age_ms": 367, "block_ts": 1793225077000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 7, "next_cursor": "100406782-32", "safe_block": 100401329 } } ``` [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Ftrades&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Ftrades%2Ftrade-tape%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Bundles & bubble maps API > Sniper, bundle and cluster detection and holder bubble-map graphs for Robinhood Chain tokens. Source: https://docs.crius.sh/reference/wallet-graph/ · Updated 2026-10-28 Graph analytics over holders. A **bundle** is one transaction buying for several recipients, a launch transaction that also buys, two or more wallets buying in the same block that share a funder, or wallets forwarding tokens to a common wallet. ## Endpoints [GET /token/{address}/bundles Snipers, bundles & clusters Starter · 10 cr](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) [GET /token/{address}/bubblemap Bubble map Starter · 10 cr](https://docs.crius.sh/reference/wallet-graph/bubble-map/) --- # Bubble map > The top holders (top, up to 500) as nodes and the links between them as edges: funding between holders, token transfers between holders, and funders shared by… Source: https://docs.crius.sh/reference/wallet-graph/bubble-map/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/bubblemap The top holders (`top`, up to 500) as nodes and the links between them as edges: funding between holders, token transfers between holders, and funders shared by two or more of them. Each cluster lists its members and why they are linked (`links`: shared funders, funding and transfers between them). Only real holders are on the map. Pools, the Uniswap V4 PoolManager, LP lockers, hooks, burn addresses, routers, other contracts and exchanges are listed under `hidden_infra` with their share. Funding from exchanges, bridges and app relayers (one signer paying the same 100+ wallets again and again) never links wallets, and dust sends from lookalike addresses (address poisoning) are ignored. `include=infra,hubs,funders` brings infrastructure, hub funding and single-wallet funders back. Pass `block` for a historical map. Ready to render with any force-directed graph library. > Nodes = holders (+ funders shared by 2+ of them), edges = funding / transfers / common funders; clusters with the links that make them. Infrastructure (pools, PoolManager, lockers, hooks, burn, routers, contracts, exchanges) is listed under hidden\_infra, not on the map. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `top`integer Default `100` Number of top holders to include as nodes. Up to 500. `edges`string Default `funding,transfers,common_funder` Which links to include between holders. `include`string Comma list of hidden classes to bring back: `infra` (pools, PoolManager, lockers, hooks, burn, routers, contracts, exchanges), `hubs` (funding from exchanges, bridges, relayers), `funders` (external funders of a single wallet). Infra | hubs | funders (comma-separated) `block`integer Build the map as of this block (historical). ## Guides that use this endpoint [**Get the holders of a Robinhood Chain token (token holders API)**Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share.](https://docs.crius.sh/guides/get-token-holders/)[**Read a token's bubble map and holder clusters**Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters.](https://docs.crius.sh/guides/read-a-bubble-map/)[**Find wallets connected by funding**Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils.](https://docs.crius.sh/guides/find-connected-wallets/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More bundles & bubble maps endpoints [GET/token/{address}/bundlesSnipers, bundles & clustersStarter · 10 cr](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "block": null, "clusters": [], "edges": [], "hidden_infra": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "label": "uniswap_v4_pool_manager", "pct": 22.2145, "tags": [ "pool" ] }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "label": "pons_v2_launch_locker", "pct": 8.16327, "tags": [ "lp_locker" ] }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "label": "pons_v2_meme_hook", "pct": 6.06241, "tags": [ "launchpad" ] }, { "address": "0xbe0b139abc90723af76a89d3051f60ba1b64c8d9", "label": null, "pct": 1, "tags": [ "contract" ] }, { "address": "0xdead000000000000000000000000000000000000", "label": null, "pct": 0.81637, "tags": [ "burn" ] }, { "address": "0x0afeb98a5b40bc38e9cf5a3f202c17843a7ce553", "label": null, "pct": 0.168848, "tags": [ "contract" ] } ], "nodes": [ { "cluster": null, "id": "0xe1a5961d61200006577f2e96114d212889213cd6", "label": null, "pct": 2.82829, "tags": [ "smart_account", "whale" ], "value_usd": 1286.54 }, { "cluster": null, "id": "0xa4109b8d391723d8f6bcfc5d75e6996f61062f76", "label": null, "pct": 2.70423, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1230.11 }, { "cluster": null, "id": "0xf2caeb616fb22a8acc00afbaeee83b24f18b354b", "label": null, "pct": 2.23269, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1015.61 }, { "cluster": null, "id": "0xb9b642020e216e84887ad414e067928e380bbbd5", "label": null, "pct": 1.77186, "tags": [ "whale" ], "value_usd": 805.992 }, { "cluster": null, "id": "0xc9cafef2258a07f8455da92438360318b34848e2", "label": null, "pct": 1.73578, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 789.58 }, { "cluster": null, "id": "0xc51c3340b898a67fed7c9f18db75b346dd04f8a0", "label": null, "pct": 1.63331, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 742.968 } ], "token": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "meta": { "block": 100406890, "block_age_ms": 885, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 30, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fbubblemap&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallet-graph%2Fbubble-map%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Snipers, bundles & clusters > Snipers (bought within the first blocks after trading opened), bundles, funding clusters and the share of supply they hold. Source: https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/token/{address}/bundles Snipers (bought within the first blocks after trading opened), bundles, funding clusters and the share of supply they hold. `window_blocks` sets the sniper window (default 10 blocks). > First 300 blocks of trading. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `window_blocks`integer Default `10` Sniper window after trading opened, in blocks. ## Guides that use this endpoint [**Get a Robinhood Chain token security score**Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples.](https://docs.crius.sh/guides/token-security-score/)[**Add safety checks to a Robinhood Chain trading bot**Keep a Robinhood Chain trading bot away from honeypots, high taxes and pullable liquidity: pre-trade checks with Crius, then live tax and LP alerts.](https://docs.crius.sh/guides/add-safety-checks-to-a-trading-bot/)[**Detect bundled launches, snipers and insiders**Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%.](https://docs.crius.sh/guides/detect-bundles-and-snipers/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More bundles & bubble maps endpoints [GET/token/{address}/bubblemapBubble mapStarter · 10 cr](https://docs.crius.sh/reference/wallet-graph/bubble-map/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x192b126efea71ca5e7767bc6fc53038d869fbbba/bundles", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "bundle_supply_pct": 1, "bundle_supply_pct_now": 0, "bundled": true, "bundles": [ { "block": 100238938, "bought": 10000000.000000000905969664, "cost_eth": 0.0174316, "funder": null, "id": "b_1", "still_holding_pct": 0, "supply_pct": 1, "type": "launch_tx_buy", "wallets": [ "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864" ] } ], "clusters": [], "dev": { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "bought_in_launch_tx": true, "first_buy_pct": 1, "funded_by": null, "holding_pct": 0 }, "early_buyers_analyzed": 54, "insider_launch": true, "launch": { "flags": [ "insider_launch" ], "lp_top_wallet": { "address": "0x6e8244ba97cbb7d136aafc667e8da302140dbc5b", "liquidity_usd": 5.70259, "pct": 0.0996139 }, "sniper_supply_pct": 60.9726, "sniper_top_wallet_pct": 53.1794, "sniper_wallets": 4, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "snipers": { "count": 4, "still_holding_pct": 0, "supply_pct": 60.9726, "wallets": [ { "address": "0xa6aeefb9c26ec96eb5fbde3ade8632ab2a8ac864", "tags": [ "dev", "sniper" ] }, { "address": "0x0f0bb85fddc70f04344bc7704bb940e387ae7762", "tags": [ "sniper" ] }, { "address": "0x5051e45b2dbecf1b2041af3937bd85fc0dc43cd4", "tags": [ "sniper" ] }, { "address": "0x217be8970fa83b0864ca06d3c18ea6d9ac04e3a5", "tags": [ "sniper" ] } ], "window_blocks": 10 }, "trader_funding": { "bridge": 18, "dev_linked": 1, "other_wallets": 21, "protocol": 3, "unknown": 6, "unlabeled_hub": 5 } }, "meta": { "block": 100406882, "block_age_ms": 1103, "block_ts": 1793225086000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 134, "safe_block": 100401329, "scope": "first 300 blocks of trading" } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Ftoken%2F%7Baddress%7D%2Fbundles&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallet-graph%2Fsnipers-bundles-clusters%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Wallets & devs API > Wallet profiles with holdings and PnL, wallet trade history, funding connections and token developer profiles on Robinhood Chain. Source: https://docs.crius.sh/reference/wallets/ · Updated 2026-10-28 Wallet-level data: what a wallet holds and earned, every trade it made, who funded it, and for token creators, every token they launched and how those did. ## Endpoints [GET /wallet/{address} Wallet profile Starter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-profile/) [GET /wallet/{address}/trades Wallet trades Starter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-trades/) [GET /wallet/{address}/connections Wallet connections Starter · 10 cr](https://docs.crius.sh/reference/wallets/wallet-connections/) [GET /dev/{address} Developer profile Free · 5 cr](https://docs.crius.sh/reference/wallets/developer-profile/) --- # Developer profile > A token creator's track record: every token they deployed or launched, with peak market cap, current state and outcomes. Source: https://docs.crius.sh/reference/wallets/developer-profile/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/dev/{address} A token creator's track record: every token they deployed or launched, with peak market cap, current state and outcomes. > Tokens created (launchpad + direct deployments), outcomes, funding. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `sort`string Default `created` Sort order. One of `created`, `ath`, `market_cap`. `limit`integer Default `50` Maximum number of items to return. ## Guides that use this endpoint [**Find wallets connected by funding**Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils.](https://docs.crius.sh/guides/find-connected-wallets/)[**Check a token developer's history (past launches and rugs)**Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling.](https://docs.crius.sh/guides/check-developer-history/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More wallets & devs endpoints [GET/wallet/{address}Wallet profileStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-profile/)[GET/wallet/{address}/tradesWallet tradesStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-trades/)[GET/wallet/{address}/connectionsWallet connectionsStarter · 10 cr](https://docs.crius.sh/reference/wallets/wallet-connections/) Request Needs a Free key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?sort=created" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?sort=created", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/dev/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?sort=created", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "first_seen_ts": 1792283372000, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "label": "bridge:Relay solver" }, "summary": { "best_ath_market_cap_usd": 68675.8, "by_launchpad": { "pons": 1 }, "graduated": 1, "graduation_rate_pct": 100, "median_ath_market_cap_usd": 68675.8, "rugged": 0, "tokens_created": 1 }, "tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "ath_scope": "all_time", "created_block": 88385886, "created_ts": 1791982834000, "deployed_via": "launchpad", "dev_sold_pct": null, "launchpad": "pons", "launchpad_name": "Pons", "liquidity_usd": 5611.81, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "market_cap_usd": 3773.42, "name": "Charge AI", "rugged": false, "status": "graduated", "symbol": "CHARGE" } ], "top_tokens": [ { "address": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "ath_market_cap_usd": 68675.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8.png?size=128", "symbol": "CHARGE" } ] }, "meta": { "block": 100406874, "block_age_ms": 1212, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 26, "next_cursor": null, "rugged_rule": "market cap < 10% of ATH (ATH > $5k) and liquidity < $500", "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fdev%2F%7Baddress%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallets%2Fdeveloper-profile%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Wallet connections > Wallets connected to this one through funding and transfers: who funded it, who it funded, and wallets sharing a funder. Source: https://docs.crius.sh/reference/wallets/wallet-connections/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/wallet/{address}/connections Wallets connected to this one through funding and transfers: who funded it, who it funded, and wallets sharing a funder. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `limit`integer Default `25` Maximum number of items to return. ## Guides that use this endpoint [**Get a wallet's holdings and PnL on Robinhood Chain**Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example.](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/)[**Find wallets connected by funding**Find who funded a Robinhood Chain wallet, which wallets it funded, who it swaps tokens with and who shares its funder, to spot alt wallets, dev links, sybils.](https://docs.crius.sh/guides/find-connected-wallets/)[**Check a token developer's history (past launches and rugs)**Check a Robinhood Chain token creator's track record in one call: every token they launched, peak and current market cap, graduations, rugs, dev selling.](https://docs.crius.sh/guides/check-developer-history/)[**Robinhood Chain API for risk and compliance**Screen Robinhood Chain tokens and wallets with the Crius API: security checks, insider launches, funding links, developer history and LP locks.](https://docs.crius.sh/use-cases/risk-and-compliance/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More wallets & devs endpoints [GET/wallet/{address}Wallet profileStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-profile/)[GET/wallet/{address}/tradesWallet tradesStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-trades/)[GET/dev/{address}Developer profileFree · 5 cr](https://docs.crius.sh/reference/wallets/developer-profile/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/connections", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "cluster": { "funder": "0xd782268f600403843484b70710daee6846fc0db8", "id": "f_359981", "wallets": 1 }, "funded": [ { "address": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "eth": 0.0005, "first_block": 88385886, "is_dev": false, "label": "pons_v2_launch_factory", "txs": 1 }, { "address": "0xbcb09304eb37d79aada84e23710158e48fb15a3d", "eth": 0.11, "first_block": 89257687, "is_dev": false, "label": null, "txs": 2 }, { "address": "0x0cfbf98d825035fc049d9914b644d7887de27d6c", "eth": 0.01, "first_block": 90076749, "is_dev": false, "label": null, "txs": 1 } ], "funded_by": [ { "address": "0xd782268f600403843484b70710daee6846fc0db8", "eth": 0.008148386337868892, "first_block": 87601233, "is_dev": false, "label": "bridge:Relay solver", "txs": 1 } ], "linked_devs": [], "note": "ETH funding = top-level ETH transfers + internal (contract) transfers from call traces; swap / launchpad payouts are not funding", "scope": "all_history", "shared_funder_with": [], "transfers": [ { "address": "0xfbb464318e8c283a2bf186b6bd6420143338e1c8", "count": 2, "direction": "in", "is_dev": false, "tokens": 2 }, { "address": "0xbfd9bf98dc34cf4696ee73c781c3039a14ce5915", "count": 2, "direction": "out", "is_dev": false, "tokens": 2 }, { "address": "0x0cfbe3b71266a6ec456c0faaf9805730c6a67d6c", "count": 1, "direction": "out", "is_dev": false, "tokens": 1 } ], "wallet": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" }, "meta": { "block": 100406869, "block_age_ms": 932, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 88, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fwallet%2F%7Baddress%7D%2Fconnections&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallets%2Fwallet-connections%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Wallet profile > Holdings with USD value, realized and unrealized PnL over a window (1d, 7d, 30d, all), win rate and wallet tags. Source: https://docs.crius.sh/reference/wallets/wallet-profile/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/wallet/{address} Holdings with USD value, realized and unrealized PnL over a window (`1d`, `7d`, `30d`, `all`), win rate and wallet tags. `min_value_usd` hides dust. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `window`string Default `30d` Stats window. One of `1d`, `7d`, `30d`, `all`. `min_value_usd`number Hide holdings worth less than this many USD. ## Guides that use this endpoint [**Find a token's top traders and their PnL**Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained.](https://docs.crius.sh/guides/get-top-traders-pnl/)[**Get a wallet's holdings and PnL on Robinhood Chain**Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example.](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/)[**Get a wallet's trade history**List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time.](https://docs.crius.sh/guides/get-wallet-trade-history/)[**Get wallet token balances on Robinhood Chain (balances API)**Get every token balance of a Robinhood Chain wallet (USDG, tokenized stocks, ETH) in USD in one call, one token's balances across wallets, and batch prices.](https://docs.crius.sh/guides/get-wallet-token-balances/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More wallets & devs endpoints [GET/wallet/{address}/tradesWallet tradesStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-trades/)[GET/wallet/{address}/connectionsWallet connectionsStarter · 10 cr](https://docs.crius.sh/reference/wallets/wallet-connections/)[GET/dev/{address}Developer profileFree · 5 cr](https://docs.crius.sh/reference/wallets/developer-profile/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?window=30d" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?window=30d", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca?window=30d", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": { "account_type": "smart_account", "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "delegate": "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b", "holdings": [ { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500064, "value_usd": 0.0117789 }, { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0x06993ae1230d3755b54f25022028daa66772bc3d", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500061, "value_usd": 0.0117789 } ], "holdings_truncated": false, "holdings_value_usd": 0.0235578, "is_contract": false, "label": null, "native_balance": 0.71473787532832551, "native_value_usd": 1683.56, "pnl": { "avg_hold_time_s": null, "best_trade": null, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 0.198772, "realized_usd": 0, "tokens_traded": 0, "tokens_with_known_cost": 0, "total_usd": 0, "trades": 0, "unrealized_usd": 0, "volume_usd": 0, "win_rate_pct": null, "window": "30d", "worst_trade": null }, "profile": { "first_seen_block": 91351250, "first_seen_ts": 1792283372000, "fresh": false, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "block": 87601233, "label": "bridge:Relay solver", "ts": 1791903516300 }, "history": "complete", "tags": [ "dev", "smart_account" ], "tx_count": 14, "wallet_age_days": 10.8994 } }, "meta": { "balances_block": 100406864, "block": 100406864, "block_age_ms": 1301, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 59, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fwallet%2F%7Baddress%7D&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallets%2Fwallet-profile%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Wallet trades > Every trade the wallet made across all tokens, newest first, in the same shape as the trade tape plus the token. Source: https://docs.crius.sh/reference/wallets/wallet-trades/ · Updated 2026-10-28 GET https://api.crius.sh/v1/{chain}/wallet/{address}/trades Every trade the wallet made across all tokens, newest first, in the same shape as the trade tape plus the token. Filter by `token`, `side`, `min_usd` and time. ## Path parameters `chain`stringrequired Chain slug (`robinhood`) or chain id (`4663`). `address`stringrequired Contract or wallet address, any case (`0x…`, 20 bytes). ## Query parameters `token`string Only trades of this token. `side`string `buy` or `sell`. `min_usd`number Only items worth at least this many USD. `from_ts`integer Start of the time range, unix milliseconds (inclusive). `to_ts`integer End of the time range, unix milliseconds (inclusive). `limit`integer Default `50` Maximum number of items to return. `cursor`string Pagination cursor from the previous response's `meta.next_cursor`. ## Guides that use this endpoint [**Get a wallet's holdings and PnL on Robinhood Chain**Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example.](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/)[**Get a wallet's trade history**List every trade a Robinhood Chain wallet made across all tokens, with USD value at trade time, market cap, DEX and gas. Filter by token, side, size, time.](https://docs.crius.sh/guides/get-wallet-trade-history/)[**Robinhood Chain API for wallets and portfolio apps**What a Robinhood Chain wallet or portfolio app needs from the Crius API: holdings, USD values, PnL, trade history and warnings about spam tokens.](https://docs.crius.sh/use-cases/wallets-and-portfolio-apps/) ## Errors Errors come back as `{ "error": { "code", "message" } }` with the matching HTTP status: `400` bad parameter, `401` missing or invalid key, `403` endpoint above your plan, `404` unknown token or address, `429` rate limit or credits used up (with `Retry-After`). See [Errors](https://docs.crius.sh/errors/). ## More wallets & devs endpoints [GET/wallet/{address}Wallet profileStarter · 5 cr](https://docs.crius.sh/reference/wallets/wallet-profile/)[GET/wallet/{address}/connectionsWallet connectionsStarter · 10 cr](https://docs.crius.sh/reference/wallets/wallet-connections/)[GET/dev/{address}Developer profileFree · 5 cr](https://docs.crius.sh/reference/wallets/developer-profile/) Request Needs a Starter key **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=20" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=20", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca/trades?limit=20", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` Response 200 · captured Oct 28, 2026 ```json { "data": [], "meta": { "block": 100406866, "block_age_ms": 557, "block_ts": 1793225085000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 110, "next_cursor": null, "safe_block": 100401329 } } ``` [Get a key for this endpoint](https://dashboard.crius.sh/signup?ref=docs-endpoint) [Report an issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20GET%20%2Fv1%2F%7Bchain%7D%2Fwallet%2F%7Baddress%7D%2Ftrades&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Freference%2Fwallets%2Fwallet-trades%2F%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) --- # Bankr on Robinhood Chain (Doppler launches, contracts and API) > How Bankr launches tokens on Robinhood Chain through Doppler on Uniswap v4, how Crius tells real Bankr tokens from copies, contract addresses and API. Source: https://docs.crius.sh/launchpads/bankr/ · Updated 2026-10-28 Short answer Bankr tokens are launched by the Bankr agent through the shared Doppler Airlock (`0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862`) straight into a Uniswap v4 pool with locked liquidity: there is no bonding curve and no graduation (`status: "launched"`). List them with `GET /v1/robinhood/tokens?launchpad=bankr`, get stats with `GET /v1/robinhood/launchpads/bankr`, and one token's launch and pools with `/token/{address}/launch`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Bankr](https://bankr.bot) is an AI agent that launches tokens from a chat, a social post or its API, and Robinhood Chain is its default chain. Bankr doesn’t run its own launch contracts: it uses **Doppler**, a shared launch protocol on Uniswap v4. A Bankr token is created in one transaction with its own v4 pool, already trading, with liquidity that can never be withdrawn. There is no bonding curve to fill and nothing to graduate from, which is why Crius reports Bankr tokens with `status: "launched"`. ## Bankr at a glance | | Bankr | | --- | --- | | Crius launchpad id | `bankr` | | Launch | The Bankr agent calls the shared Doppler Airlock with Bankr's integrator address; token addresses end in `ba3` | | Supply | 100 billion tokens, fixed; 15% vests to the creator (30-day cliff, then one year) | | Market | Uniswap v4 pool from the first block (dynamic fee, tick spacing 200), hook DopplerHookInitializer | | Quote assets | WETH by default; stock tokens (NVDA, TSLA, SPY, SPCX, META and others), BNKR, musebook, USDG | | Graduation | None: liquidity locked permanently, no migration | | Fees (standard) | 0.7% pool fee (95% to the creator) plus a hook fee, about 1.75% in total; an anti-snipe fee from 80% over ~14 seconds; 2% max wallet for the first ~5 minutes | ## How a Bankr token launches 1. **Launch.** Bankr calls `create` on the Doppler Airlock with its integrator address. The Doppler token factory deploys the token as a clone at an address Bankr has mined to end in `ba3`; the Airlock emits `Create` and the v4 PoolManager initializes the pool. 2. **Liquidity.** The DopplerHookInitializer places the sale supply in three single-sided positions on the v4 pool (a “multicurve”) and locks them. Buyers trade against those positions like any v4 pool; Crius indexes the swaps directly. 3. **Fees.** The pool’s LP fee goes 95% to the creator’s fee recipient and 5% to the Doppler protocol owner. The Rehype Doppler hook adds its own fee, starting at 80% and decaying over the first seconds, then splits it between LP reinvestment, the Bankr protocol and BNKR buybacks. 4. **Vesting.** 15% of the supply stays in the token contract and vests to the creator after a 30-day cliff over one year. Watch the creator’s wallet with [`/dev/{address}`](https://docs.crius.sh/reference/wallets/developer-profile/) when the cliff ends. Because the Airlock is shared (it had recorded 212,622 launches by many integrators when Crius researched it, 99,381 of them with Bankr’s integrator), Crius attributes a token to Bankr only when both the integrator address and the `ba3` suffix match. Copies that pass Bankr’s integrator address without the suffix stay unattributed. ## Bankr contracts on Robinhood Chain | Contract | Address | What it does | | --- | --- | --- | | Doppler Airlock | `0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862` | Shared Doppler launch entry point; emits `Create` for every launch (Bankr's `launch_contracts` in Crius) | | Bankr integrator | `0xf60633d02690e2a15a54ab919925f3d038df163e` | Bankr's address recorded by the Airlock for its launches | | DopplerHookInitializer | `0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544` | Uniswap v4 hook of every Bankr pool; holds the locked curve positions | | RehypeDopplerHookInitializer | `0x9982538f41f2ae29ddb9d3d9307010052984fdbb` | Doppler hook for anti-snipe fees, hook fees, buybacks and LP reinvestment (Bankr launches since about block 20.18 million) | | Earlier Doppler hook | `0x6f02324d20cc679d0e585290caa6b16bacbc0f77` | Used by Bankr launches before that (source not verified) | | DopplerERC20V1Factory | `0x1b37d3a72082029c44b35b604ea473617580b69a` | Deploys each token as a clone at a mined `ba3` address | | DopplerERC20V1 | `0x3be8b97fd0e713b5abe0649fa830223b6b4bc599` | Token implementation every Bankr token clones (vesting, max wallet, metadata URI) | | NoOpMigrator | `0xba2f330edb16cd8056f5988d8ce19bbc63475a0e` | Migrator whose `migrate` always reverts: why Bankr tokens never graduate | | LaunchpadGovernanceFactory | `0xdb036746d65dd52126b1915f1adf555e6c5237cf` | Set up with no governance for Bankr tokens | | Doppler protocol owner | `0x21e2ce70511e4fe542a97708e89520471daa7a66` | Airlock owner (Safe); receives 5% of the pool fee | | Uniswap v4 PoolManager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Holds every Bankr pool | ## Query Bankr with Crius Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Bankr stats: 98,672 tokens, none to graduate How active are Bankr launches on Robinhood Chain? GET/v1/robinhood/launchpads/bankr?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/bankr?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/bankr?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/bankr?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 347 lines (arrays trimmed)** ```json { "data": { "contracts": { "launch_contracts": [ "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" ] }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 2694.48, "graduated": 0, "launches": 37, "traders": 1117, "trades": 2790, "volume_usd": 159636 }, { "date": "2026-10-27", "fees_usd": 8283.43, "graduated": 0, "launches": 18, "traders": 1489, "trades": 4156, "volume_usd": 340032 }, { "date": "2026-10-28", "fees_usd": 17614, "graduated": 0, "launches": 20, "traders": 1874, "trades": 6842, "volume_usd": 558397 } ] }, "id": "bankr", "name": "Bankr", "since_block": 1565844, "stats": { "fees_usd_24h": { "lp": 5012.19, "tax": 13032, "total": 18044.2 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 20, "median_blocks_to_graduate": null, "tokens_launched": 98672, "traders_24h": 1964, "trades_24h": 7285, "volume_by_quote_usd_24h": { "eth": 221184, "other": 25229, "stock": 263266, "usdg": 86580.9 }, "volume_usd_24h": 596260 }, "top_tokens_24h": [ { "address": "0x91a2dae9699f0b82540b5886b0d8759c22820ba3", "buy_volume_usd": { "1h": 2145.75, "24h": 94400.2, "5m": 113.621, "6h": 16456.3 }, "buyers": { "1h": 14, "24h": 276, "5m": 3, "6h": 69 }, "buys": { "1h": 58, "24h": 1046, "5m": 3, "6h": 262 }, "change_pct": { "1h": 0.777364, "24h": 23.4488, "5m": -0.577312, "6h": 2.84884 }, "created_block": 64271871, "created_ts": 1789537872100, "decimals": 18, "fdv_usd": 1322521, "holders": 19013, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/musebookinfo", "website": "https://musebook.me/" }, "liquidity_usd": 305854, "logo": "https://api.crius.sh/v1/robinhood/logo/0x91a2dae9699f0b82540b5886b0d8759c22820ba3.png?size=128", "market_cap_usd": 1322483, "name": "musebook", "price_eth": 0.00000000561463, "price_usd": 0.0000132252, "progress_pct": null, "quote": "META", "sell_volume_usd": { "1h": 921.325, "24h": 67841.4, "5m": 0, "6h": 13046.9 }, "sellers": { "1h": 38, "24h": 501, "5m": 0, "6h": 195 }, "sells": { "1h": 41, "24h": 953, "5m": 0, "6h": 271 }, "status": "launched", "symbol": "musebook", "traders": { "1h": 47, "24h": 635, "5m": 3, "6h": 231 }, "txns": { "1h": 79, "24h": 1575, "5m": 3, "6h": 445 }, "volume_usd": { "1h": 3067.07, "24h": 162242, "5m": 113.621, "6h": 29503.2 } }, { "address": "0x100765a16f42636bd84ee1e86bc5107b84bcdba3", "buy_volume_usd": { "1h": 5854.05, "24h": 73424.7, "5m": 551.452, "6h": 17955.6 }, "buyers": { "1h": 14, "24h": 157, "5m": 1, "6h": 52 }, "buys": { "1h": 19, "24h": 372, "5m": 1, "6h": 121 }, "change_pct": { "1h": 7.11771, "24h": 17.3647, "5m": 1.46114, "6h": -7.17469 }, "created_block": 82497389, "created_ts": 1791378640900, "decimals": 18, "fdv_usd": 983488, "holders": 1339, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/ChopLogsApp", "website": "https://choplogs.app/" }, "liquidity_usd": 170464, "logo": "https://api.crius.sh/v1/robinhood/logo/0x100765a16f42636bd84ee1e86bc5107b84bcdba3.png?size=128", "market_cap_usd": 983488, "name": "Chop", "price_eth": 0.00000000417737, "price_usd": 0.00000983976, "progress_pct": null, "quote": "WETH", "sell_volume_usd": { "1h": 2047.61, "24h": 64671.2, "5m": 38.9946, "6h": 22254 }, "sellers": { "1h": 11, "24h": 176, "5m": 1, "6h": 52 }, "sells": { "1h": 14, "24h": 273, "5m": 1, "6h": 71 }, "status": "launched", "symbol": "CHOP", "traders": { "1h": 24, "24h": 278, "5m": 2, "6h": 90 }, "txns": { "1h": 33, "24h": 633, "5m": 2, "6h": 188 }, "volume_usd": { "1h": 7901.66, "24h": 138096, "5m": 590.447, "6h": 40209.6 } }, { "address": "0xa3b6aee90017b72c0812dc1e013de70eb2917ba3", "buy_volume_usd": { "1h": 864.69, "24h": 68400.6, "5m": 3.92806, "6h": 23969.9 }, "buyers": { "1h": 6, "24h": 141, "5m": 2, "6h": 64 }, "buys": { "1h": 19, "24h": 795, "5m": 2, "6h": 322 }, "change_pct": { "1h": 0.261912, "24h": 55.8944, "5m": -0.874171, "6h": 20.5313 }, "created_block": 17423811, "created_ts": 1784823375100, "decimals": 18, "fdv_usd": 1577123, "holders": 3037, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/EARNONHOOD", "website": "https://earnonhood.com/" }, "liquidity_usd": 239150, "logo": "https://api.crius.sh/v1/robinhood/logo/0xa3b6aee90017b72c0812dc1e013de70eb2917ba3.png?size=128", "market_cap_usd": 1553304, "name": "EARN", "price_eth": 0.00000000669551, "price_usd": 0.0000157712, "progress_pct": null, "quote": "SPY", "sell_volume_usd": { "1h": 968.583, "24h": 51263.3, "5m": 341.597, "6h": 17608.8 }, "sellers": { "1h": 8, "24h": 231, "5m": 2, "6h": 97 }, "sells": { "1h": 23, "24h": 1048, "5m": 3, "6h": 412 }, "status": "launched", "symbol": "EARN", "traders": { "1h": 13, "24h": 288, "5m": 4, "6h": 127 }, "txns": { "1h": 16, "24h": 849, "5m": 2, "6h": 338 }, "volume_usd": { "1h": 1833.27, "24h": 119664, "5m": 345.525, "6h": 41578.6 } } ], "type": "config_driven", "website": "https://bankr.bot" }, "meta": { "block": 100410846, "block_age_ms": 1207, "block_ts": 1793225490000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 57, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `tokens_launched: 98672`, `graduated: 0`, `median_blocks_to_graduate: null`: nothing graduates on Bankr. - Only 20 launches in 24 hours, but 7,285 trades by 1,964 traders and $596,260 of volume: Bankr’s activity is in older tokens, not new ones. - `volume_by_quote_usd_24h`: $263,266 against stock tokens, $221,184 against ETH, $86,580.9 against USDG. Stock-paired tokens are Bankr’s biggest market. - `fees_usd_24h`: $5,012.19 of LP fees and $13,032 of token and hook taxes measured from trades. - `history.points`: $159,636, $340,032 and $558,397 of volume on 2026-10-26, 27 and 28. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Bankr%20stats%3A%2098%2C672%20tokens%2C%20none%20to%20graduate&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fbankr%2F%23bankr-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fbankr%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The most traded Bankr tokens Which Bankr tokens traded the most on Robinhood Chain in the last 24 hours? GET/v1/robinhood/tokens?list=top\_volume&launchpad=bankr&window=24h&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=bankr&window=24h&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=bankr&window=24h&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=bankr&window=24h&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x91a2dae9699f0b82540b5886b0d8759c22820ba3", "buy_volume_usd": { "1h": 2157.59, "24h": 94386.2, "5m": 99.6247, "6h": 16599.7 }, "buyers": { "1h": 14, "24h": 276, "5m": 2, "6h": 70 }, "buys": { "1h": 58, "24h": 1045, "5m": 2, "6h": 262 }, "change_pct": { "1h": 0.777364, "24h": 23.4488, "5m": -0.577312, "6h": 3.04214 }, "created_block": 64271871, "created_ts": 1789537872100, "decimals": 18, "fdv_usd": 1322521, "holders": 19013, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/musebookinfo", "website": "https://musebook.me/" }, "liquidity_usd": 305827, "logo": "https://api.crius.sh/v1/robinhood/logo/0x91a2dae9699f0b82540b5886b0d8759c22820ba3.png?size=128", "market_cap_usd": 1322483, "name": "musebook", "price_eth": 0.00000000561463, "price_usd": 0.0000132252, "progress_pct": null, "quote": "META", "sell_volume_usd": { "1h": 960.846, "24h": 67841.4, "5m": 0, "6h": 13046.9 }, "sellers": { "1h": 39, "24h": 501, "5m": 0, "6h": 196 }, "sells": { "1h": 44, "24h": 953, "5m": 0, "6h": 272 }, "status": "launched", "symbol": "musebook", "traders": { "1h": 48, "24h": 635, "5m": 2, "6h": 233 }, "txns": { "1h": 82, "24h": 1574, "5m": 2, "6h": 446 }, "volume_usd": { "1h": 3118.43, "24h": 162228, "5m": 99.6247, "6h": 29646.7 } }, { "address": "0x100765a16f42636bd84ee1e86bc5107b84bcdba3", "buy_volume_usd": { "1h": 5854.05, "24h": 73427, "5m": 551.452, "6h": 17955.6 }, "buyers": { "1h": 14, "24h": 157, "5m": 1, "6h": 52 }, "buys": { "1h": 19, "24h": 373, "5m": 1, "6h": 121 }, "change_pct": { "1h": 7.20335, "24h": 17.6807, "5m": 1.54225, "6h": -8.40756 }, "created_block": 82497389, "created_ts": 1791378640900, "decimals": 18, "fdv_usd": 984275, "holders": 1340, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/ChopLogsApp", "website": "https://choplogs.app/" }, "liquidity_usd": 170541, "logo": "https://api.crius.sh/v1/robinhood/logo/0x100765a16f42636bd84ee1e86bc5107b84bcdba3.png?size=128", "market_cap_usd": 984275, "name": "Chop", "price_eth": 0.00000000418071, "price_usd": 0.00000984763, "progress_pct": null, "quote": "WETH", "sell_volume_usd": { "1h": 2008.62, "24h": 64632.2, "5m": 0, "6h": 22219.1 }, "sellers": { "1h": 10, "24h": 175, "5m": 0, "6h": 53 }, "sells": { "1h": 13, "24h": 272, "5m": 0, "6h": 72 }, "status": "launched", "symbol": "CHOP", "traders": { "1h": 23, "24h": 278, "5m": 1, "6h": 92 }, "txns": { "1h": 32, "24h": 633, "5m": 1, "6h": 189 }, "volume_usd": { "1h": 7862.66, "24h": 138059, "5m": 551.452, "6h": 40174.7 } }, { "address": "0xa3b6aee90017b72c0812dc1e013de70eb2917ba3", "buy_volume_usd": { "1h": 861.372, "24h": 68397.3, "5m": 0.610542, "6h": 23966.5 }, "buyers": { "1h": 5, "24h": 140, "5m": 1, "6h": 63 }, "buys": { "1h": 18, "24h": 794, "5m": 1, "6h": 321 }, "change_pct": { "1h": 0.246678, "24h": 55.8708, "5m": -0.889232, "6h": 20.5129 }, "created_block": 17423811, "created_ts": 1784823375100, "decimals": 18, "fdv_usd": 1576883, "holders": 3037, "launchpad": "bankr", "launchpad_name": "Bankr", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/EARNONHOOD", "website": "https://earnonhood.com/" }, "liquidity_usd": 239144, "logo": "https://api.crius.sh/v1/robinhood/logo/0xa3b6aee90017b72c0812dc1e013de70eb2917ba3.png?size=128", "market_cap_usd": 1553068, "name": "EARN", "price_eth": 0.0000000066945, "price_usd": 0.0000157688, "progress_pct": null, "quote": "SPY", "sell_volume_usd": { "1h": 968.558, "24h": 51263.3, "5m": 341.572, "6h": 17608.7 }, "sellers": { "1h": 8, "24h": 231, "5m": 1, "6h": 97 }, "sells": { "1h": 21, "24h": 1046, "5m": 1, "6h": 410 }, "status": "launched", "symbol": "EARN", "traders": { "1h": 12, "24h": 288, "5m": 2, "6h": 127 }, "txns": { "1h": 15, "24h": 848, "5m": 1, "6h": 337 }, "volume_usd": { "1h": 1829.93, "24h": 119661, "5m": 342.183, "6h": 41575.3 } } ], "meta": { "block": 100409930, "block_age_ms": 1105, "block_ts": 1793225398000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 4, "list": "top_volume", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - musebook (`0x91a2dae9699f0b82540b5886b0d8759c22820ba3`) leads with $162,228 of volume, 19,013 holders and a $1.32 million market cap, quoted in META (a stock token). It is itself a Bankr launch that other Bankr tokens can use as their quote. - Chop (`0x100765a16f42636bd84ee1e86bc5107b84bcdba3`) trades against WETH, EARN (`0xa3b6aee90017b72c0812dc1e013de70eb2917ba3`) against SPY; EARN is up 55.87% in 24 hours. - All three addresses end in `ba3`, have `status: "launched"` and `progress_pct: null`: no curve, nothing to measure. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20most%20traded%20Bankr%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fbankr%2F%23bankr-top%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dtop_volume%26launchpad%3Dbankr%26window%3D24h%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) `/token/{address}/launch` (Free plan) returns a Bankr token’s factory, creator, quote token, launch transaction and block, `status` and its pools (the v4 pool with the DopplerHookInitializer hook). For the hook’s risk record, see [Check a Uniswap v4 hook’s risk](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). ## Use it in your app 1. **Rank by volume, not newness.** With about 20 launches a day and most trading in established tokens, `list=top_volume&launchpad=bankr` or `list=trending&launchpad=bankr` is the useful feed. 2. **Skip the curve UI.** Bankr tokens have no `progress_pct`; show market cap, liquidity and holders instead. 3. **Price stock-paired tokens in USD.** Many Bankr tokens quote in NVDA, SPY or META. `price_usd` already converts through the stock token’s own pools; `quote` tells you the pair. 4. **Mind the first seconds.** The anti-snipe fee starts at 80%. A bot buying in the launch block pays most of its order in fees; `/security` shows the measured tax once trades exist. ```js // Bankr tokens by 24h volume, with their quote asset. const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=bankr&window=24h&limit=20"); const { data } = await res.json(); for (const t of data) { console.log(`${t.symbol.padEnd(10)} ${t.address} vs ${t.quote}: $${Math.round(t.volume_usd["24h"])} 24h, ${t.holders} holders, mcap $${Math.round(t.market_cap_usd ?? 0)}`); } ``` ## Frequently asked questions **How do I list Bankr tokens on Robinhood Chain?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=bankr&window=24h` for the most traded, or `list=new&launchpad=bankr` for the latest launches. Every row has `launchpad: "bankr"` and `status: "launched"`. **Do Bankr tokens graduate?** No. A Bankr token trades on its Uniswap v4 pool from the first block. Its liquidity is locked for good and its migrator is a no-op contract that always reverts, so `graduated` is 0 and `median_blocks_to_graduate` is `null` in the launchpad stats. **How does Crius know a token is a real Bankr launch?** Bankr launches through the Doppler Airlock, which other integrators share. Crius counts a token as Bankr when the Airlock records Bankr's integrator address (`0xf60633d02690e2a15a54ab919925f3d038df163e`) for it and the token address ends in `ba3`, the vanity suffix Bankr mines. Tokens that pass the integrator address without the suffix are copies and aren't attributed. **What fees do Bankr tokens charge?** In the standard setup, a 0.7% pool fee (95% to the creator) plus a hook fee, about 1.75% per trade in total. Right after launch the hook fee starts at 80% and falls to its normal level over about 14 seconds, which makes sniping the first block expensive. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Launchpad **Long.xyz** How Long.xyz launches tokens on Robinhood Chain through Doppler on Uniswap v4, its launcher and factory addresses, and how to list its tokens with Crius. Read](https://docs.crius.sh/launchpads/long/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Flap.sh on Robinhood Chain (contracts, graduation and API) > How Flap.sh launches tax and non-tax tokens on Robinhood Chain, graduates them to Uniswap v2 with burned LP, its contract addresses and the Crius API. Source: https://docs.crius.sh/launchpads/flap/ · Updated 2026-10-28 Short answer Flap.sh tokens trade on a bonding curve kept inside the Flap Portal (`0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09`) and graduate into a Uniswap v2 pair with the LP burned. List them with `GET /v1/robinhood/tokens?launchpad=flap` (`list=new`, `bonding`, `graduated`), get stats with `GET /v1/robinhood/launchpads/flap`, and one token's lifecycle and pools with `/token/{address}/launch`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Flap.sh](https://flap.sh) is a bonding-curve launchpad with a twist: tokens can carry a buy and sell **tax** from launch, routed to the creator, a vault or dividends for holders. Every Flap token’s curve lives inside one contract, the Flap Portal, which also emits every launch, trade and graduation. When a curve fills, the Portal moves the token into a **Uniswap v2** pair and burns the LP tokens, so that liquidity can never be withdrawn. ## Flap.sh at a glance | | Flap.sh | | --- | --- | | Crius launchpad id | `flap` | | Launch | Through the Flap Portal (or the VaultPortal for tax tokens bound to a vault); no per-token curve contract | | Token types | Tax tokens (address ends in `7777`) and non-tax tokens (address ends in `8888`) | | Quote assets | Mostly native ETH; USDG and stock tokens (SPY, NVDA, TSLA and others) are enabled | | Graduation | At 800 million tokens circulating (5 ETH raised on the default ETH curve) | | After graduation | Uniswap v2 pair (a few on a Pancake-style fork) with 200 million tokens; LP tokens burned to `0x000000000000000000000000000000000000dEaD` | | Fees | 1% on curve buys and sells, plus the token's own tax for tax tokens | | Graduation rate | 0.087% (`graduation_rate_pct: 0.0872573`), median 8,533 blocks to graduate (about 14 minutes) | ## How a Flap token launches and graduates 1. **Launch.** A creator (or a smart account, or one of the batch “launch farm” contracts that mass-create tokens) calls the Portal, which deploys the token as a clone of the tax or non-tax template and sets its curve, quote asset and tax rates. Crius picks it up from the Portal’s `TokenCreated` event; the quote comes from `TokenQuoteSet`. 2. **Bonding.** Buys and sells go through the Portal (`TokenBought`, `TokenSold`). Each trade pays a 1% fee to Flap’s fee Safe; tax tokens also pay their tax on the curve. Fresh Flap tokens show `status: "bonding"` and often `progress_pct: null` in Crius lists until progress can be measured. 3. **Graduation.** The buy that takes circulating supply to 800 million triggers `LaunchedToDEX`: 200 million tokens and the raised quote (5 ETH on the default curve, added as WETH) go into a Uniswap v2 pair, and the LP tokens are sent to the dead address. 4. **After graduation.** The token trades on its v2 pair. A tax token keeps charging its tax on DEX trades, so check `/security` for the measured `tax.buy_pct` and `tax.sell_pct`. ## Flap.sh contracts on Robinhood Chain | Contract | Address | What it does | | --- | --- | --- | | Flap Portal | `0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09` | Launches tokens, holds every curve, emits all launch, trade and graduation events (upgradeable proxy) | | Portal implementation | `0xf9209bdb1e04aca3104d5c6eed12a034451bbd99` | Current Portal logic (v5.23.1, verified) | | VaultPortal | `0xe9f7ab7de8fb8756acbb6a1cd13316a43308197b` | Launch path for tax tokens bound to a vault, such as stock-basket vaults | | Proxy admin | `0x21f7f9b33dfd0dbc3a94c0efa79f1546a1391ff5` | Admin of the Portal and VaultPortal proxies | | Tax token template | `0x7777c8743c88b3aff3cf262135bef2c8b2e83333` | FlapTaxTokenV3: every tax token is a clone, address ending in `7777` | | Non-tax token template | `0x88882688a067fe97e11c2185b996286e53132222` | FlapNonTaxToken: clones end in `8888` | | Tax token helper | `0xb10bd2672ae63735d677164a54b573a016f0203c` | Helper for tax tokens (upgradeable proxy) | | Fee receiver | `0xa4a727e0918cf9b39639fc4cb7d742d39c5352a4` | Safe that receives the 1% curve fee in ETH | | Stocks vault factory | `0xe6ca297d1d963b6f00d5b216986123caeb883af6` | Creates the stock-basket vaults most vault tokens use | | Uniswap v2 factory | `0x8bceaa40b9acdfaedf85adf4ff01f5ad6517937f` | Where almost all Flap tokens graduate | | DemoPancakeFactory | `0x02a84c1b3bbd7401a5f7fa98a384ebc70bb5749e` | Pancake-style v2 fork used by a few graduations | | Mirror pair factory | `0x0d1ebb179cdbca88d74c923c4255cb2b17474afd` | Display-only pairs that mirror curve trades without moving tokens; not indexed by Crius | Six vanity batch contracts mass-create Flap tokens, so a token’s creator can be one of them rather than a person: `0x8f96447d5d15571bc18705b2f1f09aec1b376666`, `0x5bbb332a7ea0bbc98424304326c3dce71d8b6666`, `0x8bf8eace53982a349195c452d1a22d025fae6666`, `0xb3023412cf5fe15811a158234e3fd70a7d6b6666`, `0x948ed9814055e4b74c3885f2de1599600b206666` and `0xcfc61f923c726a5f20dc56d8a925d31bf3e56666`. ## Query Flap.sh with Crius Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Flap.sh stats: 1,200 launches a day, one graduation How active is Flap.sh on Robinhood Chain, and which Flap tokens trade the most? GET/v1/robinhood/launchpads/flap?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/flap?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/flap?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/flap?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 347 lines (arrays trimmed)** ```json { "data": { "contracts": { "launch_contracts": [ "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" ] }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 10145.2, "graduated": 0, "launches": 1170, "traders": 2943, "trades": 6282, "volume_usd": 401018 }, { "date": "2026-10-27", "fees_usd": 11000.8, "graduated": 0, "launches": 1241, "traders": 2962, "trades": 6695, "volume_usd": 378046 }, { "date": "2026-10-28", "fees_usd": 9027.99, "graduated": 1, "launches": 1078, "traders": 3155, "trades": 7632, "volume_usd": 370745 } ] }, "id": "flap", "name": "Flap.sh", "since_block": 4227932, "stats": { "fees_usd_24h": { "lp": 2021.73, "tax": 7407.3, "total": 9429.03 }, "graduated": 338, "graduated_24h": 1, "graduation_rate_pct": 0.0872573, "launches_24h": 1200, "median_blocks_to_graduate": 8533, "tokens_launched": 387360, "traders_24h": 3284, "trades_24h": 7963, "volume_by_quote_usd_24h": { "eth": 367578, "other": 16.2147, "stock": 5051.86, "usdg": 11553.7 }, "volume_usd_24h": 384200 }, "top_tokens_24h": [ { "address": "0xf62bd0bb50ef92ff591c8ff39252f40ad5097777", "buy_volume_usd": { "1h": 0, "24h": 84170.9, "5m": 0, "6h": 286.905 }, "buyers": { "1h": 0, "24h": 99, "5m": 0, "6h": 11 }, "buys": { "1h": 0, "24h": 644, "5m": 0, "6h": 44 }, "change_pct": { "1h": 0.889599, "24h": -0.48219, "5m": 0.889599, "6h": -6.32022 }, "created_block": 73279901, "created_ts": 1790445510120, "decimals": 18, "fdv_usd": 2254393, "holders": 4822, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": "https://docs.flap.sh/flap", "telegram": "https://t.me/FabricAi8", "twitter": "https://x.com/Fabric_AI_", "website": null }, "liquidity_usd": 148756, "logo": "https://api.crius.sh/v1/robinhood/logo/0xf62bd0bb50ef92ff591c8ff39252f40ad5097777.png?size=128", "market_cap_usd": 2254393, "name": "FabricAI", "price_eth": 0.00000095708, "price_usd": 0.00225439, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 0, "24h": 84082.3, "5m": 0, "6h": 3028.13 }, "sellers": { "1h": 0, "24h": 71, "5m": 0, "6h": 12 }, "sells": { "1h": 0, "24h": 781, "5m": 0, "6h": 46 }, "status": "graduated", "symbol": "FA", "traders": { "1h": 0, "24h": 150, "5m": 0, "6h": 13 }, "txns": { "1h": 0, "24h": 1420, "5m": 0, "6h": 90 }, "volume_usd": { "1h": 0, "24h": 168253, "5m": 0, "6h": 3315.03 } }, { "address": "0x20024e485c0b22b42855589700721b28320a7777", "buy_volume_usd": { "1h": 2286.43, "24h": 52276.3, "5m": 0, "6h": 24617.1 }, "buyers": { "1h": 12, "24h": 184, "5m": 0, "6h": 86 }, "buys": { "1h": 19, "24h": 352, "5m": 0, "6h": 143 }, "change_pct": { "1h": 4.3405, "24h": 9.9927, "5m": 0.298221, "6h": 7.90337 }, "created_block": 27174072, "created_ts": 1785801361200, "decimals": 18, "fdv_usd": 1504039, "holders": 7803, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/PRISM_Asset", "twitter": "https://x.com/prismassets", "website": "https://prismassets.shop/" }, "liquidity_usd": 296432, "logo": "https://api.crius.sh/v1/robinhood/logo/0x20024e485c0b22b42855589700721b28320a7777.png?size=128", "market_cap_usd": 1496248, "name": "Prism Assets", "price_eth": 0.000000638524, "price_usd": 0.00150404, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 524.389, "24h": 40210.9, "5m": 0, "6h": 18450.7 }, "sellers": { "1h": 16, "24h": 317, "5m": 0, "6h": 182 }, "sells": { "1h": 20, "24h": 470, "5m": 0, "6h": 240 }, "status": "graduated", "symbol": "PRISM", "traders": { "1h": 27, "24h": 433, "5m": 0, "6h": 239 }, "txns": { "1h": 33, "24h": 644, "5m": 0, "6h": 317 }, "volume_usd": { "1h": 2810.82, "24h": 92487.1, "5m": 0, "6h": 43067.9 } }, { "address": "0xeb4641bc510277848984ef9539d54ba05ebd7777", "buy_volume_usd": { "1h": 31659, "24h": 31659, "5m": 396.003, "6h": 31659 }, "buyers": { "1h": 281, "24h": 281, "5m": 24, "6h": 281 }, "buys": { "1h": 388, "24h": 388, "5m": 24, "6h": 388 }, "change_pct": { "1h": 24.0563, "24h": 24.0563, "5m": -3.15166, "6h": 24.0563 }, "created_block": 100389612, "created_ts": 1793223305200, "decimals": 18, "fdv_usd": 72151.6, "holders": 171, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/Vellum_X", "website": "https://www.vellumrh.xyz/" }, "liquidity_usd": 26149.1, "logo": "https://api.crius.sh/v1/robinhood/logo/0xeb4641bc510277848984ef9539d54ba05ebd7777.png?size=128", "market_cap_usd": 72151.6, "name": "Vellum", "price_eth": 0.0000000306312, "price_usd": 0.0000721516, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 17782.2, "24h": 17782.2, "5m": 610.386, "6h": 17782.2 }, "sellers": { "1h": 161, "24h": 161, "5m": 31, "6h": 161 }, "sells": { "1h": 253, "24h": 253, "5m": 35, "6h": 253 }, "status": "graduated", "symbol": "VELLUM", "traders": { "1h": 283, "24h": 283, "5m": 46, "6h": 283 }, "txns": { "1h": 625, "24h": 625, "5m": 58, "6h": 625 }, "volume_usd": { "1h": 49441.2, "24h": 49441.2, "5m": 1006.39, "6h": 49441.2 } } ], "type": "config_driven", "website": "https://flap.sh" }, "meta": { "block": 100410828, "block_age_ms": 477, "block_ts": 1793225489000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 188, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `tokens_launched: 387360`, `graduated: 338`. In 24 hours: `launches_24h: 1200`, `graduated_24h: 1`, 7,963 trades by 3,284 traders and $384,200 of volume, $367,578 of it against ETH. - `fees_usd_24h`: $7,407.3 of measured taxes against $2,021.73 of LP fees. On Flap the tax tokens, not the pools, generate most of the fees. - `history.points`: 1,170, 1,241 and 1,078 launches on 2026-10-26, 27 and 28, with 0, 0 and 1 graduations. - `top_tokens_24h`: FabricAI (`0xf62bd0bb50ef92ff591c8ff39252f40ad5097777`, $168,253 of volume, 4,822 holders), Prism Assets (`0x20024e485c0b22b42855589700721b28320a7777`, 7,803 holders) and Vellum (`0xeb4641bc510277848984ef9539d54ba05ebd7777`), all graduated, all quoted in WETH and all ending in `7777`: tax tokens. - `contracts.launch_contracts` lists the Portal; `since_block: 4227932` is the first Flap launch. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Flap.sh%20stats%3A%201%2C200%20launches%20a%20day%2C%20one%20graduation&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fflap%2F%23flap-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fflap%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The newest Flap.sh tokens Which Flap.sh tokens were just launched? GET/v1/robinhood/tokens?list=new&launchpad=flap&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=flap&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=flap&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=flap&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x294839975724eb79b21f96e900d5a66cf9077777", "buy_volume_usd": { "1h": 0.000572389, "24h": 0.000572389, "5m": 0.000572389, "6h": 0.000572389 }, "buyers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "buys": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "change_pct": { "1h": -9.99999, "24h": -9.99999, "5m": -9.99999, "6h": -9.99999 }, "created_block": 100409279, "created_ts": 1793225332900, "decimals": 18, "fdv_usd": 4083.1, "holders": 2, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/Clowntrenches/status/2115566171936186372", "website": "https://dex.coinmarketcap.com/token/robinhood/0x294839975724eb79B21F96e900d5a66CF9077777" }, "liquidity_usd": 0.0010303, "logo": "https://api.crius.sh/v1/robinhood/logo/0x294839975724eb79b21f96e900d5a66cf9077777.png?size=128", "market_cap_usd": 4083.1, "name": "Shortinu", "price_eth": 0.00000000173344, "price_usd": 0.0000040831, "progress_pct": null, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "SHORTINU", "traders": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "txns": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "volume_usd": { "1h": 0.000572389, "24h": 0.000572389, "5m": 0.000572389, "6h": 0.000572389 } }, { "address": "0xbf2da78c89c4f51f108aa73d8d7a7ea8cd5e7777", "buy_volume_usd": { "1h": 0.000499407, "24h": 0.000499407, "5m": 0.000499407, "6h": 0.000499407 }, "buyers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "buys": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "change_pct": { "1h": -9.99999, "24h": -9.99999, "5m": -9.99999, "6h": -9.99999 }, "created_block": 100409188, "created_ts": 1793225323800, "decimals": 18, "fdv_usd": 4083.1, "holders": 2, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": "https://dex.coinmarketcap.com/token/robinhood/0xbf2Da78C89c4F51f108aA73D8D7a7Ea8cd5e7777" }, "liquidity_usd": 0.000898932, "logo": "https://api.crius.sh/v1/robinhood/logo/0xbf2da78c89c4f51f108aa73d8d7a7ea8cd5e7777.png?size=128", "market_cap_usd": 4083.1, "name": "United Dividend Trust Fund UDTF", "price_eth": 0.00000000173344, "price_usd": 0.0000040831, "progress_pct": null, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "UDFT", "traders": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "txns": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "volume_usd": { "1h": 0.000499407, "24h": 0.000499407, "5m": 0.000499407, "6h": 0.000499407 } }, { "address": "0x60f5b9533d0382bcbb7112d078c9c38bff1a8888", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 100408594, "created_ts": 1793225265400, "decimals": 18, "fdv_usd": null, "holders": 1, "launchpad": "flap", "launchpad_name": "Flap.sh", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/pumpstartio/status/2115566079661814213?a=PvQcqggPw9F8HIStrE8&s=20", "website": null }, "liquidity_usd": 0, "logo": "https://api.crius.sh/v1/robinhood/logo/0x60f5b9533d0382bcbb7112d078c9c38bff1a8888.png?size=128", "market_cap_usd": null, "name": "we are all cooked", "price_eth": null, "price_usd": null, "progress_pct": null, "quote": null, "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "NEW PROX LAUNCH", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } } ], "meta": { "block": 100409896, "block_age_ms": 751, "block_ts": 1793225395000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 161, "list": "new", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Shortinu (`0x294839975724eb79b21f96e900d5a66cf9077777`) and United Dividend Trust Fund (`0xbf2da78c89c4f51f108aa73d8d7a7ea8cd5e7777`) are tax tokens (`7777`). Each has one buy of a fraction of a cent and `market_cap_usd: 4083.1`: the price at the bottom of the default ETH curve. - “we are all cooked” (`0x60f5b9533d0382bcbb7112d078c9c38bff1a8888`) is a non-tax token (`8888`) with no trades yet: `price_usd: null`, `holders: 1`. - All three have `status: "bonding"` and `progress_pct: null`. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20newest%20Flap.sh%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fflap%2F%23flap-new%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26launchpad%3Dflap%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) For one token, `/token/{address}/launch` (Free plan) returns the launchpad, factory, creator, quote token, launch transaction and block, `status`, `graduated_block` and the token’s pools. The measured buy and sell tax of a tax token is in the anonymous [`/security`](https://docs.crius.sh/guides/check-token-taxes/) call. ## Use it in your app 1. **Filter the firehose.** `list=new&launchpad=flap&min_liquidity_usd=500` drops the hundreds of daily launches that never get a buyer. 2. **Check the tax before you buy.** A `7777` address means a tax token. `/security` returns the tax buyers actually paid (`tax.source: "realized"`) and whether the owner can change it. 3. **Expect slow graduations.** The median Flap graduation took 8,533 blocks, and fewer than 1 in 1,000 tokens get there. `list=graduated&launchpad=flap` shows the ones that did. 4. **Ignore the mirror pairs.** If you also read chain data yourself, leave pairs from `0x0d1ebb179cdbca88d74c923c4255cb2b17474afd` out of volume and liquidity; Crius already does. ```python # New Flap.sh tokens with some liquidity, flagged by token type. import requests rows = requests.get( "https://api.crius.sh/v1/robinhood/tokens", params={"list": "new", "launchpad": "flap", "min_liquidity_usd": 500, "limit": 50}, timeout=10, ).json()["data"] for t in rows: kind = "tax" if t["address"].endswith("7777") else "non-tax" if t["address"].endswith("8888") else "?" print(f"{t['symbol']:<12} {kind:<8} {t['address']} liq ${t['liquidity_usd']:,.0f} holders {t['holders']} quote {t['quote']}") ``` ## Frequently asked questions **How do I track new Flap.sh tokens on Robinhood Chain?** Poll `GET https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=flap`, or subscribe to `launches:flap` on the [WebSocket stream](https://docs.crius.sh/reference/stream/). About 1,200 Flap tokens launch a day, so add `min_liquidity_usd` to skip the ones nobody buys. **What is the Flap.sh contract address on Robinhood Chain?** Every Flap launch, trade and graduation goes through the Flap Portal, `0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09`. Tax tokens are clones of `0x7777c8743c88b3aff3cf262135bef2c8b2e83333` (addresses ending in `7777`), non-tax tokens clones of `0x88882688a067fe97e11c2185b996286e53132222` (ending in `8888`). **When does a Flap.sh token graduate?** When its curve sells through to 800 million tokens in circulation. On the default ETH curve that is 5 ETH raised; the Portal then adds 200 million tokens and the raised quote to a Uniswap v2 pair and burns the LP tokens. Only 338 of 387,360 Flap tokens had graduated when the samples were captured. **Why do Flap.sh tokens show up twice on some chart sites?** Flap creates a display-only Uniswap v2-style pair for each token on `0x0d1ebb179cdbca88d74c923c4255cb2b17474afd`. Those pairs repeat every curve trade as a swap but move no tokens. Crius doesn't index them, so Flap volume and liquidity on Crius are counted once. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Launchpad **Pons** Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Read](https://docs.crius.sh/launchpads/pons/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Flywheel on Robinhood Chain (4% hook launches, contracts and API) > How Flywheel launches tokens into Uniswap v4 pools with a 4% hook tax on Robinhood Chain, how graduation works, its contracts and the Crius API calls. Source: https://docs.crius.sh/launchpads/flywheel/ · Updated 2026-10-28 Short answer Flywheel launches each token straight into a Uniswap v4 pool whose hook (`0x992118de23b4ebe9f527dacbbb7d8d4bbbf8e044`) holds the liquidity and takes 4% of every swap for holder rewards, burns and the platform. A token graduates, without moving, when the hook's liquidity reaches its target. List tokens with `GET /v1/robinhood/tokens?launchpad=flywheel`, stats with `GET /v1/robinhood/launchpads/flywheel`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Flywheel](https://flywheel.cash) launches tokens directly into a **Uniswap v4 pool** whose hook holds the liquidity and charges a **4% tax on every swap**, most of it paid back to holders as rewards. There is no bonding-curve contract and no migration: a token “graduates” when the liquidity its hook holds reaches a target, and keeps trading in the same pool. Crius indexes Flywheel v2, the native v4 deployment. ## Flywheel at a glance | | Flywheel | | --- | --- | | Crius launchpad id | `flywheel` | | Launch | StandardLaunchFactory deploys the token and opens its v4 pool (fee 0, tick spacing 200) with the launch hook; creation fee 0.0005 ETH | | Quote assets | WETH by default; any ERC-20 is allowed (SPY, XMR and other Flywheel tokens in the samples) | | Tax | 4% per swap: 2.95% holder rewards, 0.05% burn, 0.05% locked liquidity, 0.95% platform | | Graduation | `Graduated` event when the hook-owned liquidity reaches its quote target; no migration | | Graduation rate | 1.70% (`graduation_rate_pct: 1.70118`), median 25,108 blocks to graduate (about 42 minutes) | ## How a Flywheel token launches and graduates 1. **Launch.** The creator calls the StandardLaunchFactory, which deploys the token through the StandardTokenDeployer and opens a v4 pool whose hook is the StandardLaunchHook. The factory emits `TokenLaunched` with the token, creator and quote; Crius attributes the token from it. 2. **Trading.** Swaps go through the hook, which holds the pool’s single-sided liquidity and takes 4% of each swap. The StandardFeeRouter splits that tax into holder rewards, a burn, locked liquidity and the platform share; holders and creators claim rewards from the factory. 3. **Graduation.** When the quote principal in the hook’s liquidity reaches the token’s target, the hook emits `Graduated` for the pool. Nothing moves; Crius marks the token `status: "graduated"`, `progress_pct: 100`. The 4% tax applies before and after graduation. A trader buying and selling a Flywheel token pays it twice, so a 5% price move is a loss after tax. ## Flywheel contracts on Robinhood Chain | Contract | Address | What it does | | --- | --- | --- | | StandardLaunchFactory | `0xf05a26e92e27b8f0385f6895f5507db26a2f4b8d` | Launch entry point (`TokenLaunched`), creation fee, holder and creator reward claims | | StandardLaunchHook | `0x992118de23b4ebe9f527dacbbb7d8d4bbbf8e044` | Uniswap v4 hook of every Flywheel pool: holds the liquidity, takes the 4% tax, emits `Graduated` | | StandardFeeRouter | `0x3bb49db5a7ee80c9c132b9f7376058f11b0d9c7b` | Splits the hook tax into rewards, burn, locked liquidity and platform | | StandardTokenDeployer | `0x7b9aedf3257cfebf288009b1be6def2c19f68e58` | Deploys launch tokens for the factory | | NativePlatformDistributor | `0x64c69108052c05844a459e618b168a8d4aeca96f` | Pays out the platform's ETH: 69% to the buyback wallet, 31% to the owner | | Buyback recipient | `0xae6e5d2dbf09451ba4a223e24b720ec13be740c1` | Receives 69% of platform ETH | | Owner | `0xf9b9b1a0b12f8aa50cbaa32628fcc07f7c0c64ab` | Deployed and owns the factory; receives 31% of platform ETH | | Operator | `0x7a4b26e7b0f6d8ae0402349ba52e41433cc3f965` | Maintenance operator of the factory | | Uniswap v4 PoolManager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Holds every Flywheel pool | The factory, hook, fee router, token deployer and platform distributor are verified (Sourcify exact match). ## Query Flywheel with Crius Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Flywheel stats: 1,352 tokens, 23 graduations How active is Flywheel on Robinhood Chain? GET/v1/robinhood/launchpads/flywheel?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/flywheel?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/flywheel?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/flywheel?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 347 lines (arrays trimmed)** ```json { "data": { "contracts": { "launch_contracts": [ "0xf05a26e92e27b8f0385f6895f5507db26a2f4b8d" ] }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 14871.8, "graduated": 1, "launches": 117, "traders": 3274, "trades": 12476, "volume_usd": 853210 }, { "date": "2026-10-27", "fees_usd": 8479.03, "graduated": 2, "launches": 48, "traders": 2217, "trades": 7970, "volume_usd": 482087 }, { "date": "2026-10-28", "fees_usd": 4295.55, "graduated": 0, "launches": 13, "traders": 1654, "trades": 4565, "volume_usd": 227561 } ] }, "id": "flywheel", "name": "Flywheel", "since_block": 87735869, "stats": { "fees_usd_24h": { "lp": 1570.29, "tax": 4671.24, "total": 6241.53 }, "graduated": 23, "graduated_24h": 1, "graduation_rate_pct": 1.70118, "launches_24h": 17, "median_blocks_to_graduate": 25108, "tokens_launched": 1352, "traders_24h": 2005, "trades_24h": 6463, "volume_by_quote_usd_24h": { "eth": 89454.7, "other": 78986.9, "stock": 135070, "usdg": 30064.2 }, "volume_usd_24h": 333576 }, "top_tokens_24h": [ { "address": "0x127cdc74e44e3c60422b7e792ebe480c0f873ed5", "buy_volume_usd": { "1h": 2324.8, "24h": 83523.9, "5m": 46.4567, "6h": 23877 }, "buyers": { "1h": 18, "24h": 590, "5m": 2, "6h": 328 }, "buys": { "1h": 32, "24h": 1495, "5m": 3, "6h": 470 }, "change_pct": { "1h": -4.12534, "24h": 15.4062, "5m": 0.0651763, "6h": 10.4166 }, "created_block": 91295058, "created_ts": 1792277645800, "decimals": 18, "fdv_usd": 2535912, "holders": 3079, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/flywheelcash", "twitter": "https://x.com/BoomerSP500", "website": "https://boomerspy.com" }, "liquidity_usd": 226813, "logo": "https://api.crius.sh/v1/robinhood/logo/0x127cdc74e44e3c60422b7e792ebe480c0f873ed5.png?size=128", "market_cap_usd": 2535911, "name": "Boomer", "price_eth": 0.0000000156932, "price_usd": 0.0000369651, "progress_pct": 100, "quote": "SPY", "sell_volume_usd": { "1h": 5621.48, "24h": 73686, "5m": 38.6907, "6h": 17567.4 }, "sellers": { "1h": 54, "24h": 623, "5m": 3, "6h": 291 }, "sells": { "1h": 67, "24h": 1213, "5m": 6, "6h": 377 }, "status": "graduated", "symbol": "BOOMER", "traders": { "1h": 69, "24h": 915, "5m": 4, "6h": 478 }, "txns": { "1h": 96, "24h": 2617, "5m": 9, "6h": 802 }, "volume_usd": { "1h": 7946.28, "24h": 157210, "5m": 85.1473, "6h": 41444.4 } }, { "address": "0xb321f6822c67f0b673f35d4558ec566b7f9332b9", "buy_volume_usd": { "1h": 862.349, "24h": 32667.1, "5m": 0, "6h": 1623.83 }, "buyers": { "1h": 5, "24h": 521, "5m": 0, "6h": 39 }, "buys": { "1h": 5, "24h": 705, "5m": 0, "6h": 48 }, "change_pct": { "1h": 7.03724, "24h": 190.504, "5m": -0.980598, "6h": -23.6967 }, "created_block": 97818775, "created_ts": 1792955474500, "decimals": 18, "fdv_usd": 36608.2, "holders": 217, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/mooner_flywheel", "website": null }, "liquidity_usd": 15193.6, "logo": "https://api.crius.sh/v1/robinhood/logo/0xb321f6822c67f0b673f35d4558ec566b7f9332b9.png?size=128", "market_cap_usd": 36608.2, "name": "Mooner", "price_eth": 0.000155598, "price_usd": 0.366511, "progress_pct": null, "quote": "BOOMER", "sell_volume_usd": { "1h": 211.089, "24h": 29536, "5m": 0, "6h": 3603.47 }, "sellers": { "1h": 9, "24h": 414, "5m": 0, "6h": 72 }, "sells": { "1h": 9, "24h": 527, "5m": 0, "6h": 81 }, "status": "bonding", "symbol": "MOONER", "traders": { "1h": 14, "24h": 541, "5m": 0, "6h": 95 }, "txns": { "1h": 14, "24h": 1207, "5m": 0, "6h": 128 }, "volume_usd": { "1h": 1073.44, "24h": 62203, "5m": 0, "6h": 5227.3 } }, { "address": "0xc6d0a987c6839d08516bcd27ad89b3bcc8bbaac1", "buy_volume_usd": { "1h": 249.17, "24h": 12010.9, "5m": 0, "6h": 2836.35 }, "buyers": { "1h": 6, "24h": 129, "5m": 0, "6h": 33 }, "buys": { "1h": 10, "24h": 353, "5m": 0, "6h": 65 }, "change_pct": { "1h": -2.44453, "24h": -1.14121, "5m": -0.000834633, "6h": -0.538705 }, "created_block": 97758596, "created_ts": 1792949280600, "decimals": 18, "fdv_usd": 204460, "holders": 538, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/flytittyheaven", "website": null }, "liquidity_usd": 56511.9, "logo": "https://api.crius.sh/v1/robinhood/logo/0xc6d0a987c6839d08516bcd27ad89b3bcc8bbaac1.png?size=128", "market_cap_usd": 204460, "name": "Eternal Titty Heaven", "price_eth": 0.000000000214493, "price_usd": 0.000000505235, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 635.095, "24h": 12232.8, "5m": 0, "6h": 3128.97 }, "sellers": { "1h": 12, "24h": 183, "5m": 0, "6h": 53 }, "sells": { "1h": 16, "24h": 262, "5m": 0, "6h": 73 }, "status": "graduated", "symbol": "ETH", "traders": { "1h": 17, "24h": 261, "5m": 0, "6h": 75 }, "txns": { "1h": 26, "24h": 608, "5m": 0, "6h": 138 }, "volume_usd": { "1h": 884.264, "24h": 24243.7, "5m": 0, "6h": 5965.32 } } ], "type": "config_driven", "website": "https://flywheel.cash" }, "meta": { "block": 100410751, "block_age_ms": 672, "block_ts": 1793225481000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 89, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `tokens_launched: 1352`, `graduated: 23`, `median_blocks_to_graduate: 25108`. In 24 hours: 17 launches, 1 graduation, 6,463 trades by 2,005 traders and $333,576 of volume. - `fees_usd_24h.tax: 4671.24` is 1.4% of the 24-hour volume. The hook takes 4% of each swap; `meta.notes` says taxes a hook takes in the quote currency on sells aren’t measured yet, one reason the measured figure is lower. - `history.points`: 117 launches and $853,210 of volume on 2026-10-26, 48 and $482,087 on 10-27, 13 and $227,561 on 10-28. - `top_tokens_24h`: Boomer (`0x127cdc74e44e3c60422b7e792ebe480c0f873ed5`, quoted in SPY, $157,210, 3,079 holders), Mooner (`0xb321f6822c67f0b673f35d4558ec566b7f9332b9`), which is quoted in BOOMER, another Flywheel token, and still `status: "bonding"`, and “Eternal Titty Heaven” (`0xc6d0a987c6839d08516bcd27ad89b3bcc8bbaac1`), whose symbol is `ETH`. It isn’t ether: always go by address. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Flywheel%20stats%3A%201%2C352%20tokens%2C%2023%20graduations&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fflywheel%2F%23flywheel-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fflywheel%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Graduated Flywheel tokens Which Flywheel tokens have graduated? GET/v1/robinhood/tokens?list=graduated&launchpad=flywheel&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=flywheel&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=flywheel&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=flywheel&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x127cdc74e44e3c60422b7e792ebe480c0f873ed5", "buy_volume_usd": { "1h": 2348.85, "24h": 83549.4, "5m": 1.14628, "6h": 23831.7 }, "buyers": { "1h": 21, "24h": 589, "5m": 1, "6h": 327 }, "buys": { "1h": 34, "24h": 1494, "5m": 1, "6h": 468 }, "change_pct": { "1h": -4.24605, "24h": 15.4183, "5m": -0.0221787, "6h": 10.3202 }, "created_block": 91295058, "created_ts": 1792277645800, "decimals": 18, "fdv_usd": 2533698, "holders": 3080, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/flywheelcash", "twitter": "https://x.com/BoomerSP500", "website": "https://boomerspy.com" }, "liquidity_usd": 226730, "logo": "https://api.crius.sh/v1/robinhood/logo/0x127cdc74e44e3c60422b7e792ebe480c0f873ed5.png?size=128", "market_cap_usd": 2533698, "name": "Boomer", "price_eth": 0.0000000156795, "price_usd": 0.0000369328, "progress_pct": 100, "quote": "SPY", "sell_volume_usd": { "1h": 5730.46, "24h": 73682.2, "5m": 34.807, "6h": 17563.5 }, "sellers": { "1h": 59, "24h": 622, "5m": 2, "6h": 291 }, "sells": { "1h": 71, "24h": 1211, "5m": 4, "6h": 376 }, "status": "graduated", "symbol": "BOOMER", "traders": { "1h": 74, "24h": 914, "5m": 2, "6h": 478 }, "txns": { "1h": 99, "24h": 2614, "5m": 5, "6h": 799 }, "volume_usd": { "1h": 8079.31, "24h": 157232, "5m": 35.9533, "6h": 41395.2 } }, { "address": "0x5a5b3bd134f84e6ba9c40e0612428cda6cc9425f", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 98865705, "created_ts": 1793064557500, "decimals": 18, "fdv_usd": 2.9113, "holders": 4, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 0.488609, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5a5b3bd134f84e6ba9c40e0612428cda6cc9425f.png?size=128", "market_cap_usd": 2.9113, "name": "SSRF Probe", "price_eth": 0.0000000000000123596, "price_usd": 0.000000000029113, "progress_pct": 100, "quote": "WETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "graduated", "symbol": "SSRF", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } }, { "address": "0x735a245470fdfacb5d14e90674bdd826096da636", "buy_volume_usd": { "1h": 0, "24h": 197.443, "5m": 0, "6h": 13.6755 }, "buyers": { "1h": 0, "24h": 12, "5m": 0, "6h": 2 }, "buys": { "1h": 0, "24h": 18, "5m": 0, "6h": 3 }, "change_pct": { "1h": -1.07182, "24h": -13.3174, "5m": -1.07182, "6h": 0.317721 }, "created_block": 98084327, "created_ts": 1792983154240, "decimals": 18, "fdv_usd": 6167.45, "holders": 181, "launchpad": "flywheel", "launchpad_name": "Flywheel", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/FlyLynxCash", "website": "https://lynxmr.world/" }, "liquidity_usd": 1055.14, "logo": "https://api.crius.sh/v1/robinhood/logo/0x735a245470fdfacb5d14e90674bdd826096da636.png?size=128", "market_cap_usd": 6167.45, "name": "Lynx", "price_eth": 0.000000000000262133, "price_usd": 0.000000000617453, "progress_pct": 100, "quote": "XMR", "sell_volume_usd": { "1h": 0, "24h": 600.902, "5m": 0, "6h": 24.6128 }, "sellers": { "1h": 0, "24h": 17, "5m": 0, "6h": 2 }, "sells": { "1h": 0, "24h": 22, "5m": 0, "6h": 2 }, "status": "graduated", "symbol": "LYNX", "traders": { "1h": 0, "24h": 21, "5m": 0, "6h": 3 }, "txns": { "1h": 0, "24h": 36, "5m": 0, "6h": 5 }, "volume_usd": { "1h": 0, "24h": 798.345, "5m": 0, "6h": 38.2883 } } ], "meta": { "block": 100409988, "block_age_ms": 911, "block_ts": 1793225404000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 70, "list": "graduated", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Boomer (`0x127cdc74e44e3c60422b7e792ebe480c0f873ed5`) has a $2.53 million market cap, $226,730 of liquidity and 3,080 holders. - SSRF Probe (`0x5a5b3bd134f84e6ba9c40e0612428cda6cc9425f`) is also `status: "graduated"` but has a $2.91 market cap, $0.49 of liquidity and 4 holders. Graduation only means the hook’s target was reached; check liquidity and holders before treating it as a milestone. - Lynx (`0x735a245470fdfacb5d14e90674bdd826096da636`) is quoted in XMR, with 181 holders and $1,055.14 of liquidity. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Graduated%20Flywheel%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fflywheel%2F%23flywheel-graduated%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduated%26launchpad%3Dflywheel%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) `/token/{address}/launch` (Free plan) returns a Flywheel token’s factory, creator, quote token, launch transaction and block, `status`, `graduated_block` and its pool with the hook address. The measured buy and sell tax is in the anonymous [`/security`](https://docs.crius.sh/guides/check-token-taxes/) call. ## Use it in your app 1. **Show the 4% tax.** Every Flywheel buy and sell pays it; a trading UI should include it in the quoted price and a bot in its profit target. 2. **Track progress by status.** `list=bonding&launchpad=flywheel` for tokens still filling their target, `list=graduated&launchpad=flywheel` for those that reached it. 3. **Check the quote.** Flywheel tokens can be quoted in other Flywheel tokens (Mooner in BOOMER); the quote’s own price moves the token’s USD price. 4. **Go by address, not symbol.** Symbols such as `ETH` are taken by unrelated tokens. ```js // Flywheel tokens still filling their target, by 24h volume. const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=bonding&launchpad=flywheel&limit=100"); const { data } = await res.json(); data .sort((a, b) => b.volume_usd["24h"] - a.volume_usd["24h"]) .slice(0, 10) .forEach((t) => console.log(`${t.symbol} ${t.address} vs ${t.quote}: $${Math.round(t.volume_usd["24h"])} 24h, liq $${Math.round(t.liquidity_usd)}`)); ``` ## Frequently asked questions **How do I list Flywheel tokens on Robinhood Chain?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=flywheel` for new launches, `list=bonding&launchpad=flywheel` for tokens that haven't graduated and `list=graduated&launchpad=flywheel` for the ones that have. **What is the Flywheel tax?** 4% of every swap, taken by the Flywheel launch hook: 2.95% to holder rewards, 0.05% burned, 0.05% to locked liquidity and 0.95% to the platform. The platform's ETH share is split 69% to a buyback wallet and 31% to Flywheel's owner. `/security` shows the tax buyers actually paid. **What does graduation mean on Flywheel?** There is no separate curve and no migration. The hook holds each token's liquidity from launch; when the quote it holds reaches the token's target, the hook emits `Graduated` for the pool and Crius sets `status: "graduated"`. Trading continues in the same pool. **Which Flywheel contracts does Crius index?** The StandardLaunchFactory `0xf05a26e92e27b8f0385f6895f5507db26a2f4b8d` (launches) and the StandardLaunchHook `0x992118de23b4ebe9f527dacbbb7d8d4bbbf8e044` (swaps, tax, graduation) of Flywheel v2. Tokens from Flywheel's older v1 deployment aren't attributed yet. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Long.xyz on Robinhood Chain (Doppler launches, contracts and API) > How Long.xyz launches tokens on Robinhood Chain through Doppler on Uniswap v4, its launcher and factory addresses, and how to list its tokens with Crius. Source: https://docs.crius.sh/launchpads/long/ · Updated 2026-10-28 Short answer Long.xyz launches tokens through its launcher contracts and the shared Doppler Airlock straight onto Uniswap v4, so its tokens trade on a v4 pool for life (`status: "launched"`, no bonding curve). List them with `GET /v1/robinhood/tokens?launchpad=long`, get stats with `GET /v1/robinhood/launchpads/long`, and one token's launch and pools with `/token/{address}/launch`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [Long.xyz](https://long.xyz) is a token launch platform whose tokens go straight onto **Uniswap v4** through **Doppler**, the same shared launch protocol Bankr uses. There is no bonding curve and no graduation: a Long token’s v4 pool is its market from the first block. Of the launchpads Crius attributes, Long is second only to Pons by volume, and its tokens are paired with almost anything: ETH, USDG, tokenized stocks and other tokens, including PONS. ## Long.xyz at a glance | | Long.xyz | | --- | --- | | Crius launchpad id | `long` | | Launch | LongLaunchFactory (or the earlier LongLauncher) launches through the Doppler Airlock and emits `LaunchCreated` | | Market | Uniswap v4 pool from the first block | | Quote assets | ETH, USDG, stock tokens (HIMS, AMC, MSFT, META in the samples) and other tokens (PONS) | | Graduation | None so far: Crius watches the Airlock's `Migrate` event and no Long token has migrated | | Metadata | Token metadata and logos on IPFS | | Activity (24h) | 505 launches, 68,017 trades, $10,785,197 of volume | ## How a Long token launches 1. **Launch.** Long’s factory calls the Doppler Airlock, which deploys the token and initializes its Uniswap v4 pool, and the factory emits `LaunchCreated` with the token (`asset`), the quote (`numeraire`), the pool or hook, the launcher and a normalized ticker. Crius attributes the token from that event. 2. **Trading.** From the first block, buys and sells are ordinary v4 swaps, which Crius indexes like any other pool. List rows show `status: "launched"` and `progress_pct: null`. 3. **No migration.** Doppler supports migrating a pool to a new market, and Crius listens for the Airlock’s `Migrate` event as Long’s graduation, but none has happened for a Long token. In practice a Long token keeps its v4 pool for life. Because Long and Bankr share the Doppler Airlock, Crius attributes Long tokens from Long’s own `LaunchCreated` events, not from the Airlock alone. Every Long token in the samples on this page has an address ending in `1e18`. ## Long.xyz contracts on Robinhood Chain | Contract | Address | What it does | | --- | --- | --- | | LongLaunchFactory | `0x1eef016f22a943abc7dd11422edee9d235942104` | Current launch factory (upgradeable UUPS proxy, verified); emits `LaunchCreated` | | LongLauncher | `0x22e99278308b393ea1260859b181ad7e78f5eeed` | Earlier launcher (verified); same `LaunchCreated` event | | Doppler Airlock | `0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862` | Shared Doppler entry point that deploys the token and pool; would emit `Migrate` on a migration | | Uniswap v4 PoolManager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Holds every Long pool | ## Query Long.xyz with Crius Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Long.xyz stats: $10.8 million a day, no graduations How active is Long.xyz on Robinhood Chain? GET/v1/robinhood/launchpads/long?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/long?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/long?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/long?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 348 lines (arrays trimmed)** ```json { "data": { "contracts": { "launch_contracts": [ "0x22e99278308b393ea1260859b181ad7e78f5eeed", "0x1eef016f22a943abc7dd11422edee9d235942104" ] }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 38091.6, "graduated": 0, "launches": 529, "traders": 5854, "trades": 36476, "volume_usd": 4042179 }, { "date": "2026-10-27", "fees_usd": 156189, "graduated": 0, "launches": 482, "traders": 8408, "trades": 66849, "volume_usd": 8077900 }, { "date": "2026-10-28", "fees_usd": 116387, "graduated": 0, "launches": 466, "traders": 8597, "trades": 61931, "volume_usd": 10110323 } ] }, "id": "long", "name": "Long.xyz", "since_block": 8658626, "stats": { "fees_usd_24h": { "lp": 52341.3, "tax": 70592.4, "total": 122934 }, "graduated": 0, "graduated_24h": 0, "graduation_rate_pct": 0, "launches_24h": 505, "median_blocks_to_graduate": null, "tokens_launched": 83664, "traders_24h": 9157, "trades_24h": 68017, "volume_by_quote_usd_24h": { "eth": 2444027, "other": 2760956, "stock": 3328303, "usdg": 2251911 }, "volume_usd_24h": 10785197 }, "top_tokens_24h": [ { "address": "0x2e8c31162b855a2ffa90f6f8634643ad6f111e18", "buy_volume_usd": { "1h": 67905.3, "24h": 3570261, "5m": 590.183, "6h": 2374111 }, "buyers": { "1h": 159, "24h": 2810, "5m": 13, "6h": 1547 }, "buys": { "1h": 374, "24h": 11923, "5m": 22, "6h": 5599 }, "change_pct": { "1h": 1.31674, "24h": 25.1479, "5m": -0.263025, "6h": 20.1767 }, "created_block": 9721433, "created_ts": 1784051310300, "decimals": 18, "fdv_usd": 79666308, "holders": 58018, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/artificiallyinu", "website": "https://artificialinu.com/" }, "liquidity_usd": 4098580, "logo": "https://api.crius.sh/v1/robinhood/logo/0x2e8c31162b855a2ffa90f6f8634643ad6f111e18.png?size=128", "market_cap_usd": 79500880, "name": "Artificial Inu", "price_eth": 0.0000341314, "price_usd": 0.0803963, "progress_pct": null, "quote": "PONS", "sell_volume_usd": { "1h": 47964.4, "24h": 3028027, "5m": 6177.43, "6h": 1847683 }, "sellers": { "1h": 150, "24h": 3055, "5m": 15, "6h": 1669 }, "sells": { "1h": 284, "24h": 12106, "5m": 29, "6h": 5955 }, "status": "launched", "symbol": "AI", "traders": { "1h": 263, "24h": 4136, "5m": 26, "6h": 2301 }, "txns": { "1h": 460, "24h": 14565, "5m": 37, "6h": 6648 }, "volume_usd": { "1h": 115870, "24h": 6598287, "5m": 6767.61, "6h": 4221793 } }, { "address": "0x98096d17e191b3da1d5f99a6d7b3584351b11e18", "buy_volume_usd": { "1h": 9251.27, "24h": 492359, "5m": 127.691, "6h": 243356 }, "buyers": { "1h": 28, "24h": 694, "5m": 2, "6h": 343 }, "buys": { "1h": 62, "24h": 2403, "5m": 4, "6h": 1070 }, "change_pct": { "1h": -2.21643, "24h": 18.1598, "5m": -0.134329, "6h": 7.95163 }, "created_block": 41726520, "created_ts": 1787259586000, "decimals": 18, "fdv_usd": 20608254, "holders": 21209, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/bonercoinlong", "website": "https://boneronlong.xyz/" }, "liquidity_usd": 1427098, "logo": "https://api.crius.sh/v1/robinhood/logo/0x98096d17e191b3da1d5f99a6d7b3584351b11e18.png?size=128", "market_cap_usd": 20608126, "name": "Boner Coin", "price_eth": 0.00000874949, "price_usd": 0.0206094, "progress_pct": null, "quote": "HIMS", "sell_volume_usd": { "1h": 26664.2, "24h": 428391, "5m": 127.421, "6h": 205903 }, "sellers": { "1h": 38, "24h": 814, "5m": 1, "6h": 364 }, "sells": { "1h": 85, "24h": 2249, "5m": 1, "6h": 866 }, "status": "launched", "symbol": "BONER", "traders": { "1h": 57, "24h": 1089, "5m": 3, "6h": 497 }, "txns": { "1h": 79, "24h": 2630, "5m": 2, "6h": 1050 }, "volume_usd": { "1h": 35915.5, "24h": 920750, "5m": 255.112, "6h": 449259 } }, { "address": "0x385f4f8ae47651ce5f58f5265395a669f8281e18", "buy_volume_usd": { "1h": 12413.5, "24h": 441894, "5m": 822.466, "6h": 81470.3 }, "buyers": { "1h": 25, "24h": 1112, "5m": 5, "6h": 226 }, "buys": { "1h": 41, "24h": 4247, "5m": 5, "6h": 701 }, "change_pct": { "1h": 2.07186, "24h": 11.5171, "5m": 0.103801, "6h": 11.6989 }, "created_block": 53697172, "created_ts": 1788467405200, "decimals": 18, "fdv_usd": 8573216, "holders": 29040, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/amemecoinrh", "website": null }, "liquidity_usd": 521018, "logo": "https://api.crius.sh/v1/robinhood/logo/0x385f4f8ae47651ce5f58f5265395a669f8281e18.png?size=128", "market_cap_usd": 8573210, "name": "A Meme Coin", "price_eth": 0.00000363967, "price_usd": 0.00857322, "progress_pct": null, "quote": "AMC", "sell_volume_usd": { "1h": 2622.62, "24h": 399599, "5m": 345.82, "6h": 41142.5 }, "sellers": { "1h": 54, "24h": 1396, "5m": 5, "6h": 307 }, "sells": { "1h": 67, "24h": 4365, "5m": 5, "6h": 650 }, "status": "launched", "symbol": "MEME", "traders": { "1h": 67, "24h": 1767, "5m": 8, "6h": 397 }, "txns": { "1h": 77, "24h": 5174, "5m": 8, "6h": 827 }, "volume_usd": { "1h": 15036.1, "24h": 841493, "5m": 1168.29, "6h": 122613 } } ], "type": "config_driven", "website": "https://long.xyz" }, "meta": { "block": 100410863, "block_age_ms": 991, "block_ts": 1793225492000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 188, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `tokens_launched: 83664`, `graduated: 0`. In 24 hours: 505 launches, 68,017 trades by 9,157 traders, `volume_usd_24h: 10785197`. - `volume_by_quote_usd_24h` is the most evenly split of any launchpad: $3,328,303 against stock tokens, $2,760,956 against other tokens, $2,444,027 against ETH and $2,251,911 against USDG. - `fees_usd_24h`: $52,341.3 of LP fees and $70,592.4 of measured taxes, $122,934 in total. - `history.points`: volume grew from $4,042,179 on 2026-10-26 to $8,077,900 and $10,110,323 on the next two days, with 529, 482 and 466 launches. - `top_tokens_24h`: Artificial Inu (`0x2e8c31162b855a2ffa90f6f8634643ad6f111e18`) with $6,598,287, about 61% of Long’s volume, 58,018 holders and a $79.5 million market cap, quoted in PONS. Then Boner Coin (`0x98096d17e191b3da1d5f99a6d7b3584351b11e18`, HIMS) and A Meme Coin (`0x385f4f8ae47651ce5f58f5265395a669f8281e18`, AMC). [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Long.xyz%20stats%3A%20%2410.8%20million%20a%20day%2C%20no%20graduations&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Flong%2F%23long-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Flong%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### New Long.xyz tokens, before their first trade Which tokens were just launched on Long.xyz? GET/v1/robinhood/tokens?list=new&launchpad=long&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=long&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=long&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=long&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xcc15dd17b92dc81a1580a516b2887d449b671e18", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 100419107, "created_ts": 1793226345700, "decimals": 18, "fdv_usd": 19968.1, "holders": 2, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://twitter.com/wallstengine/status/2115570642729025973", "website": null }, "liquidity_usd": 0, "logo": "https://api.crius.sh/v1/robinhood/logo/0xcc15dd17b92dc81a1580a516b2887d449b671e18.png?size=128", "market_cap_usd": 19968.1, "name": "The Shiny Object", "price_eth": 0.00000000848151, "price_usd": 0.0000199681, "progress_pct": null, "quote": "MSFT", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "launched", "symbol": "OBJECT", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } }, { "address": "0xb110cb51b07fd237519ad1f90bc53170e0d61e18", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 100418467, "created_ts": 1793226279700, "decimals": 18, "fdv_usd": null, "holders": 2, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/catcast_rh", "website": null }, "liquidity_usd": 0, "logo": "https://api.crius.sh/v1/robinhood/logo/0xb110cb51b07fd237519ad1f90bc53170e0d61e18.png?size=128", "market_cap_usd": null, "name": "catcast", "price_eth": null, "price_usd": null, "progress_pct": null, "quote": null, "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "launched", "symbol": "CATCAST", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } }, { "address": "0xa9a57fede9e6c859febd1b1f510d34d1d0d51e18", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 100417037, "created_ts": 1793226135700, "decimals": 18, "fdv_usd": 20029, "holders": 2, "launchpad": "long", "launchpad_name": "Long.xyz", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/agentmuserh", "website": null }, "liquidity_usd": 0, "logo": "https://api.crius.sh/v1/robinhood/logo/0xa9a57fede9e6c859febd1b1f510d34d1d0d51e18.png?size=128", "market_cap_usd": 20029, "name": "Agent Muse", "price_eth": 0.00000000850737, "price_usd": 0.000020029, "progress_pct": null, "quote": "META", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "launched", "symbol": "AGENTMUSE", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } } ], "meta": { "block": 100419456, "block_age_ms": 1108, "block_ts": 1793226380000, "chain": "robinhood", "finalized_block": 100408671, "lag_ms": 38, "list": "new", "next_cursor": "3", "safe_block": 100412483, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - The Shiny Object (`0xcc15dd17b92dc81a1580a516b2887d449b671e18`) was created 35 seconds before the response, quoted in MSFT, with a logo and a link to a post on X. - It shows `market_cap_usd: 19968.1` but `liquidity_usd: 0` and no trades: the pool has a starting price but no quote currency in it yet. Agent Muse (`0xa9a57fede9e6c859febd1b1f510d34d1d0d51e18`, META) looks the same. - catcast (`0xb110cb51b07fd237519ad1f90bc53170e0d61e18`) has `quote: null` and `market_cap_usd: null`: no price yet at all. - All three: `status: "launched"`, `progress_pct: null`, `holders: 2`. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20New%20Long.xyz%20tokens%2C%20before%20their%20first%20trade&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Flong%2F%23long-new%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26launchpad%3Dlong%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) `/token/{address}/launch` (Free plan) returns a Long token’s factory, creator, quote token, launch transaction and block, `status` and its pools. For a token’s markets, prices and liquidity, use [`/token/{address}/pools`](https://docs.crius.sh/guides/get-token-pools-and-liquidity/). ## Use it in your app 1. **Filter launches by liquidity.** New Long tokens start with no quote-side liquidity; `list=new&launchpad=long&min_liquidity_usd=1000` waits for the first real buyers. 2. **Rank the established tokens.** Most Long volume is in a few large tokens: `list=trending&launchpad=long` or `list=top_volume&launchpad=long`. 3. **Handle unusual quotes.** Pairs against PONS, HIMS or MSFT are normal here. Use `price_usd` and `liquidity_usd`, which Crius converts to USD through the quote’s own pools. 4. **Don’t wait for graduation.** A Long token never moves; its pool on day one is its pool for good. Terminal window ```bash # Long.xyz: stats, newest tokens with liquidity, most traded today. curl "https://api.crius.sh/v1/robinhood/launchpads/long?days=30" curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=long&min_liquidity_usd=1000" curl "https://api.crius.sh/v1/robinhood/tokens?list=top_volume&launchpad=long&window=24h" ``` ## Frequently asked questions **How do I list Long.xyz tokens on Robinhood Chain?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=long` for the newest, or `list=top_volume&launchpad=long&window=24h` for the most traded. Subscribe to `launches:long` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) to get each launch as it happens. **Do Long.xyz tokens graduate?** No. They launch directly onto a Uniswap v4 pool and stay there. Doppler can migrate a pool in principle, and Crius watches the Airlock's `Migrate` event, but no Long token has migrated: `graduated` is 0 in the stats. **What are the Long.xyz contract addresses?** Long launches come from the LongLaunchFactory proxy `0x1eef016f22a943abc7dd11422edee9d235942104` and the earlier LongLauncher `0x22e99278308b393ea1260859b181ad7e78f5eeed`, both through the Doppler Airlock `0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862`. `GET /v1/robinhood/launchpads/long` lists the two launchers under `contracts.launch_contracts`. **What do Long.xyz tokens trade against?** Anything: in the samples, Artificial Inu trades against PONS, Boner Coin against the HIMS stock token, A Meme Coin against AMC, and new launches against MSFT and META. Long's 24-hour volume was spread across stock tokens ($3.3 million), other tokens ($2.8 million), ETH ($2.4 million) and USDG ($2.3 million). ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Launchpad **Bankr** How Bankr launches tokens on Robinhood Chain through Doppler on Uniswap v4, how Crius tells real Bankr tokens from copies, contract addresses and API. Read](https://docs.crius.sh/launchpads/bankr/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Find trending tokens** Get the Robinhood Chain tokens with the most real traders, plus top gainers and volume leaders with rugs and wash trading filtered out. Real API responses. Read](https://docs.crius.sh/guides/find-trending-tokens/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Pons on Robinhood Chain (contracts, graduation and API) > Pons v2 launchpad API for Robinhood Chain: launches, curve progress, graduations and fees, plus every contract (PonsV2LaunchFactory, PonsV2MemeHook, locker). Source: https://docs.crius.sh/launchpads/pons/ · Updated 2026-10-28 Short answer Pons v2 tokens are created by the PonsV2LaunchFactory on a per-token bonding curve and graduate into a Uniswap v4 pool with the PonsV2MemeHook, with the LP position locked in the Pons launch locker. List them with `GET /v1/robinhood/tokens?launchpad=pons` (`list=new`, `bonding`, `graduating`, `graduated`), get live stats with `GET /v1/robinhood/launchpads/pons`, and one token's lifecycle with `/token/{address}/launch`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) [GET `/token/{address}/fees`](https://docs.crius.sh/reference/launchpads/fees-claims/) [Pons](https://ponsfamily.com) is the largest token launchpad on Robinhood Chain. Each token gets its own bonding-curve contract that sells tokens against a quote asset (ETH, USDG or a tokenized stock such as PYPL or MCD). When the curve raises its target, the token **graduates**: the raised quote and a block of tokens go into a Uniswap v4 pool that uses the Pons hook, and the LP position is locked in the Pons launch locker. Crius indexes Pons v2, the contracts named PonsV2… below (`version: "v2"` in `/launch`, `deployed_via: "pons_v2"` on the token profile), attributes every Pons token from its factory and follows it from the first curve trade to the v4 pool. ## Pons at a glance | | Pons | | --- | --- | | Crius launchpad id | `pons` (`type: "bonding_curve_to_v4"`) | | Launch | PonsV2LaunchFactory deploys the token (a PonsV2LauncherToken) and a per-token bonding curve; PonsV2LaunchAndBuy can launch and buy in one transaction | | Quote assets | ETH, USDG and stock tokens (PYPL and MCD in the samples on this page) | | Graduation | When the curve has raised its target (4.2 ETH for the ETH-quoted Charge AI) | | After graduation | Uniswap v4 pool with the PonsV2MemeHook; LP position locked in the Pons launch locker (RobinFunFiV2LaunchLocker) | | Fees (Charge AI) | 2% creator tax and 1% hook fee on pool swaps, 30% protocol share, a 99% snipe tax for the first 3 seconds | | Graduation rate | 1.46% of launches (`graduation_rate_pct: 1.46318`), median 2,491 blocks to graduate (about 4 minutes) | ## How a Pons token launches and graduates 1. **Launch.** The creator calls `launchToken` on the PonsV2LaunchFactory, or PonsV2LaunchAndBuy calls `launchTokenFor` on the creator’s behalf and buys in the same transaction. The factory deploys the token and its curve; Crius records the token with `creation.attribution: "known_launchpad"`, `creation.deployed_via: "pons_v2"` and the factory address, and it appears in `list=new` and `list=bonding` with `launchpad: "pons"` and `status: "bonding"`. 2. **Bonding.** Buys and sells go to the curve. `progress_pct` is the quote raised divided by the curve’s target, and it goes down when holders sell back. A snipe tax (99% at the start, for the first 3 seconds on Charge AI) makes buying in the launch block expensive. 3. **Graduation.** When the curve completes, the raised quote and a block of tokens are added to a new Uniswap v4 pool whose hook is the PonsV2MemeHook; the factory’s graduation executor (PonsV2GraduationExecutor) mints the pool’s full-range LP position, which is held by the launch locker. Charge AI moved 4.2 ETH and 204,081,632.65 CHARGE into its pool. `status` becomes `graduated` and `progress_pct` 100. 4. **After graduation.** The LP position sits in the launch locker. Every pool swap pays the hook fee and creator tax to the hook, which holds them as pending fees until they are swept to the creator’s fee recipient, the protocol and the buyback vault. The token’s price, liquidity, trades and candles follow it from the curve into the pool, so a chart of a Pons token starts at its first curve trade. ## Pons contracts on Robinhood Chain The names are the verified contract names (Sourcify), so you can match them to what an explorer such as [robin.etherscan.io](https://robin.etherscan.io) shows. Searching for PonsLaunchFactory, PonsLauncherToken or PonsLaunchLocker? The deployed contracts carry a V2 in the name: PonsV2LaunchFactory, PonsV2LauncherToken, and the locker that the factory calls PonsV2LaunchLocker. | Contract | Address | What it does | | --- | --- | --- | | PonsV2LaunchFactory (launch factory) | `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` | Creates Pons tokens and their curves (`TokenLaunched`, `PoolGraduated`); the `factory` of every Pons token | | PonsV2LauncherToken (each token) | One contract per token, e.g. Charge AI `0x7b8892cea949bc60d494681d1bc3ea96071ab0b8` | The ERC-20 of every Pons v2 token, with its links stored as `PonsV2LauncherToken.Socials`; token sources aren't verified | | PonsV2MemeHook | `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` | Uniswap v4 hook of every graduated Pons pool; collects hook fees and creator tax | | RobinFunFiV2LaunchLocker (launch locker) | `0x267444d099b10fb5ed7c3cc7b7c767adca574952` | Holds the v4 LP positions of graduated tokens for good; returned by the factory's `locker()`, typed PonsV2LaunchLocker in the factory's source | | PonsV2GraduationExecutor | `0xc7819b64a1daecd7ec19856d026cb14efbd89046` | Mints the graduated pool's full-range LP position (`mintFullRangePosition`); the factory's `graduationExecutor()` | | PonsV2FeeEscrow | `0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e` | Pons fee escrow (`role: "launchpad_fee_escrow"` in `/fees`, `fees.escrow` in `/launch`) | | PonsV2BuybackVault | `0x42df2a798f82289e177311362e8f5ccc45c1219c` | Pons buyback vault (`fees.buyback_vault` in `/launch`); buybacks are set per token (`buyback_enabled`) | | PonsV2LaunchAndBuy (launch-and-buy helper) | `0xe33e9e479df8802cb0866d5d05258bec4cf62948` | Forwarder that launches a token for a creator (`launchTokenFor`) and buys in the same transaction | | PonsV2LaunchDeployer | `0x3711cea4feade896c913c68f01eda97cb06d1a42` | Pons v2 launch deployer, used by the factory (`launchDeployer()`) | | PonsV2GraduationGuard | `0xf5695117b99b6f6401e67d4195bd653628176c6c` | Pons contract involved in graduation, the factory's `graduationGuard()` (source not verified) | | Protocol fee recipient | `0x31ea5b453a6cd60f36203830de046ff32dec2cdb` | Receives the protocol share of fees (`protocol_fee_recipient`) | | Uniswap v4 PoolManager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Holds the graduated pools (shared by every v4 pool on the chain) | Each token also has its own curve contract: Charge AI’s is `0x2b0943bf947b54df526047b6fec8183a4fdeb3c3` (`launch.curve` on the token profile and `/launch`). The PONS token (`0x39dbed3a2bd333467115de45665cc57f813c4571`, linked to ponsfamily.com) is a separate token: Crius reports it with `launchpad: null`, because it wasn’t created through the launch factory. ## Pons v2 API: launches, curves, graduations and fees Every stage of a Pons v2 token has its own call. The lists and launchpad stats are on the anonymous plan; one token’s lifecycle needs a free key. | What you want | Call | Plan | | --- | --- | --- | | Launchpad stats: launches, graduations, volume, fees, daily history | `GET /v1/robinhood/launchpads/pons?days=30` | Anonymous | | New Pons launches | `GET /v1/robinhood/tokens?list=new&launchpad=pons` | Anonymous | | Every token still on its curve | `list=bonding&launchpad=pons` | Anonymous | | Curve progress, closest to graduating first | `list=graduating&launchpad=pons` (`progress_pct` 50 or more) | Anonymous | | Graduations, most recent first | `list=graduated&launchpad=pons` | Anonymous | | One token's curve, raised amount, target, graduation pool, LP locker and fee settings | `/token/{address}/launch` | Free | | Fees paid, receivers and sweeps | `/token/{address}/fees` | Starter | | Launches and graduations as they happen | `launches:pons` and `graduations:pons` on the [WebSocket stream](https://docs.crius.sh/reference/stream/) | Free | Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### Pons stats: 716,247 launches, 1.46% graduate How active is the Pons launchpad on Robinhood Chain right now? GET/v1/robinhood/launchpads/pons?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/pons?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/pons?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/pons?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 350 lines (arrays trimmed)** ```json { "data": { "contracts": { "buyback_vault": "0x42df2a798f82289e177311362e8f5ccc45c1219c", "factory": "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "fee_escrow": "0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e", "hook": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "launch_and_buy": "0xe33e9e479df8802cb0866d5d05258bec4cf62948", "lp_locker": "0x267444d099b10fb5ed7c3cc7b7c767adca574952" }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 170878, "graduated": 14, "launches": 1430, "traders": 42760, "trades": 206278, "volume_usd": 19271245 }, { "date": "2026-10-27", "fees_usd": 177036, "graduated": 15, "launches": 1452, "traders": 57144, "trades": 263793, "volume_usd": 19464449 }, { "date": "2026-10-28", "fees_usd": 232042, "graduated": 16, "launches": 1690, "traders": 52250, "trades": 266666, "volume_usd": 23630413 } ] }, "id": "pons", "name": "Pons", "since_block": 27027321, "stats": { "fees_usd_24h": { "lp": 110954, "tax": 144615, "total": 255569 }, "graduated": 10480, "graduated_24h": 17, "graduation_rate_pct": 1.46318, "launches_24h": 1781, "median_blocks_to_graduate": 2491, "tokens_launched": 716247, "traders_24h": 55079, "trades_24h": 285952, "volume_by_quote_usd_24h": { "eth": 13328235, "other": 1946513, "stock": 3097444, "usdg": 7490650 }, "volume_usd_24h": 25862841 }, "top_tokens_24h": [ { "address": "0xedbf91223639800bcd5756815caf908df3b890be", "buy_volume_usd": { "1h": 13166.8, "24h": 1501301, "5m": 708.542, "6h": 514376 }, "buyers": { "1h": 55, "24h": 1901, "5m": 6, "6h": 745 }, "buys": { "1h": 81, "24h": 4653, "5m": 6, "6h": 1464 }, "change_pct": { "1h": -6.26568, "24h": 65.1479, "5m": -0.773021, "6h": 13.4944 }, "created_block": 67325240, "created_ts": 1789845345000, "decimals": 18, "fdv_usd": 14106689, "holders": 4820, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/priors_trade", "website": "https://priors.trade/" }, "liquidity_usd": 942584, "logo": "https://api.crius.sh/v1/robinhood/logo/0xedbf91223639800bcd5756815caf908df3b890be.png?size=128", "market_cap_usd": 14106678, "name": "Priors Agents", "price_eth": 0.00000598885, "price_usd": 0.0141067, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 34344.3, "24h": 1401242, "5m": 462.802, "6h": 485007 }, "sellers": { "1h": 73, "24h": 1888, "5m": 6, "6h": 755 }, "sells": { "1h": 130, "24h": 4995, "5m": 8, "6h": 1535 }, "status": "graduated", "symbol": "PRIORS", "traders": { "1h": 119, "24h": 2579, "5m": 12, "6h": 1060 }, "txns": { "1h": 161, "24h": 7142, "5m": 13, "6h": 2096 }, "volume_usd": { "1h": 47511.1, "24h": 2902542, "5m": 1171.34, "6h": 999383 } }, { "address": "0x94641b97010608c3827fb058074889f19868ff33", "buy_volume_usd": { "1h": 15562.1, "24h": 529864, "5m": 815.808, "6h": 87540.8 }, "buyers": { "1h": 44, "24h": 1372, "5m": 5, "6h": 228 }, "buys": { "1h": 90, "24h": 3345, "5m": 5, "6h": 621 }, "change_pct": { "1h": 4.85445, "24h": 37.4979, "5m": 1.70944, "6h": 9.96024 }, "created_block": 76051465, "created_ts": 1790724560500, "decimals": 18, "fdv_usd": 4988990, "holders": 7132, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": "https://t.me/VraxVerify", "twitter": "https://x.com/RobinhoodApp/status/2105077426481222125", "website": "https://vraxthecommander.cat/" }, "liquidity_usd": 586772, "logo": "https://api.crius.sh/v1/robinhood/logo/0x94641b97010608c3827fb058074889f19868ff33.png?size=128", "market_cap_usd": 4988889, "name": "Commander Vrax", "price_eth": 0.00000211802, "price_usd": 0.00498899, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 9369.91, "24h": 472466, "5m": 1189.91, "6h": 70634.6 }, "sellers": { "1h": 73, "24h": 1263, "5m": 8, "6h": 277 }, "sells": { "1h": 119, "24h": 3171, "5m": 12, "6h": 595 }, "status": "graduated", "symbol": "VRAX", "traders": { "1h": 96, "24h": 1859, "5m": 11, "6h": 408 }, "txns": { "1h": 128, "24h": 3830, "5m": 12, "6h": 635 }, "volume_usd": { "1h": 24932, "24h": 1002331, "5m": 2005.72, "6h": 158175 } }, { "address": "0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725", "buy_volume_usd": { "1h": 12089.9, "24h": 501099, "5m": 97.5853, "6h": 68251.9 }, "buyers": { "1h": 60, "24h": 1263, "5m": 1, "6h": 223 }, "buys": { "1h": 112, "24h": 3157, "5m": 1, "6h": 435 }, "change_pct": { "1h": -0.98306, "24h": 47.0227, "5m": -0.64655, "6h": -4.92164 }, "created_block": 47404695, "created_ts": 1787829863500, "decimals": 18, "fdv_usd": 7669642, "holders": 19014, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/MicroDuckNVDA", "website": "https://microduck.net/" }, "liquidity_usd": 643248, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd5f1afea47b1a9eab414d2ee740cf1d6d039e725.png?size=128", "market_cap_usd": 7669633, "name": "microduck", "price_eth": 0.00000325607, "price_usd": 0.00766964, "progress_pct": 100, "quote": "USDG", "sell_volume_usd": { "1h": 14193, "24h": 447864, "5m": 1441.41, "6h": 76639.5 }, "sellers": { "1h": 39, "24h": 1042, "5m": 3, "6h": 248 }, "sells": { "1h": 65, "24h": 2757, "5m": 5, "6h": 543 }, "status": "graduated", "symbol": "microduck", "traders": { "1h": 92, "24h": 1783, "5m": 4, "6h": 400 }, "txns": { "1h": 126, "24h": 4314, "5m": 4, "6h": 694 }, "volume_usd": { "1h": 26282.9, "24h": 948962, "5m": 1538.99, "6h": 144891 } } ], "type": "bonding_curve_to_v4", "website": "https://ponsfamily.com" }, "meta": { "block": 100410808, "block_age_ms": 623, "block_ts": 1793225487000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 257, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `tokens_launched: 716247` and `graduated: 10480` (`graduation_rate_pct: 1.46318`). In the last 24 hours: 1,781 launches, 17 graduations, 285,952 trades by 55,079 traders. - `volume_usd_24h: 25862841`, of which $13.3 million against ETH, $7.5 million against USDG, $3.1 million against stock tokens and $1.9 million against other tokens (`volume_by_quote_usd_24h`). - `fees_usd_24h.total: 255569`: $110,954 of LP fees and $144,615 of measured taxes. - `history.points` (with `days=3`): 1,430 launches and $19,271,245 of volume on 2026-10-26, 1,452 and $19,464,449 on 10-27, 1,690 and $23,630,413 on 10-28. - `top_tokens_24h` is led by Priors Agents (`0xedbf91223639800bcd5756815caf908df3b890be`) with $2,902,542 of 24-hour volume, then Commander Vrax and microduck: all graduated, all quoted in USDG. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Pons%20stats%3A%20716%2C247%20launches%2C%201.46%25%20graduate&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fpons%2F%23pons-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fpons%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### New Pons tokens, and one that was dumped in 24 seconds What are the newest Pons tokens and how are their curves doing? GET/v1/robinhood/tokens?list=new&launchpad=pons&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x5132c73e282f15e156d43fe1757115c4bda208be", "buy_volume_usd": { "1h": 1443.59, "24h": 1443.59, "5m": 1443.59, "6h": 1443.59 }, "buyers": { "1h": 9, "24h": 9, "5m": 9, "6h": 9 }, "buys": { "1h": 30, "24h": 30, "5m": 30, "6h": 30 }, "change_pct": { "1h": -14.1318, "24h": -14.1318, "5m": -14.1318, "6h": -14.1318 }, "created_block": 100409067, "created_ts": 1793225312360, "decimals": 18, "fdv_usd": 14085.9, "holders": 2, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/1vampnation1/status/2115566407018565807", "website": "https://trustinnom.xyz/" }, "liquidity_usd": 34.5779, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5132c73e282f15e156d43fe1757115c4bda208be.png?size=128", "market_cap_usd": 14085.9, "name": "paycat", "price_eth": 0.00000000598001, "price_usd": 0.0000140859, "progress_pct": 0.0492167, "quote": "PYPL", "sell_volume_usd": { "1h": 1473.19, "24h": 1473.19, "5m": 1473.19, "6h": 1473.19 }, "sellers": { "1h": 8, "24h": 8, "5m": 8, "6h": 8 }, "sells": { "1h": 18, "24h": 18, "5m": 18, "6h": 18 }, "status": "bonding", "symbol": "PAYCAT", "traders": { "1h": 9, "24h": 9, "5m": 9, "6h": 9 }, "txns": { "1h": 48, "24h": 48, "5m": 48, "6h": 48 }, "volume_usd": { "1h": 2916.78, "24h": 2916.78, "5m": 2916.78, "6h": 2916.78 } }, { "address": "0x3736c3daeb6bee85b8086354424e31e23d39a416", "buy_volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 }, "buyers": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "buys": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "change_pct": { "1h": 343.081, "24h": 343.081, "5m": 343.081, "6h": 343.081 }, "created_block": 100408733, "created_ts": 1793225280300, "decimals": 18, "fdv_usd": 9508.48, "holders": 18, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 4722.24, "logo": "https://api.crius.sh/v1/robinhood/logo/0x3736c3daeb6bee85b8086354424e31e23d39a416.png?size=128", "market_cap_usd": 9508.48, "name": "Ronald", "price_eth": 0.00000000403673, "price_usd": 0.00000950848, "progress_pct": 47.1712, "quote": "MCD", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "RONALD", "traders": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "txns": { "1h": 16, "24h": 16, "5m": 16, "6h": 16 }, "volume_usd": { "1h": 2368.93, "24h": 2368.93, "5m": 2368.93, "6h": 2368.93 } }, { "address": "0x82c43abb2ab9633be5a98b76500acbd700344cec", "buy_volume_usd": { "1h": 0.00000040181, "24h": 0.00000040181, "5m": 0.00000040181, "6h": 0.00000040181 }, "buyers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "buys": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "change_pct": { "1h": -13.8651, "24h": -13.8651, "5m": -13.8651, "6h": -13.8651 }, "created_block": 100408402, "created_ts": 1793225246200, "decimals": 18, "fdv_usd": 14051.3, "holders": 5, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/MiamiMinty/status/2115551765949218980?a=JCtZDJI2ZOGh-1E1Kfw&s=20", "website": "https://trustinnom.xyz/" }, "liquidity_usd": 0.00000024843, "logo": "https://api.crius.sh/v1/robinhood/logo/0x82c43abb2ab9633be5a98b76500acbd700344cec.png?size=128", "market_cap_usd": 14051.3, "name": "paycat", "price_eth": 0.00000000596533, "price_usd": 0.0000140513, "progress_pct": 0.000000000353605, "quote": "PYPL", "sell_volume_usd": { "1h": 0.000000269439, "24h": 0.000000269439, "5m": 0.000000269439, "6h": 0.000000269439 }, "sellers": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "sells": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "status": "bonding", "symbol": "PAYCAT", "traders": { "1h": 1, "24h": 1, "5m": 1, "6h": 1 }, "txns": { "1h": 2, "24h": 2, "5m": 2, "6h": 2 }, "volume_usd": { "1h": 0.000000671249, "24h": 0.000000671249, "5m": 0.000000671249, "6h": 0.000000671249 } } ], "meta": { "block": 100410113, "block_age_ms": 524, "block_ts": 1793225417000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 88, "list": "new", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - paycat (`0x5132c73e282f15e156d43fe1757115c4bda208be`) is at `progress_pct: 0.0492167` with $34.58 of liquidity, 30 buys and 18 sells. In the [new tokens guide](https://docs.crius.sh/guides/find-new-tokens/#with-liquidity) sample, captured 24 seconds earlier, the same token was at 3.19647% with $2,392 of liquidity: early buyers sold back into the curve. - A second paycat (`0x82c43abb2ab9633be5a98b76500acbd700344cec`) with the same website was launched 66 seconds before it and never got going (`progress_pct: 3.53605e-10`). Relaunches and copies with the same name are common on Pons; track tokens by address. - Ronald (`0x3736c3daeb6bee85b8086354424e31e23d39a416`) is at 47.1712% with 16 buys and no sells, quoted in MCD. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20New%20Pons%20tokens%2C%20and%20one%20that%20was%20dumped%20in%2024%20seconds&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fpons%2F%23pons-new%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dnew%26launchpad%3Dpons%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Pons curves closest to graduating: 93%, 82% and 75% Which Pons tokens are closest to graduating to Uniswap v4? GET/v1/robinhood/tokens?list=graduating&launchpad=pons&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x742af99ef5e528ee85fb04ff76c44b22ef08611a", "buy_volume_usd": { "1h": 4644.62, "24h": 33416, "5m": 1537.08, "6h": 33416 }, "buyers": { "1h": 61, "24h": 193, "5m": 30, "6h": 193 }, "buys": { "1h": 216, "24h": 739, "5m": 59, "6h": 739 }, "change_pct": { "1h": 7.60431, "24h": 934.335, "5m": 6.82972, "6h": 934.335 }, "created_block": 100366236, "created_ts": 1793220900600, "decimals": 18, "fdv_usd": 44042, "holders": 153, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/OwnerlessFun/status/2115538949003227427", "website": "https://ownerless.fun/" }, "liquidity_usd": 18513.9, "logo": "https://api.crius.sh/v1/robinhood/logo/0x742af99ef5e528ee85fb04ff76c44b22ef08611a.png?size=128", "market_cap_usd": 43583.5, "name": "Ownerless", "price_eth": 0.0000000186742, "price_usd": 0.000044042, "progress_pct": 93.3602, "quote": "ETH", "sell_volume_usd": { "1h": 4149.4, "24h": 23594.6, "5m": 1144.1, "6h": 23594.6 }, "sellers": { "1h": 50, "24h": 102, "5m": 32, "6h": 102 }, "sells": { "1h": 205, "24h": 412, "5m": 68, "6h": 412 }, "status": "bonding", "symbol": "OWNERLESS", "traders": { "1h": 66, "24h": 194, "5m": 35, "6h": 194 }, "txns": { "1h": 421, "24h": 1149, "5m": 127, "6h": 1149 }, "volume_usd": { "1h": 8794.02, "24h": 57010.6, "5m": 2681.18, "6h": 57010.6 } }, { "address": "0x71d5502c2e670b151960596adfbfd57f3d414544", "buy_volume_usd": { "1h": 0, "24h": 2946.31, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 34, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 35, "5m": 0, "6h": 0 }, "change_pct": { "1h": 0.36886, "24h": 20.6009, "5m": 0.36886, "6h": 0.36886 }, "created_block": 98237798, "created_ts": 1792999460800, "decimals": 18, "fdv_usd": 37080.2, "holders": 160, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 16317.8, "logo": "https://api.crius.sh/v1/robinhood/logo/0x71d5502c2e670b151960596adfbfd57f3d414544.png?size=128", "market_cap_usd": 37080.2, "name": "NMS", "price_eth": 0.0000000157223, "price_usd": 0.0000370802, "progress_pct": 82.3668, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 1727.7, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 16, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 17, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "NMS", "traders": { "1h": 0, "24h": 45, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 52, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 4674.01, "5m": 0, "6h": 0 } }, { "address": "0x5052497a00f7e2a2658b45af5726b2698ddf6ec8", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": null, "24h": null, "5m": null, "6h": null }, "created_block": 59730868, "created_ts": 1789076323800, "decimals": 18, "fdv_usd": 11388.5, "holders": 105, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/mademen_family", "website": "https://mademen.family/t/open" }, "liquidity_usd": 14815.6, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5052497a00f7e2a2658b45af5726b2698ddf6ec8.png?size=128", "market_cap_usd": 11388.5, "name": "open", "price_eth": 0.0000000138342, "price_usd": 0.000032627, "progress_pct": 74.7841, "quote": "ETH", "sell_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "status": "bonding", "symbol": "OPEN", "traders": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 } } ], "meta": { "block": 100455211, "block_age_ms": 1477, "block_ts": 1793230041000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 511, "list": "graduating", "next_cursor": "3", "safe_block": 100449754, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Ownerless (`0x742af99ef5e528ee85fb04ff76c44b22ef08611a`) leads at `progress_pct: 93.3602` on an ETH curve, with $18,513.9 of liquidity, 153 holders and 739 buys against 412 sells in 24 hours. - NMS (`0x71d5502c2e670b151960596adfbfd57f3d414544`) is at 82.3668%, with 52 transactions in 24 hours and none in the last hour. - open (`0x5052497a00f7e2a2658b45af5726b2698ddf6ec8`) is at 74.7841% but had no trades in 24 hours: it was created about 48 days before the capture (`created_ts: 1789076323800`). A curve can stall below 100% for good. - All three still show `status: "bonding"`. When one completes, it leaves this list and appears in `list=graduated` with `progress_pct: 100`. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Pons%20curves%20closest%20to%20graduating%3A%2093%25%2C%2082%25%20and%2075%25&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fpons%2F%23pons-graduating%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduating%26launchpad%3Dpons%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### The latest Pons graduations, and one that fell 96% in an hour Which Pons tokens graduated most recently, and how are they trading on Uniswap v4? GET/v1/robinhood/tokens?list=graduated&launchpad=pons&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=pons&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=pons&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=pons&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0xea04f0ebb9b17b817f97694fac5deaeb5722b495", "buy_volume_usd": { "1h": 44955.4, "24h": 44955.4, "5m": 1688.14, "6h": 44955.4 }, "buyers": { "1h": 247, "24h": 247, "5m": 20, "6h": 247 }, "buys": { "1h": 364, "24h": 364, "5m": 23, "6h": 364 }, "change_pct": { "1h": -17.1671, "24h": -17.1671, "5m": 0.300852, "6h": -17.1671 }, "created_block": 100442286, "created_ts": 1793228722600, "decimals": 18, "fdv_usd": 20361.8, "holders": 177, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/WagieCoinRH", "website": null }, "liquidity_usd": 9186.32, "logo": "https://api.crius.sh/v1/robinhood/logo/0xea04f0ebb9b17b817f97694fac5deaeb5722b495.png?size=128", "market_cap_usd": 20361.8, "name": "Wagie", "price_eth": 0.00000000863361, "price_usd": 0.0000203618, "progress_pct": 100, "quote": "MCD", "sell_volume_usd": { "1h": 40247.8, "24h": 40247.8, "5m": 1709.59, "6h": 40247.8 }, "sellers": { "1h": 132, "24h": 132, "5m": 20, "6h": 132 }, "sells": { "1h": 349, "24h": 349, "5m": 23, "6h": 349 }, "status": "graduated", "symbol": "WAGIE", "traders": { "1h": 265, "24h": 265, "5m": 40, "6h": 265 }, "txns": { "1h": 491, "24h": 491, "5m": 26, "6h": 491 }, "volume_usd": { "1h": 85203.2, "24h": 85203.2, "5m": 3397.72, "6h": 85203.2 } }, { "address": "0x80427a46e3f337b1e4a47abe3d21a4caaab898c7", "buy_volume_usd": { "1h": 14753, "24h": 48577.2, "5m": 0, "6h": 48577.2 }, "buyers": { "1h": 149, "24h": 283, "5m": 0, "6h": 283 }, "buys": { "1h": 154, "24h": 351, "5m": 0, "6h": 351 }, "change_pct": { "1h": -95.7723, "24h": -95.2138, "5m": -1.02279, "6h": -95.2138 }, "created_block": 100419101, "created_ts": 1793226345100, "decimals": 18, "fdv_usd": 1294.43, "holders": 31, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/GrimaceCoinRHC", "website": "https://www.mcdonalds.com/" }, "liquidity_usd": 2296.08, "logo": "https://api.crius.sh/v1/robinhood/logo/0x80427a46e3f337b1e4a47abe3d21a4caaab898c7.png?size=128", "market_cap_usd": 1294.43, "name": "Grimace Coin", "price_eth": 0.000000000548851, "price_usd": 0.00000129443, "progress_pct": 100, "quote": "MCD", "sell_volume_usd": { "1h": 19487.5, "24h": 47365.1, "5m": 0, "6h": 47365.1 }, "sellers": { "1h": 249, "24h": 262, "5m": 0, "6h": 262 }, "sells": { "1h": 346, "24h": 492, "5m": 0, "6h": 492 }, "status": "graduated", "symbol": "GRIMACE", "traders": { "1h": 256, "24h": 284, "5m": 0, "6h": 284 }, "txns": { "1h": 364, "24h": 572, "5m": 0, "6h": 572 }, "volume_usd": { "1h": 34240.4, "24h": 95942.3, "5m": 0, "6h": 95942.3 } }, { "address": "0x1e6016155e0e1e73c95b4080f1180e60383a9026", "buy_volume_usd": { "1h": 55239.5, "24h": 97247.2, "5m": 2017.18, "6h": 97247.2 }, "buyers": { "1h": 636, "24h": 865, "5m": 37, "6h": 865 }, "buys": { "1h": 1188, "24h": 1766, "5m": 45, "6h": 1766 }, "change_pct": { "1h": 24.5062, "24h": 92.0332, "5m": 17.2513, "6h": 92.0332 }, "created_block": 100412479, "created_ts": 1793225673900, "decimals": 18, "fdv_usd": 50208.4, "holders": 300, "launchpad": "pons", "launchpad_name": "Pons", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://ponsfamily.com/launchpad/0xb1a7abcbe798bcd3302f71c0f274d6828bfa6302", "website": "https://ponsfamily.com/launchpad/0xed488ad4401fd576c6d07c6ac695cd36dc9aece1" }, "liquidity_usd": 15512, "logo": "https://api.crius.sh/v1/robinhood/logo/0x1e6016155e0e1e73c95b4080f1180e60383a9026.png?size=128", "market_cap_usd": 50208.4, "name": "nugs", "price_eth": 0.0000000212888, "price_usd": 0.0000502084, "progress_pct": 100, "quote": "MCD", "sell_volume_usd": { "1h": 54647, "24h": 89833.5, "5m": 1389.58, "6h": 89833.5 }, "sellers": { "1h": 520, "24h": 674, "5m": 27, "6h": 674 }, "sells": { "1h": 873, "24h": 1823, "5m": 31, "6h": 1823 }, "status": "graduated", "symbol": "NUGS", "traders": { "1h": 700, "24h": 873, "5m": 48, "6h": 873 }, "txns": { "1h": 2003, "24h": 3531, "5m": 67, "6h": 3531 }, "volume_usd": { "1h": 109887, "24h": 187081, "5m": 3406.75, "6h": 187081 } } ], "meta": { "block": 100455222, "block_age_ms": 1149, "block_ts": 1793230042000, "chain": "robinhood", "finalized_block": 100446224, "lag_ms": 89, "list": "graduated", "next_cursor": "3", "safe_block": 100449754, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - Wagie (`0xea04f0ebb9b17b817f97694fac5deaeb5722b495`), quoted in MCD, was created 22 minutes before the capture and has already graduated: 177 holders and $85,203.2 of volume. - Grimace Coin (`0x80427a46e3f337b1e4a47abe3d21a4caaab898c7`) has graduated but fell 95.7723% in the last hour (`change_pct.1h`), to a market cap of $1,294.43. Graduation says the curve filled, not that the token is safe: check `/security` and the [launch’s buyers](https://docs.crius.sh/guides/detect-bundles-and-snipers/). - nugs (`0x1e6016155e0e1e73c95b4080f1180e60383a9026`) has 300 holders and $187,081 of 24-hour volume, up 92.0332%. - All three have `status: "graduated"` and `progress_pct: 100`; their price, liquidity and trades now come from the v4 pool. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20The%20latest%20Pons%20graduations%2C%20and%20one%20that%20fell%2096%25%20in%20an%20hour&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fpons%2F%23pons-graduated%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduated%26launchpad%3Dpons%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) In `/launch`, the Pons v2 fee settings are in basis points: `fees.creator_tax_bps` (200 for Charge AI, 2%), `hook_fee_bps` (100, 1%), `protocol_fee_share_bps` (3000, 30%) and `snipe_tax` (`start_bps: 9900` for `window_s: 3`); `fees.pending` holds what the hook has collected but not yet swept. For one token’s full lifecycle (curve, raised amount, target, graduation pool, LP locker, fee settings and pending fees), call `/token/{address}/launch` on the Free plan; the [Charge AI example](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/#lifecycle) walks through a real response. Fees, receivers and sweeps for a Pons token are in [`/token/{address}/fees`](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/) (Starter plan). ## Use it in your app 1. **Feed new launches.** `list=new&launchpad=pons&min_liquidity_usd=1000` every few seconds, or the `launches:pons` stream channel. 2. **Watch the curves.** `list=graduating&launchpad=pons` returns Pons tokens at 50%+ progress, closest first. 3. **Check before you list.** `/security` on each token. Its score covers the contract, the launch (snipers, insiders) and the liquidity lock; the [security score guide](https://docs.crius.sh/guides/token-security-score/) compares a clean Pons token (score 95) with a Pons insider launch (score 45). 4. **Follow graduations.** `list=graduated&launchpad=pons` or `graduations:pons`; after graduation the token trades in its v4 pool and `/token/{address}/pools` lists it. Terminal window ```bash # Pons launchpad: stats, newest tokens, closest to graduating, latest graduations. curl "https://api.crius.sh/v1/robinhood/launchpads/pons?days=30" curl "https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=pons&min_liquidity_usd=1000" curl "https://api.crius.sh/v1/robinhood/tokens?list=graduating&launchpad=pons" curl "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=pons" # One token's lifecycle (Free plan key) curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/launch" -H "x-api-key: $CRIUS_API_KEY" ``` ## Frequently asked questions **Is there a Pons v2 API for launches, curves and graduations?** Yes, through Crius: `GET https://api.crius.sh/v1/robinhood/launchpads/pons` for launchpad stats, `/v1/robinhood/tokens?list=new&launchpad=pons` for new launches, `list=graduating&launchpad=pons` for curve progress (`progress_pct`), `list=graduated&launchpad=pons` for graduations and `/token/{address}/launch` for one token's curve, target, LP locker and fee settings. For push updates, subscribe to `launches:pons` and `graduations:pons` on the [WebSocket stream](https://docs.crius.sh/reference/stream/). **What are the Pons contract addresses on Robinhood Chain?** The launch factory (PonsV2LaunchFactory) is `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e`, the v4 hook (PonsV2MemeHook) `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044`, the LP locker `0x267444d099b10fb5ed7c3cc7b7c767adca574952` and the launch-and-buy helper (PonsV2LaunchAndBuy) `0xe33e9e479df8802cb0866d5d05258bec4cf62948`. The full list is in the contracts table on this page, and `GET /v1/robinhood/launchpads/pons` returns the main ones under `contracts`. **When does a Pons token graduate?** When its curve has raised its target in the quote currency. Charge AI's curve, priced in ETH, graduated at 4.2 ETH raised (`progress.threshold: 4.2`). Pons tokens priced in USDG or a stock token have their own targets; `progress_pct` in every list row shows how close each one is. **What is the Pons launch locker?** The contract at `0x267444d099b10fb5ed7c3cc7b7c767adca574952` that holds the Uniswap v4 LP position of every graduated Pons token, permanently. Its verified contract name is RobinFunFiV2LaunchLocker; the factory's source types it as PonsV2LaunchLocker, and the factory's `locker()` returns this address. `/token/{address}/launch` shows the `lp_locker` and `lp_position_id`, and `/security` reports the locked share (about 97% for the sockets token in the security guide). **What is PonsV2LauncherToken?** The contract name of Pons v2 tokens (sometimes searched as PonsLauncherToken): the factory's and deployer's ABIs define the token's links (`twitter`, `telegram`, `discord`, `website`, `farcaster`) as the struct `PonsV2LauncherToken.Socials`. Every token the PonsV2LaunchFactory creates, such as Charge AI (`0x7b8892cea949bc60d494681d1bc3ea96071ab0b8`), is one. Pons token contracts aren't verified on Sourcify, which is why `/security` gives them the `unverified` flag (−5). ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Get fees & creator rewards** See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response. Read](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/) [Launchpad **Flap.sh** How Flap.sh launches tax and non-tax tokens on Robinhood Chain, graduates them to Uniswap v2 with burned LP, its contract addresses and the Crius API. Read](https://docs.crius.sh/launchpads/flap/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # King of the Markets (Standard Reserve) on Robinhood Chain > How King of the Markets prices bonding curves in stock tokens (SPCX, BABA, SKHY) and graduates them to Uniswap v4 on Robinhood Chain: contracts and API. Source: https://docs.crius.sh/launchpads/standard-reserve/ · Updated 2026-10-28 Short answer King of the Markets, the Standard Reserve's launchpad, sells each token on its own bonding curve priced in a stock token (SPCX, BABA or SKHY) and graduates it into a Uniswap v4 pool with permanently locked liquidity. List its tokens with `GET /v1/robinhood/tokens?launchpad=standard_reserve`, get stats with `GET /v1/robinhood/launchpads/standard_reserve`, and one token's lifecycle with `/token/{address}/launch`. [GET `/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/) [GET `/tokens`](https://docs.crius.sh/reference/discovery/token-lists/) [GET `/token/{address}/launch`](https://docs.crius.sh/reference/launchpads/launch-lifecycle/) **King of the Markets** is the launchpad of [The Standard Reserve](https://www.standardreserve.xyz). Its bonding curves are priced in **tokenized stocks** instead of ETH: every token is paired with SPCX, BABA or SKHY from launch, and buyers pay in that stock (or in ETH or USDG, converted on the way in). Tokens can’t be transferred until they graduate; when the curve sells out, the token moves into a Uniswap v4 pool against the same stock, with its liquidity locked for good. ## King of the Markets at a glance | | King of the Markets | | --- | --- | | Crius launchpad id | `standard_reserve` (page slug `standard-reserve`) | | Launch | LaunchFactory deploys the token (1 billion supply) and a per-token BondingCurve clone; launch fee 0.0005 ETH | | Quote assets | Stock tokens: SPCX, BABA, SKHY. ETH and USDG are converted by the LaunchRouter | | Bonding | Constant-product curve over virtual reserves; token transfers locked until graduation | | Graduation | When the curve's supply is sold; `Graduated` on the LaunchFactory | | After graduation | Uniswap v4 pool (fee 0, tick spacing 200) with the LaunchHook; liquidity permanently locked | | Fees | 1% base fee (30% creator, 70% protocol), creator tax 0–5%, snipe fee from 99% over the first 7 seconds | | Graduation rate | 1.00% (`graduation_rate_pct: 1.00319`), median 2,835 blocks to graduate (about 5 minutes) | ## How a King of the Markets token launches and graduates 1. **Launch.** The creator calls `launch` on the LaunchFactory with the stock to pair with, name, symbol, metadata, creator tax, snipe-fee switch and an optional charter drop. The factory deploys the token through the TokenDeployer, creates a BondingCurve clone and emits `Launched`, which already contains the v4 pool the token will graduate into. Crius attributes the token from that event. 2. **Bonding.** Trades go to the curve and are priced in the stock. Each trade pays the 1% base fee (plus any creator tax and, in the first 7 seconds, the snipe fee); the creator’s share collects in the FeeEscrow and the rest goes to the protocol’s Safe. Tokens can’t be transferred outside the curve yet. 3. **Graduation.** The buy that takes the last curve tokens triggers graduation: the token moves into the v4 pool fixed at launch with its pool supply of tokens, and that liquidity is locked permanently. If the launch had a charter drop, those tokens go to the CharterDrop contract for $STANDARD charter holders. 4. **After graduation.** The LaunchHook charges the same fee on pool swaps. Crius indexes the v4 pool swaps directly. The first launch, Kimchi (`0x92de9d3888953f3c6a55840f189c409976d9bba1`, block 88,527,856, paired with SKHY), sold 770 million tokens on its curve and put 220 million into its pool. Its launch block is the `since_block` Crius reports. ## King of the Markets contracts on Robinhood Chain | Contract | Address | What it does | | --- | --- | --- | | LaunchFactory | `0x3d6ea4e97b8ab9e1a1b4943febffe22d8c920091` | Launches tokens; emits `Launched` and `Graduated` (verified) | | BondingCurve implementation | `0x0d6fd6f0f07c1b6caec7150966a801b7d5a991e3` | Logic of every per-token curve (each launch is an EIP-1167 clone) | | LaunchHook | `0x048f2dc8a71a0321b5e119cd577c56d0190920cc` | Uniswap v4 hook of every graduated pool; charges the fee on pool swaps | | LaunchRouter | `0x190b452d16e12e3beedd76a030ea991fe3856c33` | Lets buyers pay and sellers receive ETH or USDG, converted to and from the stock | | TokenDeployer | `0xf47e03bea56c4de656dc7423ebf66e503f84f7be` | Deploys launch tokens for the factory | | FeeEscrow | `0xcbc8f65ef158c829379472dee771cf3e7741440e` | Holds each curve's creator fees until claimed by its fee recipient | | Fee Safe | `0x047829087f9ac81fdb05f7b750458afe3d72415f` | 2-of-4 Safe: launch fees, the protocol share of trade fees, snipe fees | | CharterDrop | `0xff4639d2369b7411e666c9b4a44dbfb2b51ba1e1` | Receives charter-drop tokens at graduation for $STANDARD charter holders | | SessionFeeHook | `0xc15b155a3094934171a15625d1a80aba267b6080` | Hook on the stock/USDG pools the router converts through; its fee depends on the US market session | | Deployer and owner | `0xb1748f1857bef8de020982aa33f6f9cc1b9ad3c1` | Deployed the contracts and owns the factory and hooks | | SPCX / BABA / SKHY | `0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea` / `0xad25ac6c84d497db898fa1e8387bf6af3532a1c4` / `0x84cab63bc87912e71ad199ff14a0ba45de68fef8` | The stock tokens curves are priced in | ## Query King of the Markets with Crius Example [Anonymous · no key · 2 credits](https://docs.crius.sh/reference/launchpads/launchpad-detail/) ### King of the Markets stats: 2,193 launches, 22 graduations How active is King of the Markets on Robinhood Chain? GET/v1/robinhood/launchpads/standard\_reserve?days=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/launchpads/standard_reserve?days=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/launchpads/standard_reserve?days=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/launchpads/standard_reserve?days=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 347 lines (arrays trimmed)** ```json { "data": { "contracts": { "launch_contracts": [ "0x3d6ea4e97b8ab9e1a1b4943febffe22d8c920091" ] }, "history": { "days": 3, "points": [ { "date": "2026-10-26", "fees_usd": 143.172, "graduated": 0, "launches": 5, "traders": 200, "trades": 766, "volume_usd": 74007.1 }, { "date": "2026-10-27", "fees_usd": 22.6598, "graduated": 0, "launches": 4, "traders": 142, "trades": 518, "volume_usd": 65636.9 }, { "date": "2026-10-28", "fees_usd": 24.9723, "graduated": 0, "launches": 1, "traders": 196, "trades": 673, "volume_usd": 94840.3 } ] }, "id": "standard_reserve", "name": "King of the Markets (Standard Reserve)", "since_block": 88527856, "stats": { "fees_usd_24h": { "lp": 15.7398, "tax": 9.64612, "total": 25.3859 }, "graduated": 22, "graduated_24h": 0, "graduation_rate_pct": 1.00319, "launches_24h": 1, "median_blocks_to_graduate": 2835, "tokens_launched": 2193, "traders_24h": 217, "trades_24h": 739, "volume_by_quote_usd_24h": { "eth": 0.343093, "other": 0, "stock": 104433, "usdg": 240.598 }, "volume_usd_24h": 104674 }, "top_tokens_24h": [ { "address": "0xd589027135d4dad0f269c4bb6986d28e4e62e44d", "buy_volume_usd": { "1h": 14968.8, "24h": 22369.9, "5m": 0, "6h": 21336.1 }, "buyers": { "1h": 1, "24h": 3, "5m": 0, "6h": 2 }, "buys": { "1h": 27, "24h": 102, "5m": 0, "6h": 45 }, "change_pct": { "1h": -8.45096, "24h": -5.52872, "5m": -9.35954, "6h": -0.753962 }, "created_block": 92487736, "created_ts": 1792399800320, "decimals": 18, "fdv_usd": 3918.47, "holders": 2, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 2.30232, "logo": "https://api.crius.sh/v1/robinhood/logo/0xd589027135d4dad0f269c4bb6986d28e4e62e44d.png?size=128", "market_cap_usd": 3918.47, "name": "The Federal Bird", "price_eth": 0.00000000166354, "price_usd": 0.00000391847, "progress_pct": null, "quote": "SPCX", "sell_volume_usd": { "1h": 14819.5, "24h": 22248.5, "5m": 0, "6h": 21126 }, "sellers": { "1h": 1, "24h": 4, "5m": 0, "6h": 2 }, "sells": { "1h": 25, "24h": 97, "5m": 0, "6h": 39 }, "status": "bonding", "symbol": "FEDBIRD", "traders": { "1h": 1, "24h": 4, "5m": 0, "6h": 2 }, "txns": { "1h": 52, "24h": 199, "5m": 0, "6h": 84 }, "volume_usd": { "1h": 29788.3, "24h": 44618.4, "5m": 0, "6h": 42462.1 } }, { "address": "0x5452fcb54894027801cf8852e6acbca2890cb5f7", "buy_volume_usd": { "1h": 364.574, "24h": 13346.5, "5m": 364.574, "6h": 2015.97 }, "buyers": { "1h": 1, "24h": 34, "5m": 1, "6h": 12 }, "buys": { "1h": 1, "24h": 99, "5m": 1, "6h": 22 }, "change_pct": { "1h": -1.16762, "24h": -19.4149, "5m": -2.54228, "6h": -1.57592 }, "created_block": 92575867, "created_ts": 1792408887700, "decimals": 18, "fdv_usd": 41036.1, "holders": 125, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": "https://discord.gg/AsWJpX4eA", "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/Skarly_co1n", "website": null }, "liquidity_usd": 18622.7, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5452fcb54894027801cf8852e6acbca2890cb5f7.png?size=128", "market_cap_usd": 41036.1, "name": "SKARLY COIN", "price_eth": 0.0000000174215, "price_usd": 0.0000410361, "progress_pct": 100, "quote": "SPCX", "sell_volume_usd": { "1h": 511.699, "24h": 14271.2, "5m": 461.171, "6h": 2109.35 }, "sellers": { "1h": 2, "24h": 39, "5m": 2, "6h": 9 }, "sells": { "1h": 3, "24h": 93, "5m": 2, "6h": 23 }, "status": "graduated", "symbol": "SKARLY", "traders": { "1h": 3, "24h": 49, "5m": 3, "6h": 15 }, "txns": { "1h": 4, "24h": 192, "5m": 3, "6h": 45 }, "volume_usd": { "1h": 876.273, "24h": 27617.6, "5m": 825.745, "6h": 4125.32 } }, { "address": "0xbf9b33ed15069775e799c7af7ccb0637f8eeb9bf", "buy_volume_usd": { "1h": 157.31, "24h": 6629.07, "5m": 0, "6h": 4243.74 }, "buyers": { "1h": 1, "24h": 69, "5m": 0, "6h": 44 }, "buys": { "1h": 1, "24h": 97, "5m": 0, "6h": 61 }, "change_pct": { "1h": -8.37934, "24h": 25.1002, "5m": -3.35261, "6h": 23.1233 }, "created_block": 88533429, "created_ts": 1791997672900, "decimals": 18, "fdv_usd": 36672.5, "holders": 280, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/standardcatrsv", "website": "https://standardcat.family/" }, "liquidity_usd": 17685.7, "logo": "https://api.crius.sh/v1/robinhood/logo/0xbf9b33ed15069775e799c7af7ccb0637f8eeb9bf.png?size=128", "market_cap_usd": 36672.5, "name": "Standard Cat", "price_eth": 0.0000000155689, "price_usd": 0.0000366725, "progress_pct": 100, "quote": "SPCX", "sell_volume_usd": { "1h": 548.854, "24h": 5528.69, "5m": 143.062, "6h": 3349.01 }, "sellers": { "1h": 8, "24h": 57, "5m": 2, "6h": 34 }, "sells": { "1h": 9, "24h": 68, "5m": 2, "6h": 37 }, "status": "graduated", "symbol": "SCAT", "traders": { "1h": 9, "24h": 75, "5m": 2, "6h": 47 }, "txns": { "1h": 9, "24h": 151, "5m": 2, "6h": 89 }, "volume_usd": { "1h": 706.164, "24h": 12157.8, "5m": 143.062, "6h": 7592.75 } } ], "type": "config_driven", "website": "https://www.standardreserve.xyz" }, "meta": { "block": 100410896, "block_age_ms": 1199, "block_ts": 1793225495000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 54, "notes": [ "volume and trades: every trade of the launchpad's tokens in any pool, on the curve and after graduation", "fees_usd_24h.lp: LP fees at each pool's fee (v4: the swap's own fee); tax: token and hook taxes measured from trades (taxes a hook takes in the quote currency on sells are not measured yet)" ], "safe_block": 100405028 } } ``` What this tells you - `name: "King of the Markets (Standard Reserve)"`, `tokens_launched: 2193`, `graduated: 22`, `median_blocks_to_graduate: 2835`. - In 24 hours: 1 launch, 739 trades by 217 traders and `volume_usd_24h: 104674`, of which $104,433 against stock tokens (`volume_by_quote_usd_24h.stock`). Launches have slowed to 5, 4 and 1 a day on 2026-10-26, 27 and 28 (`history.points`), while volume held at $65,000–$95,000 a day. - `fees_usd_24h.total` is only $25.39: the fees are taken in the stock token by the curve and hook, and taxes a hook takes in the quote currency aren’t measured yet (`meta.notes`). - `top_tokens_24h` is led by The Federal Bird (`0xd589027135d4dad0f269c4bb6986d28e4e62e44d`): $44,618.4 of volume from 4 traders, on $2.30 of liquidity, still bonding. Volume without traders means little. SKARLY COIN (`0x5452fcb54894027801cf8852e6acbca2890cb5f7`) and Standard Cat (`0xbf9b33ed15069775e799c7af7ccb0637f8eeb9bf`) are graduated with 125 and 280 holders. All three are quoted in SPCX. [Launchpad detail reference](https://docs.crius.sh/reference/launchpads/launchpad-detail/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20King%20of%20the%20Markets%20stats%3A%202%2C193%20launches%2C%2022%20graduations&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fstandard-reserve%2F%23kotm-stats%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Flaunchpads%2Fstandard_reserve%3Fdays%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/discovery/token-lists/) ### Graduated King of the Markets tokens Which King of the Markets tokens have graduated, and what do their pools hold? GET/v1/robinhood/tokens?list=graduated&launchpad=standard\_reserve&limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=standard_reserve&limit=3" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=standard_reserve&limit=3"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/tokens?list=graduated&launchpad=standard_reserve&limit=3", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 281 lines (arrays trimmed)** ```json { "data": [ { "address": "0x5452fcb54894027801cf8852e6acbca2890cb5f7", "buy_volume_usd": { "1h": 364.574, "24h": 13356.7, "5m": 364.574, "6h": 2065.48 }, "buyers": { "1h": 1, "24h": 35, "5m": 1, "6h": 12 }, "buys": { "1h": 1, "24h": 100, "5m": 1, "6h": 23 }, "change_pct": { "1h": 6.5113, "24h": -13.9844, "5m": 5.02984, "6h": 6.67792 }, "created_block": 92575867, "created_ts": 1792408887700, "decimals": 18, "fdv_usd": 44224.5, "holders": 126, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": "https://discord.gg/AsWJpX4eA", "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/Skarly_co1n", "website": null }, "liquidity_usd": 19332.3, "logo": "https://api.crius.sh/v1/robinhood/logo/0x5452fcb54894027801cf8852e6acbca2890cb5f7.png?size=128", "market_cap_usd": 44224.5, "name": "SKARLY COIN", "price_eth": 0.0000000187751, "price_usd": 0.0000442245, "progress_pct": 100, "quote": "SPCX", "sell_volume_usd": { "1h": 156.895, "24h": 13916.4, "5m": 106.367, "6h": 1754.55 }, "sellers": { "1h": 1, "24h": 39, "5m": 1, "6h": 9 }, "sells": { "1h": 2, "24h": 92, "5m": 1, "6h": 22 }, "status": "graduated", "symbol": "SKARLY", "traders": { "1h": 2, "24h": 49, "5m": 2, "6h": 15 }, "txns": { "1h": 3, "24h": 192, "5m": 2, "6h": 45 }, "volume_usd": { "1h": 521.469, "24h": 27273.1, "5m": 470.942, "6h": 3820.03 } }, { "address": "0x9353ac4dcf13630169e22188894deb20abf40e3a", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": -0.969516, "24h": -4.73911, "5m": -0.969516, "6h": -0.969516 }, "created_block": 90257835, "created_ts": 1792171816500, "decimals": 18, "fdv_usd": 6283.91, "holders": 126, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": "https://x.com/payloadspcx", "website": "https://payloadspcx.com/" }, "liquidity_usd": 7322.74, "logo": "https://api.crius.sh/v1/robinhood/logo/0x9353ac4dcf13630169e22188894deb20abf40e3a.png?size=128", "market_cap_usd": 6023.68, "name": "PAYLOAD", "price_eth": 0.00000000266777, "price_usd": 0.00000628391, "progress_pct": 100, "quote": "SPCX", "sell_volume_usd": { "1h": 0, "24h": 18.1582, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 3, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 3, "5m": 0, "6h": 0 }, "status": "graduated", "symbol": "PAYLOAD", "traders": { "1h": 0, "24h": 3, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 3, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 18.1582, "5m": 0, "6h": 0 } }, { "address": "0x3cedeb9e2b73ae92c61aa4bb5fa27d1cbab75d65", "buy_volume_usd": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buyers": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "buys": { "1h": 0, "24h": 0, "5m": 0, "6h": 0 }, "change_pct": { "1h": -3.48023, "24h": -3.40644, "5m": -3.48023, "6h": -3.48023 }, "created_block": 89623205, "created_ts": 1792107543500, "decimals": 18, "fdv_usd": 2512.6, "holders": 34, "launchpad": "standard_reserve", "launchpad_name": "King of the Markets (Standard Reserve)", "links": { "discord": null, "farcaster": null, "github": null, "telegram": null, "twitter": null, "website": null }, "liquidity_usd": 4876.36, "logo": "https://api.crius.sh/v1/robinhood/logo/0x3cedeb9e2b73ae92c61aa4bb5fa27d1cbab75d65.png?size=128", "market_cap_usd": 2512.6, "name": "The Banking King", "price_eth": 0.0000000010667, "price_usd": 0.0000025126, "progress_pct": 100, "quote": "SPCX", "sell_volume_usd": { "1h": 0, "24h": 0.482033, "5m": 0, "6h": 0 }, "sellers": { "1h": 0, "24h": 2, "5m": 0, "6h": 0 }, "sells": { "1h": 0, "24h": 2, "5m": 0, "6h": 0 }, "status": "graduated", "symbol": "KING", "traders": { "1h": 0, "24h": 2, "5m": 0, "6h": 0 }, "txns": { "1h": 0, "24h": 2, "5m": 0, "6h": 0 }, "volume_usd": { "1h": 0, "24h": 0.482033, "5m": 0, "6h": 0 } } ], "meta": { "block": 100410006, "block_age_ms": 675, "block_ts": 1793225406000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 42, "list": "graduated", "next_cursor": "3", "safe_block": 100405028, "stats_since": "chain_start", "window": "24h" } } ``` What this tells you - SKARLY COIN (`0x5452fcb54894027801cf8852e6acbca2890cb5f7`): `status: "graduated"`, `quote: "SPCX"`, a $44,224.5 market cap and $19,332.3 of liquidity. - PAYLOAD (`0x9353ac4dcf13630169e22188894deb20abf40e3a`) has $7,322.74 of liquidity against a $6,023.68 market cap and only sells in the last 24 hours. Locked liquidity stays in the pool when the price falls, so liquidity can exceed market cap. - The Banking King (`0x3cedeb9e2b73ae92c61aa4bb5fa27d1cbab75d65`) has 34 holders and $4,876.36 of liquidity. [Token lists reference](https://docs.crius.sh/reference/discovery/token-lists/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Graduated%20King%20of%20the%20Markets%20tokens&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Flaunchpads%2Fstandard-reserve%2F%23kotm-graduated%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftokens%3Flist%3Dgraduated%26launchpad%3Dstandard_reserve%26limit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) `/token/{address}/launch` (Free plan) returns the factory, creator, quote stock, launch transaction and block, `status`, `graduated_block` and the token’s pools, including the v4 pool with the LaunchHook. ## Use it in your app 1. **Use the underscore id.** Filters and stream channels take `standard_reserve`: `/tokens?launchpad=standard_reserve`, `launches:standard_reserve`. 2. **Show prices in USD and in the stock.** `price_usd` is converted through the stock token’s pools; `quote` says which stock. A move in SPCX moves every SPCX-paired token’s USD price. 3. **Don’t offer transfers before graduation.** Tokens on the curve can only be bought and sold through it; a wallet app should hide send buttons until `status` is `graduated`. 4. **Look past volume.** With few launches a day, a single token with four traders can top the list. Rank by `traders` or use `list=trending&launchpad=standard_reserve`. ```python # King of the Markets tokens on their curves, with the stock they're priced in. import requests rows = requests.get( "https://api.crius.sh/v1/robinhood/tokens", params={"list": "bonding", "launchpad": "standard_reserve", "limit": 50}, timeout=10, ).json()["data"] for t in rows: print(f"{t['symbol']:<10} {t['address']} vs {t['quote']}: progress {t['progress_pct']} " f"traders 24h {t['traders']['24h']} liq ${t['liquidity_usd']:,.2f}") ``` ## Frequently asked questions **How do I list King of the Markets tokens?** Call `GET https://api.crius.sh/v1/robinhood/tokens?list=new&launchpad=standard_reserve` for new launches, `list=bonding&launchpad=standard_reserve` for tokens on their curves and `list=graduated&launchpad=standard_reserve` for graduations. The launchpad id is `standard_reserve`, with an underscore. **Why are King of the Markets tokens priced in stock tokens?** Each curve is denominated in one listed stock token: SPCX, BABA or SKHY. Buyers can pay with ETH or USDG through the LaunchRouter, which converts to the stock in the same transaction. Crius reports `quote` as the stock and converts `price_usd` through the stock token's own pools. **When does a King of the Markets token graduate?** When its curve sells its last tokens. The buy that empties the curve triggers `Graduated` on the LaunchFactory, and the token moves into a Uniswap v4 pool (fee 0, tick spacing 200, hook LaunchHook) whose id was fixed at launch. The liquidity is locked permanently. Of 2,193 launches, 22 had graduated when the samples were captured. **What fees does King of the Markets charge?** A 1% base fee on curve and pool trades (30% of it to the creator through the FeeEscrow, 70% to the protocol's Safe), an optional creator tax of up to 5% that can only be lowered, and a snipe fee on curve buys that starts at 99% and is gone after 7 seconds. ## Related [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Guide **Track bonding & graduating tokens** Track Pons, Flap and other Robinhood Chain launchpad tokens on their bonding curves, see which are closest to graduating and catch each graduation. Read](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/) [Guide **Get launchpad stats** Launches, graduations, graduation rate, time to graduate, volume, traders and fees for every Robinhood Chain launchpad, with daily history. Real responses. Read](https://docs.crius.sh/guides/get-launchpad-stats/) [Guide **Get fees & creator rewards** See every fee paid around a Robinhood Chain token (gas, LP, hook, creator tax, curve, token tax), who receives it and what is still unclaimed. Real response. Read](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/) [Launchpad **Flywheel** How Flywheel launches tokens into Uniswap v4 pools with a 4% hook tax on Robinhood Chain, how graduation works, its contracts and the Crius API calls. Read](https://docs.crius.sh/launchpads/flywheel/) [API reference **Launchpads API** Every supported launchpad with its live stats: launches, graduations and volume. Read](https://docs.crius.sh/reference/launchpads/launchpads/) --- # Trader attribution & wallet tags > How Crius attributes Robinhood Chain trades to the real trader behind routers, aggregators, bundlers and bot contracts, and what each wallet tag means. Source: https://docs.crius.sh/concepts/attribution/ · Updated 2026-10-28 ## Who actually traded On-chain, the address that sends a transaction (`tx.from`) or calls the pool is often infrastructure: a router, an aggregator, a Relay solver, an ERC-4337 bundler, a launchpad’s launch-and-buy helper, Permit2, or a trading bot’s contract. Counting those as traders would make every stat wrong. For each swap Crius: 1. computes every address’s net token and quote change in the transaction (including internal ETH transfers); 2. removes known infrastructure (pools, the v4 PoolManager, routers, aggregators, Permit2, vaults, lockers, launchpads); 3. takes the address that **received** the token (buy) or **sent** it (sell) as the **trader**; 4. for ERC-4337, uses the smart account as trader and the bundler as `executor`; 5. for Relay and other gasless flows, uses the user whose funds moved, with the solver as `executor`; 6. for bot contracts, uses the contract as trader and tags it `bot`. One transaction can contain several trades (a multi-recipient buy, an arbitrage). Each trade has its own `id` (`--`). ## Wallet tags | Tag | Meaning | | --- | --- | | `dev` | The token’s deployer or launch creator | | `dev_linked` | Funded by or funding the dev, or in the same cluster | | `sniper` | Bought within the first blocks after trading opened | | `bundler` | Part of a coordinated bundle | | `fresh` | A new wallet (under 24 h old or under 5 transactions before its first buy) | | `insider` | Received tokens from the dev or launch contract without buying | | `whale` | Holds 1% or more of supply | | `bot` | Trades through its own contract, or trades like a bot (very frequent, sub-second round trips, same-block buy and sell) | | `top_trader` | Among the best traders by realized PnL | | `pool`, `lp_locker`, `burn`, `launchpad`, `protocol_fee`, `cex`, `bridge` | Infrastructure, excluded from concentration stats by default | Use `exclude=infra` or `exclude=bots` on holder and stats endpoints to leave those wallets out. --- # Finality & reorgs > Finality levels on Robinhood Chain (latest, safe, finalized), how the Crius API marks them, and how chain reorganizations are handled in REST and WebSocket. Source: https://docs.crius.sh/concepts/finality/ · Updated 2026-10-28 Every event Crius returns (trades, transfers, liquidity changes) carries a `finality`: | Level | When | Typical delay | | --- | --- | --- | | `latest` | Included by the Robinhood Chain sequencer | under a second | | `safe` | The batch containing it has been posted to Ethereum | minutes | | `finalized` | Ethereum has finalized that batch | about 15–20 minutes more | Every response’s `meta` reports the current `safe_block` and `finalized_block`, so you can tell the level of anything by its block. ## Reorgs Sequencer-ordered blocks are very rarely replaced, but it can happen. When it does: - **REST** responses simply reflect the new chain: replaced events disappear and new ones appear. - **WebSocket** clients receive a `reorg` message (`common_ancestor`, `removed_blocks`, `depth`), then every affected event again with `"removed": true` and the same `id`, then the replacement events. Undo what you did for removed events by `id`. If your application can’t handle reversals (accounting, payouts), only act on `safe` data: filter by `finality=safe` where an endpoint supports it, or subscribe to the stream with `"finality": "safe"`, which holds each event until its block is safe. --- # Holder classes on Robinhood Chain: infrastructure, bots, snipers, whales and smart accounts > How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Source: https://docs.crius.sh/concepts/holder-classes/ · Updated 2026-10-28 Not every address that holds a token is a holder. On a typical Robinhood Chain token most of the supply sits in Uniswap v4’s PoolManager, an LP locker and a burn address, and many active “wallets” are router or bot contracts. Crius classifies every address into **infrastructure** (contracts that hold tokens on behalf of a market or nobody) and **holders** (people, including smart accounts), then adds tags such as `dev`, `sniper` and `whale` to holders. Concentration stats count holders only, so `top10_pct` describes who really owns the supply. ## Who holds a token Example [Free plan · 2 credits](https://docs.crius.sh/reference/holders/live-holders/) ### CHARGE's top five real holders, infrastructure left out Who are the largest holders of Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8), and which of them are real holders? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5&exclude=infra", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 67 lines (arrays trimmed)** ```json { "data": { "balances": "verified_onchain", "count": 178, "distribution": { "top10_pct": 13.436 }, "history": "complete", "holders": [ { "address": "0x1860e8b874ed7742ae5459af731687ecb576c9fd", "balance": 28729479.389247917189540117, "label": null, "pct": 2.87295, "rank": 1, "value_eth": 0.0474081, "value_usd": 111.806 }, { "address": "0x346f5777f5652bd561dcd830e638bc40d3e1cf3d", "balance": 25566954.227971953484331514, "label": null, "pct": 2.5567, "rank": 2, "value_eth": 0.0421894, "value_usd": 99.4981 }, { "address": "0xa975e46d6552fb0ef85f7e9f7b640a058dc368bd", "balance": 23260835.335709034922247096, "label": null, "pct": 2.32608, "rank": 3, "value_eth": 0.038384, "value_usd": 90.5235 }, { "address": "0xf4e322c50010e00878b8d6bbb2c495d90097e58f", "balance": 19090692.939108585371870819, "label": null, "pct": 1.90907, "rank": 4, "value_eth": 0.0315026, "value_usd": 74.2947 }, { "address": "0x8e6be350c1276d3276cead49859aa435d77ac9eb", "balance": 12214695.452807030766083489, "label": null, "pct": 1.22147, "rank": 5, "value_eth": 0.0201561, "value_usd": 47.5356 } ], "ledger_reliable": true }, "meta": { "block": 100436633, "block_age_ms": 414, "block_ts": 1793228150000, "chain": "robinhood", "finalized_block": 100427397, "lag_ms": 17, "safe_block": 100431079 } } ``` What this tells you - With `exclude=infra`, the Uniswap v4 PoolManager, the Pons launch locker and the burn address are left out, so the list starts with real holders. - Ranks 1 and 2 (`0x1860e8b874ed7742ae5459af731687ecb576c9fd` at `pct: 2.87295`, `0x346f5777f5652bd561dcd830e638bc40d3e1cf3d` at `pct: 2.5567`) and the three after them all have `label: null`: ordinary wallets. - `distribution.top10_pct: 13.436` counts holders only, across `count: 178` holders. [Live holders reference](https://docs.crius.sh/reference/holders/live-holders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20top%20five%20real%20holders%2C%20infrastructure%20left%20out&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Fholder-classes%2F%23live-holders%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fholders%3Flimit%3D5%26exclude%3Dinfra%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Without `exclude=infra`, the live list keeps infrastructure rows with their `label`, so you can draw them differently. The [holder snapshot](https://docs.crius.sh/reference/holders/holder-snapshot/) gives both shares: for CHARGE at block 94616288, `top10_incl_infra_pct` is 88.256 and `top10_ex_infra_pct` is 20.2394. ## The classes **Infrastructure** never counts as a holder. These tags are left out of concentration stats and the bubble map: | Tag | What it is | | --- | --- | | `pool` | A Uniswap v2 pair, a v3 pool, or the v4 PoolManager that holds every v4 pool's tokens | | `lp_locker` | An LP locker or vesting contract (the Pons launch locker, UNCX, Team Finance and others) | | `burn` | `0x0000000000000000000000000000000000000000`, `0x000000000000000000000000000000000000dead` and any address with 17 or more zero bytes out of 20, such as `0xdead000000000000000000000000000000000000` | | `launchpad` | A launchpad's contracts, including its v4 hook (the Pons hook is `pons_v2_meme_hook`) | | `hook` | Any other Uniswap v4 hook: hooks hold the fees and taxes they take from swaps | | `router` | Routers and aggregators | | `protocol_fee` | Protocol fee receivers | | `contract` | Any other program contract (a bot, vault or game): a deployed contract with more than 300 bytes of code | | `exchange`, `cex`, `bridge` | Labeled exchange and bridge wallets | **Holder tags** describe a real holder in the context of one token: | Tag | Meaning | | --- | --- | | `dev` | The token's launch creator or its verified deployer | | `sniper` | Bought within the first 10 blocks after the token's first trade | | `whale` | Holds 1% or more of total supply and is not infrastructure | | `smart_account` | An EIP-7702 account: an ordinary wallet whose code delegates to a contract. Always a holder, never infrastructure | | App id, e.g. `fomo` | A smart account whose delegate contract belongs to a known app | The difference between a contract and a smart account matters. An EIP-7702 account’s code is only a 23-byte pointer to its delegate, and Safe or ERC-4337 account proxies are under 200 bytes, so they stay wallets. A trading bot’s own contract is far larger and is tagged `contract`. Trade-level tags (`bundler`, `fresh`, `insider`, `bot`) are explained on the [attribution page](https://docs.crius.sh/concepts/attribution/#wallet-tags). Example [Starter plan · 10 credits](https://docs.crius.sh/reference/wallet-graph/bubble-map/) ### A bubble map with the infrastructure moved aside Who are the real top holders of sockets (0xddccd4690cc99cf19d2e0bdbcb390d17e913958a), and are they linked? GET/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xddccd4690cc99cf19d2e0bdbcb390d17e913958a/bubblemap?top=50", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 138 lines (arrays trimmed)** ```json { "data": { "block": null, "clusters": [], "edges": [], "hidden_infra": [ { "address": "0x8366a39cc670b4001a1121b8f6a443a643e40951", "label": "uniswap_v4_pool_manager", "pct": 22.2145, "tags": [ "pool" ] }, { "address": "0x267444d099b10fb5ed7c3cc7b7c767adca574952", "label": "pons_v2_launch_locker", "pct": 8.16327, "tags": [ "lp_locker" ] }, { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "label": "pons_v2_meme_hook", "pct": 6.06241, "tags": [ "launchpad" ] }, { "address": "0xbe0b139abc90723af76a89d3051f60ba1b64c8d9", "label": null, "pct": 1, "tags": [ "contract" ] }, { "address": "0xdead000000000000000000000000000000000000", "label": null, "pct": 0.81637, "tags": [ "burn" ] }, { "address": "0x0afeb98a5b40bc38e9cf5a3f202c17843a7ce553", "label": null, "pct": 0.168848, "tags": [ "contract" ] } ], "nodes": [ { "cluster": null, "id": "0xe1a5961d61200006577f2e96114d212889213cd6", "label": null, "pct": 2.82829, "tags": [ "smart_account", "whale" ], "value_usd": 1286.54 }, { "cluster": null, "id": "0xa4109b8d391723d8f6bcfc5d75e6996f61062f76", "label": null, "pct": 2.70423, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1230.11 }, { "cluster": null, "id": "0xf2caeb616fb22a8acc00afbaeee83b24f18b354b", "label": null, "pct": 2.23269, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 1015.61 }, { "cluster": null, "id": "0xb9b642020e216e84887ad414e067928e380bbbd5", "label": null, "pct": 1.77186, "tags": [ "whale" ], "value_usd": 805.992 }, { "cluster": null, "id": "0xc9cafef2258a07f8455da92438360318b34848e2", "label": null, "pct": 1.73578, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 789.58 }, { "cluster": null, "id": "0xc51c3340b898a67fed7c9f18db75b346dd04f8a0", "label": null, "pct": 1.63331, "tags": [ "smart_account", "fomo", "whale" ], "value_usd": 742.968 } ], "token": "0xddccd4690cc99cf19d2e0bdbcb390d17e913958a" }, "meta": { "block": 100406890, "block_age_ms": 885, "block_ts": 1793225087000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 30, "safe_block": 100401329 } } ``` What this tells you - `hidden_infra` holds what isn’t a holder: the PoolManager (`pct: 22.2145`, tag `pool`), the Pons launch locker (`pct: 8.16327`, `lp_locker`), the Pons hook `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` (`pct: 6.06241`, `launchpad`), two program contracts (`contract`) and the burn address `0xdead000000000000000000000000000000000000` (`pct: 0.81637`, `burn`). - The first node, `0xe1a5961d61200006577f2e96114d212889213cd6`, holds `pct: 2.82829` and is tagged `smart_account` and `whale`. - Four of the six nodes shown also carry `fomo`: smart accounts created by that app, for example `0xa4109b8d391723d8f6bcfc5d75e6996f61062f76` at `pct: 2.70423`. - `clusters: []` and `edges: []`: no funding or transfer links among these holders. [Bubble map reference](https://docs.crius.sh/reference/wallet-graph/bubble-map/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20bubble%20map%20with%20the%20infrastructure%20moved%20aside&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Fholder-classes%2F%23bubble-map%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xddccd4690cc99cf19d2e0bdbcb390d17e913958a%2Fbubblemap%3Ftop%3D50%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Where the classes apply - **`/holders`** lists every address with its `label`; `exclude=infra` drops infrastructure rows, and `distribution.top10_pct` counts holders only either way. - **`/holders/snapshot`** puts `tags` on each row and returns both `top10_ex_infra_pct` and `top10_incl_infra_pct`. `exclude=infra` drops infrastructure rows. - **`/holders/cohort`** and **`/holders/history`** take `exclude=infra` too, so cohorts and holder counts aren’t padded by pools and lockers. - **`/traders`** filters on tags: `tag=smart_account` for smart accounts only, `exclude=dev,sniper,exchange` for outside traders. Program contracts are left out unless you pass `include_contracts=true`, and `exclude=bots` drops wallets labeled as bots. - **`/bubblemap`** moves infrastructure to `hidden_infra`; `include=infra` brings it back. - **`/security`** and **`/bundles`** use the same 10-block sniper window for `sniper_supply_pct`. ## Use it in your app 1. **Never rank infrastructure.** Show pools, lockers and burn addresses in a separate group, or drop them with `exclude=infra` where the endpoint takes it. 2. **Read tags, not labels.** `label` is a name for display (`uniswap_v4_pool_manager`, `pons_v2_launch_locker`); `tags` are the stable classes you filter on. 3. **Flag the dev and the snipers.** A `dev` or `sniper` among the top holders is the first thing a trader wants to know. ```python import requests # Top traders of a token, without the dev, snipers and exchanges (Free plan key). r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders", params={"sort": "pnl", "window": "all", "exclude": "dev,sniper,exchange", "limit": 20}, headers={"x-api-key": API_KEY}, ) for t in r.json()["data"]: print(t["rank"], t["address"], t["pnl_usd"], ",".join(t["tags"]) or "-") ``` ## Frequently asked questions **Why is the Uniswap PoolManager the biggest holder of my token?** All Uniswap v4 pools live inside one contract, the PoolManager (`0x8366a39cc670b4001a1121b8f6a443a643e40951` on Robinhood Chain), so the tokens in every v4 pool of your token sit at that address. Crius labels it `uniswap_v4_pool_manager`, tags it `pool` and leaves it out of `top10_pct` and other concentration stats. **What is a smart account on Robinhood Chain?** A wallet whose code delegates to a contract under EIP-7702. It is still a user's wallet, so Crius counts it as a holder and tags it `smart_account`; the wallet profile shows `account_type: "smart_account"` and the `delegate` contract. When the delegate belongs to a known app, the app's id is added as a tag (for example `fomo`). **How does Crius decide a wallet is a sniper?** A wallet is tagged `sniper` on a token when it bought within the first 10 blocks after the token's first trade. On Robinhood Chain 10 blocks is about one second. The bundles endpoint lets you change the window with `window_blocks`. **Is the whale tag based on USD value?** No. `whale` means the address holds 1% or more of the token's total supply and is not infrastructure: a pool, locker, hook or burn address holding 1% is never a whale. **Are exchange wallets counted as holders?** No. Exchange and bridge wallets are treated as infrastructure. One exchange deposit wallet holds many customers' tokens, and linking wallets through it would join unrelated people into one cluster. ## Related [Guide **Token holders** Robinhood Chain token holders API: get any token's top holders in one call, with balance, share of supply, USD value, labels, holder count and top-10 share. Read](https://docs.crius.sh/guides/get-token-holders/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Concept **Trader attribution & wallet tags** How Crius attributes Robinhood Chain trades to the real trader behind routers, aggregators, bundlers and bot contracts, and what each wallet tag means. Read](https://docs.crius.sh/concepts/attribution/) [API reference **Live holders API** The current holder list, ranked by balance, with each holder's share of supply, USD value and labels (pools, lockers, burn addresses, the dev). Read](https://docs.crius.sh/reference/holders/live-holders/) --- # Launch risk: snipers, insiders, wallet farms and uniform holders > How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Source: https://docs.crius.sh/concepts/launch-risk/ · Updated 2026-10-28 Launch risk is the risk that a token is controlled by a few people even though nothing in its contract says so. A renounced contract with locked liquidity can still be a pump and dump if insiders bought most of the supply in the first blocks, or spread it across hundreds of wallets they control. Crius looks for four patterns in every Robinhood Chain token’s launch and holders, and reports them in the `launch` object of [`/security`](https://docs.crius.sh/reference/security/security-checks/) and [`/bundles`](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/). ## The four patterns | Flag | What Crius looks for | Flagged when | Score | | --- | --- | --- | --- | | `insider_launch` | Supply bought in the first 10 blocks of trading (`sniper_supply_pct`, `sniper_top_wallet_pct`, `sniper_wallets`). | One wallet bought 50%+ of supply, or all snipers together 80%+. | −50, always `high` | | `wallet_farm` | Among the top 500 holders (infrastructure excluded, 100+ needed), how often each leading hex digit appears. Chance is 1 in 16 (6.25%). | One leading digit on 20%+ of those holders, and they hold 20%+ of supply. | −50, always `high` | | `uniform_holders` | Near-identical balances among the top 100 holders (within 5% of each other). | 25 or more holders with the same balance. | −30 | | `lp_single_wallet` | The wallet with the largest unlocked share of the token's liquidity, by USD across its pools (`lp_top_wallet`). | One wallet holds 40%+ of all the liquidity, unlocked. | −25 | **Snipers** are counted from the token’s first trade. Robinhood Chain makes a block about every 100 ms, so the 10-block window is roughly the first second of trading: too fast for anyone who saw the token appear. A large sniped share isn’t proof of insiders on its own: sockets had 6 snipers taking about 30% and is a clean token. A single wallet taking half the supply before anyone else could buy is. **Wallet farms** hide one holder behind many. When wallets are generated in bulk, their addresses often share a first character, and one character showing up on far more than 1 in 16 of the top holders, holding a fifth of the supply, is a pattern chance doesn’t produce. The `wallet_farm` object gives the `prefix`, `wallets`, `holders_examined`, `share_pct` against `expected_pct: 6.25`, and `supply_pct`. **Uniform holders** are many wallets with the same balance: bots buying a fixed size, or supply handed out in equal slices to controlled wallets. The `uniform_holders` object gives `holders`, `of_top` and `balance_pct` (the balance they share, as a share of supply). **LP control** is one wallet able to pull a large part of the market by withdrawing unlocked liquidity. See [Check if a token’s liquidity is locked](https://docs.crius.sh/guides/check-liquidity-locked/). Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Uniform holders: Let's End AI Let's End AI (0xc882f10529a5518ee3393af5a80e9ff00d38d44b) has over 12,000 holders. Are they real? GET/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xc882f10529a5518ee3393af5a80e9ff00d38d44b/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 140 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": "0x0000000000000000000000000000000000000000", "ownership": "renounced", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": true, "upgradeable": false, "verified": "none" }, "flags": [ "honeypot", "unverified", "uniform_holders" ], "honeypot": { "is_honeypot": true, "reason": "simulated sell failed", "selective": false }, "hook": null, "known_asset": false, "launch": { "flags": [ "uniform_holders" ], "lp_top_wallet": { "address": "0xabe3a51937eb4c76ab6449e9823dbffd4409776f", "liquidity_usd": 8.58651, "pct": 0.0253312 }, "sniper_supply_pct": 0.000299049, "sniper_top_wallet_pct": 0.000299049, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": { "balance_pct": 0.112731, "holders": 51, "of_top": 100 }, "wallet_farm": null }, "limits": { "max_tx": "1000000000", "max_tx_getter": "maxTxAmount()", "max_tx_pct": 100, "max_wallet": "1000000000", "max_wallet_getter": "maxWalletSize()", "max_wallet_pct": 100 }, "liquidity": { "status": "burned", "summary": { "burned_pct": 99.9715, "locked_pct": 0, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.0284848, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v2", "risk": "critical", "score": 0, "tax": { "buy_pct": 0, "confidence": "high", "realized": { "buy_pct": 0, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793224820000, "max_sell_pct_seen": 0, "samples": { "buys": 27197, "sells": 3423 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": { "amount_eth": 0.042454083286938696, "buy_gas": 159144, "buy_pct": 0, "can_buy": true, "can_sell": false, "can_transfer": true, "from": "eoa", "revert_reason": { "code": 3, "data": "0x08c379a0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000245472616e7366657248656c7065723a205452414e534645525f46524f4d5f4641494c454400000000000000000000000000000000000000000000000000000000", "message": "execution reverted: TransferHelper: TRANSFER_FROM_FAILED" }, "router": "0x89e5db8b5aa49aa85ac63f691524311aeb649eba", "sell_gas": 229228, "sell_pct": null, "transfer_pct": 0 }, "source": "realized", "transfer_pct": 0 }, "tax_history": [ { "from_block": 62239227, "pct": 0, "side": "buy" }, { "from_block": 62240181, "pct": 0, "side": "sell" } ], "tax_history_total": 2, "tax_mode": "static", "token": "0xc882f10529a5518ee3393af5a80e9ff00d38d44b" }, "meta": { "block": 100406838, "block_age_ms": 1257, "block_ts": 1793225081000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 14, "safe_block": 100401329, "simulation": "eth_simulateV1 via Uniswap V2 router at head" } } ``` What this tells you - `launch.uniform_holders`: `holders: 51` of `of_top: 100` hold the same balance, `balance_pct: 0.112731` of supply each. Half of the top 100 holders look like one buyer repeated. - `launch.flags: ["uniform_holders"]`, which adds `uniform_holders` to the token’s `flags` and costs 30 points. - `launch.sniper_supply_pct` is about 0.0003% with `sniper_wallets: 1`: the launch itself wasn’t sniped. Launch risk is about holders as much as about the first blocks. - `launch.wallet_farm: null`: no over-represented address prefix among the top holders. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Uniform%20holders%3A%20Let's%20End%20AI&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Flaunch-risk%2F%23uniform-holders%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xc882f10529a5518ee3393af5a80e9ff00d38d44b%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Where the numbers come from - **Infrastructure is excluded** from the holder checks: pools, the Uniswap v4 PoolManager, burn addresses and other labeled contracts aren’t holders, so they can’t make a token look concentrated or farmed. - **Known assets** (WETH, USDG, tokenized stocks) are skipped: they are issued and market-made from few wallets by design. - **Tokens Crius didn’t see from their first mint** have `sniper_supply_pct: null`: their launch isn’t in the indexed trades, so no sniper flag is set. - **`/bundles` adds the detail**: which wallets sniped, bundled buys, how the early buyers were funded and whether they still hold. Its `insider_launch` field is `true` for any of `insider_launch`, `wallet_farm` or `uniform_holders`. See [Detect bundled launches, snipers and insiders](https://docs.crius.sh/guides/detect-bundles-and-snipers/). ## Frequently asked questions **Can a token with a renounced contract and locked liquidity still be a rug?** Yes. If insiders bought most of the supply at launch, they can sell it into later buyers: no contract function is needed. That is what launch risk measures, and why `insider_launch` and `wallet_farm` make a token `high` risk whatever its score. **Doesn't the developer's first buy on a launchpad count as sniping?** It does count toward `sniper_supply_pct`, but a launchpad creator's first buy on the bonding curve is usually 20–40% of the supply, below the 50% one-wallet threshold. A token is flagged only when one wallet takes half the supply or all snipers together take 80%. **How fresh are the launch-risk flags?** They are recomputed at most every 10 minutes per token. Sniper numbers come from the launch and don't change; wallet-farm, uniform-holder and LP checks follow the current holders and liquidity. ## Related [Guide **Detect bundles & snipers** Find out who bought a Robinhood Chain token's launch, how much of the supply snipers and bundles took and whether they still hold it, with a real insider launch that fell 97%. Read](https://docs.crius.sh/guides/detect-bundles-and-snipers/) [Guide **Read a bubble map** Get a Robinhood Chain token's top holders as a graph, with the funding and transfer links that group them. Real examples, with and without clusters. Read](https://docs.crius.sh/guides/read-a-bubble-map/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [API reference **Snipers, bundles & clusters API** Snipers (bought within the first blocks after trading opened), bundles, funding clusters and the share of supply they hold. Read](https://docs.crius.sh/reference/wallet-graph/snipers-bundles-clusters/) --- # Launchpads > How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Source: https://docs.crius.sh/concepts/launchpads/ · Updated 2026-10-28 A **launchpad** lets anyone create a token in one transaction. Most start trading on a **bonding curve**: the launchpad contract sells tokens at a price that rises with each buy, against a quote asset (usually ETH). When the curve raises enough, the token **graduates**: the launchpad moves the raised liquidity into a Uniswap pool, often locking or burning the LP position, and trading continues on the DEX. ## Supported launchpads Crius attributes tokens to their launchpad automatically from the factory that created them. Live stats for each are at [`GET /v1/robinhood/launchpads`](https://docs.crius.sh/reference/launchpads/launchpads/). | Id | Name | Model | | --- | --- | --- | | `pons` | Pons | Bonding curve that graduates into a Uniswap v4 pool with the Pons hook; the LP is locked permanently | | `flap` | [Flap.sh](https://flap.sh) | Bonding-curve launchpad | | `bankr` | [Bankr](https://bankr.bot) | Token launches from the Bankr agent | | `long` | [Long.xyz](https://long.xyz) | Token launch platform | | `flywheel` | [Flywheel](https://flywheel.cash) | Launches straight into a Uniswap v4 pool whose hook takes a 4% swap tax for holder rewards, burns and the platform; graduates when the pool’s liquidity reaches its target | | `standard_reserve` | [King of the Markets (Standard Reserve)](https://www.standardreserve.xyz) | Launch competition platform | Tokens from factories we haven’t attributed yet are reported with `creation.attribution` other than `known_launchpad`, and `/launch` returns `meta.attribution = "unattributed_factory"`. ## Lifecycle in the API - `launch.status`: `bonding` while on the curve, `graduated` after migration. - `launch.progress_pct`: how far along the curve the token is (100 when graduated). - `launch.curve`, `launch.launched_block`, `launch.graduated_block`, `launch.graduation_threshold`. - The token’s market (price, liquidity, candles) follows it from the curve into its pool without a break: candles for a launchpad token include the curve history by default. Stream new launches with the `launches:all` (or `launches:pons`, …) channel and graduations with `graduations:all` on the [WebSocket](https://docs.crius.sh/reference/stream/). --- # How trader and wallet PnL is computed on Robinhood Chain > How the Crius API computes realized and unrealized PnL, ROI, cost basis and win rate for Robinhood Chain traders and wallets, worked through on real trades. Source: https://docs.crius.sh/concepts/pnl/ · Updated 2026-10-28 Crius computes PnL with the **average-cost method** on the trade tape: every buy and sell is valued in USD at the moment it happened, the tokens sold are charged at the average price paid for all tokens bought, and what is still held is valued at the current price. Realized PnL is what the sells made over that cost; unrealized PnL is the current value of the balance over its cost. Top traders of a token, a wallet’s profile, holder snapshots and holder cohorts all use the same rules. ## A trader’s PnL, worked through Example [Free plan · 5 credits](https://docs.crius.sh/reference/holders/top-traders/) ### CHARGE's top three traders by PnL Who made the most on Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8), and how is their PnL calculated? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/traders?limit=3", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 91 lines (arrays trimmed)** ```json { "data": [ { "address": "0x9e38fedc40987c19396cc20ea59eb2b1b7928881", "avg_buy_usd": 0.00000842823, "avg_sell_usd": 0.0000532304, "balance": 0, "bought": 29080767.335830362668108408, "bought_eth": 0.099, "bought_usd": 245.099, "buys": 1, "cost_basis": "complete", "first_trade_ts": 1791983208000, "gas_spent_usd": 0.0875722, "holding_time_s": 118676, "last_trade_ts": 1792101884000, "pnl_usd": 1302.88, "rank": 1, "realized_pnl_usd": 1302.88, "roi_pct": 531.573, "sells": 7, "sold": 29080767.335830362668108408, "sold_eth": 0.635695, "sold_usd": 1547.98, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x7c79ad74d36dea424d08a5d326271bf03da81f6a", "avg_buy_usd": 0.00000790248, "avg_sell_usd": 0.0000343631, "balance": 0, "bought": 46475393.982901663958413733, "bought_eth": 0.1485, "bought_usd": 367.271, "buys": 2, "cost_basis": "complete", "first_trade_ts": 1791983183000, "gas_spent_usd": 0.0712204, "holding_time_s": 125872, "last_trade_ts": 1792109055000, "pnl_usd": 994.45, "rank": 2, "realized_pnl_usd": 994.45, "roi_pct": 270.767, "sells": 4, "sold": 37582304.39247174197236032, "sold_eth": 0.528147, "sold_usd": 1291.44, "tags": [], "unrealized_pnl_usd": 0 }, { "address": "0x83055f3e7be4e289733bbc8c7bd42a6443177f07", "avg_buy_usd": 0.000023621, "avg_sell_usd": 0.0000471805, "balance": 0, "bought": 35569497.20243776424709037, "bought_eth": 0.3465, "bought_usd": 840.189, "buys": 3, "cost_basis": "complete", "first_trade_ts": 1791988168000, "gas_spent_usd": 0.0631376, "holding_time_s": 4039, "last_trade_ts": 1791992207000, "pnl_usd": 838, "rank": 3, "realized_pnl_usd": 838, "roi_pct": 99.7395, "sells": 3, "sold": 35569497.20243776424709037, "sold_eth": 0.691944, "sold_usd": 1678.19, "tags": [], "unrealized_pnl_usd": 0 } ], "meta": { "block": 100406823, "block_age_ms": 829, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 64, "next_cursor": "3", "pnl_method": "average cost; USD at trade time; unrealized at current price", "safe_block": 100401329, "window": "all" } } ``` What this tells you - Rank 1, `0x9e38fedc40987c19396cc20ea59eb2b1b7928881`: one buy of 29,080,767 CHARGE for `bought_usd: 245.099`, then seven sells of all of it for `sold_usd: 1547.98`. Realized PnL is 1,547.98 − 245.099 = `realized_pnl_usd: 1302.88`, and `roi_pct: 531.573` is 1,302.88 ÷ 245.099. - Rank 2, `0x7c79ad74d36dea424d08a5d326271bf03da81f6a`: bought 46,475,393 tokens for $367.271 (`avg_buy_usd: 0.00000790248`) and sold 37,582,304 of them for $1,291.44. The sold tokens cost 37,582,304 × 0.00000790248 ≈ $296.99, so `realized_pnl_usd` is 994.45. - Rank 2 also has `balance: 0` although it sold only part of what it bought. The other 8.9 million tokens left the wallet without a sale (a transfer), so they count neither as a sale nor as a loss. - `gas_spent_usd` (0.0875722 for rank 1) is reported separately and not subtracted from `pnl_usd`. - `cost_basis: "complete"` on all three: every token they sold was bought, so the numbers are exact. [Top traders reference](https://docs.crius.sh/reference/holders/top-traders/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE's%20top%20three%20traders%20by%20PnL&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Fpnl%2F%23top-traders%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Ftraders%3Flimit%3D3%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## The formulas For one wallet and one token over the window (`bought` and `sold` in tokens, `bought_usd` and `sold_usd` at trade time): | Field | How it is computed | | --- | --- | | `avg_buy_usd` | `bought_usd ÷ bought`: the average cost of one token | | `realized_pnl_usd` | `sold_usd − min(sold, bought) × avg_buy_usd` | | `unrealized_pnl_usd` | Current value of `balance` − `min(balance, bought − sold) × avg_buy_usd` | | `pnl_usd` | `realized_pnl_usd + unrealized_pnl_usd` | | `roi_pct` | `pnl_usd ÷ bought_usd × 100` | | `holding_time_s` | From the first trade to now while the wallet still holds the token, otherwise from the first trade to the last | - **USD at trade time.** Each trade’s `value_usd` is the quote amount times the quote’s USD price at that block. ETH-quoted trades use that block’s ETH/USD (`eth_usd_at_trade` on the trade tape). Later price moves never change a past trade’s value. - **Current value.** The balance is valued at the token’s [current price](https://docs.crius.sh/concepts/token-prices/), capped at what the price pool’s quote side could pay out. Ten million tokens in a pool holding $50 of ETH are never worth more than $50. - **Windows.** `/traders` takes `window=1h`, `24h`, `7d` or `all` (the default); the wallet profile takes `1d`, `7d`, `30d` (the default) or `all`. Only trades inside the window count. ## When PnL is unknown When a wallet **sold more than it bought**, the extra tokens came from somewhere else (a transfer, an airdrop, a launch allocation) and their cost is unknown. Crius doesn’t guess: `cost_basis` says `"unknown (sold tokens received by transfer)"`, `realized_pnl_usd`, `unrealized_pnl_usd`, `pnl_usd` and `roi_pct` are `null`, and the row sorts last when you rank by PnL. Tokens received by transfer and **still held** are different: they are part of the balance, valued at the current price, with no cost against them, so they show up as unrealized gain. A dev wallet holding its launch allocation is the common case. Use the `dev` tag and `exclude=dev` when you rank traders (see [holder classes](https://docs.crius.sh/concepts/holder-classes/)). ## Wallet PnL The [wallet profile](https://docs.crius.sh/reference/wallets/wallet-profile/) applies the same per-token formulas to every token the wallet traded in the window and adds them up. Tokens with an unknown cost are left out of the totals. | `pnl` field | Meaning | | --- | --- | | `realized_usd`, `unrealized_usd`, `total_usd` | Sums over the tokens with a known cost | | `win_rate_pct` | Share of those tokens with a positive total PnL (per token, not per trade) | | `tokens_traded`, `tokens_with_known_cost` | How many tokens the wallet traded, and how many the totals cover | | `best_trade`, `worst_trade` | The token with the highest and lowest total PnL | | `gas_spent_usd`, `gas_scope` | Gas for all transactions the wallet sent in the window, trades or not | | `avg_hold_time_s` | Average time from first to last trade per token | Example [Starter plan · 5 credits](https://docs.crius.sh/reference/wallets/wallet-profile/) ### A creator wallet with no trades in 30 days What did CHARGE's creator wallet (0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca) make or lose in the last 30 days? GET/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/wallet/0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 84 lines (arrays trimmed)** ```json { "data": { "account_type": "smart_account", "address": "0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca", "delegate": "0x63c0c19a282a1b52b07dd5a65b58948a07dae32b", "holdings": [ { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0xfaaf8ffa8a29ceb6c85aff8d3961f65ae1bfc775", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500064, "value_usd": 0.0117789 }, { "balance": 25, "pnl": null, "price_confidence": "low", "token": { "address": "0x06993ae1230d3755b54f25022028daa66772bc3d", "logo": null, "symbol": "USDG" }, "value_eth": 0.00000500061, "value_usd": 0.0117789 } ], "holdings_truncated": false, "holdings_value_usd": 0.0235578, "is_contract": false, "label": null, "native_balance": 0.71473787532832551, "native_value_usd": 1683.56, "pnl": { "avg_hold_time_s": null, "best_trade": null, "gas_scope": "all transactions sent by the wallet in the window", "gas_spent_usd": 0.198772, "realized_usd": 0, "tokens_traded": 0, "tokens_with_known_cost": 0, "total_usd": 0, "trades": 0, "unrealized_usd": 0, "volume_usd": 0, "win_rate_pct": null, "window": "30d", "worst_trade": null }, "profile": { "first_seen_block": 91351250, "first_seen_ts": 1792283372000, "fresh": false, "funded_by": { "address": "0xd782268f600403843484b70710daee6846fc0db8", "amount_eth": 0.008148386337868892, "block": 87601233, "label": "bridge:Relay solver", "ts": 1791903516300 }, "history": "complete", "tags": [ "dev", "smart_account" ], "tx_count": 14, "wallet_age_days": 10.8994 } }, "meta": { "balances_block": 100406864, "block": 100406864, "block_age_ms": 1301, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 59, "safe_block": 100401329 } } ``` What this tells you - `pnl.window: "30d"` is the default window. `trades: 0` and `tokens_traded: 0`: the wallet made no trades in it, so `realized_usd`, `unrealized_usd` and `total_usd` are 0. - `win_rate_pct`, `best_trade`, `worst_trade` and `avg_hold_time_s` are `null`: with no tokens traded there is nothing to rate. - `gas_spent_usd: 0.198772` is still counted, because `gas_scope` is “all transactions sent by the wallet in the window”, not only trades. - Each holding has `pnl: null` here: neither of the two tokens it holds was traded in the window. [Wallet profile reference](https://docs.crius.sh/reference/wallets/wallet-profile/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20creator%20wallet%20with%20no%20trades%20in%2030%20days&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Fpnl%2F%23wallet-pnl%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fwallet%2F0x3ac82d45ff9e4963cefbc3f74dbe293f34c927ca%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Holder endpoints use the same cost basis. The [holder snapshot](https://docs.crius.sh/reference/holders/holder-snapshot/) adds `cost_basis_usd` and `unrealized_pnl_usd` to each holder at the snapshot’s price, and the [holder cohort](https://docs.crius.sh/reference/holders/holder-cohort/) adds `pnl_usd` to each wallet that held through the window. ## Use it in your app 1. **Rank outside traders.** `/traders?sort=pnl&window=7d&exclude=dev,sniper` gives the best traders of the week who neither created nor sniped the token. 2. **Show the basis.** Next to a PnL number, show `bought_usd`, `sold_usd` and `cost_basis`, so users can see what it rests on. 3. **Subtract gas if your users care.** `pnl_usd − gas_spent_usd` is the net result after fees paid to the chain. ```js // Net PnL of a token's top traders this week, outside traders only (Free plan key). const url = `https://api.crius.sh/v1/robinhood/token/${token}/traders?sort=pnl&window=7d&exclude=dev,sniper&limit=10`; const { data } = await (await fetch(url, { headers: { "x-api-key": process.env.CRIUS_API_KEY } })).json(); for (const t of data) { if (t.pnl_usd === null) continue; // cost unknown: tokens arrived by transfer const net = t.pnl_usd - (t.gas_spent_usd ?? 0); console.log(t.rank, t.address, `pnl $${t.pnl_usd}`, `net $${net.toFixed(2)}`, `roi ${t.roi_pct}%`); } ``` ## Frequently asked questions **Does Crius PnL include gas?** No. PnL is computed from the USD value of the trades. Gas is reported next to it as `gas_spent_usd` so you can subtract it yourself: per token on `/traders`, and for every transaction the wallet sent in the window on the wallet profile. **Is PnL FIFO or average cost?** Average cost. Every token bought costs the average USD price of all the wallet's buys of that token, so the order of buys and sells doesn't change the result. Each response says so in `meta.pnl_method` on `/traders`. **Why is a trader's PnL null?** The wallet sold more tokens than it bought: the extra tokens arrived by transfer, airdrop or launch allocation, so their cost is unknown. Those rows have `cost_basis: "unknown (sold tokens received by transfer)"` and `null` PnL, and they sort last when you rank by PnL. **Is the wallet win rate per trade?** Per token. `win_rate_pct` is the share of tokens with a known cost whose total PnL (realized + unrealized) is positive in the window. Ten losing trades and one big winning trade on the same token count as one win if the token's total PnL is positive. **Which trades count toward a wallet's PnL?** The trades attributed to it as the trader: the address whose balance changed, not the router, solver or ERC-4337 bundler that sent the transaction. See trader attribution. ## Related [Guide **Top traders & PnL** Rank the traders of any Robinhood Chain token by PnL, volume, buys or ROI, with wallet tags, gas and hold time. A real example with the PnL math explained. Read](https://docs.crius.sh/guides/get-top-traders-pnl/) [Guide **Wallet holdings & PnL** Get a Robinhood Chain wallet's tokens with USD value, ETH balance, realized and unrealized PnL, win rate, gas spent and wallet tags in one call. Real example. Read](https://docs.crius.sh/guides/get-wallet-pnl-and-holdings/) [Guide **Diamond-hand holders** Find wallets that bought a Robinhood Chain token early and held through the run, with hold time, entry market cap, sells and PnL per wallet. Real example. Read](https://docs.crius.sh/guides/find-diamond-hand-holders/) [Concept **Trader attribution & wallet tags** How Crius attributes Robinhood Chain trades to the real trader behind routers, aggregators, bundlers and bot contracts, and what each wallet tag means. Read](https://docs.crius.sh/concepts/attribution/) [Concept **Token prices** How the Crius API prices Robinhood Chain tokens from on-chain pools, how the price pool is picked, and what confidence and thin\_liquidity mean. Read](https://docs.crius.sh/concepts/token-prices/) [API reference **Top traders API** Traders of the token ranked by PnL, realized PnL, volume, buys or ROI over a window (1h, 24h, 7d, all), with wallet tags: dev, sniper, whale, smart\_account (EIP-7702 wallets), the app for app wallets Read](https://docs.crius.sh/reference/holders/top-traders/) --- # Robinhood Chain > What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Source: https://docs.crius.sh/concepts/robinhood-chain/ · Updated 2026-10-28 **Robinhood Chain** is an Ethereum layer-2 network (an Arbitrum Orbit chain) with chain id **4663** (`0x1237`). Transactions are ordered by a sequencer and settled on Ethereum. | | | | --- | --- | | Chain id | `4663` | | Native gas token | ETH | | Block time | about 100 ms | | Official RPC | `https://rpc.mainnet.chain.robinhood.com` | | Explorers | [Robinhood Chain Etherscan](https://robin.etherscan.io), [Hoodscan](https://hoodscan.co) | ## Assets you’ll see everywhere | Symbol | Address | Role | | --- | --- | --- | | ETH | `0x0000000000000000000000000000000000000000` | Native gas token; quote asset of many pools and launch curves | | WETH | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` | Wrapped ETH (ERC-20) | | USDG | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` | Dollar stablecoin (6 decimals) | USD prices on Crius are derived from these on-chain pools: a token is priced against its deepest pool’s quote asset, and the quote asset is converted to USD through the deepest ETH/USDG pool. The addresses of the other main contracts (stock tokens, Uniswap v2, v3 and v4, launchpads, LP lockers, v4 hooks, bridges) are listed on [Robinhood Chain contract addresses](https://docs.crius.sh/contract-addresses/). ## Two block numbers Robinhood Chain blocks arrive every ~100 ms, but inside a smart contract `block.number` returns the **Ethereum L1 block** (about every 12 seconds). Contract rules written “per block” (anti-snipe windows, sell limits) therefore act on L1 blocks. Crius reports the L2 `block` everywhere and adds `l1_block` where it matters. ## Finality A transaction is visible as soon as the sequencer includes it (`latest`), becomes `safe` when its batch is posted to Ethereum, and `finalized` when Ethereum finalizes that batch. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/). ## How Crius indexes it Crius runs its own Robinhood Chain archive nodes and decodes every block as it arrives: transfers, swaps on every Uniswap version, launchpad events, LP locks, contract calls. State (prices, holders, pools) is kept in memory for fast answers; history is stored back to block one. Every response tells you the block it reflects (`meta.block`) and how far behind the head it is (`meta.lag_ms`, usually well under a second). --- # Security score: confidence and limitations > What the Crius security score can and can't see on Robinhood Chain, how to read its confidence fields, and why a low-risk result is not a guarantee a token is safe. Source: https://docs.crius.sh/concepts/security-score-limits/ · Updated 2026-10-28 Short answer The score only reports what was checked: a honeypot simulation (only for tokens with a Uniswap v2 WETH pair), taxes measured from real trades, contract code, LP locks Crius recognises, hook history and launch buyers. Read `tax.source`, `tax.confidence`, `tax.realized.samples` and `meta.simulation` to see how much evidence stands behind each answer. A `low` risk means no trap was found, not that none exists. [GET `/token/{address}/security`](https://docs.crius.sh/reference/security/security-checks/) [GET `/token/{address}/liquidity`](https://docs.crius.sh/reference/security/liquidity-locks/) [GET `/hook/{address}`](https://docs.crius.sh/reference/pools/hook-detail/) The security score is a summary of evidence, and every piece of evidence has limits. This page lists what each check can miss, which fields show how much evidence stands behind a result, and how to use the score without over-trusting it. Read it before you gate trades, listings or alerts on `risk` or `score`. A low risk result is not a safety guarantee `risk: "low"` and a high `score` mean Crius found no trap with the checks below. They don’t mean the token is safe to buy, that the price will hold, or that the team is honest. Most losses on new tokens come from insiders selling, not from contract traps, and some traps only turn on after you’ve bought. ## What each check can miss | Check | How it works | Can miss (false negatives) | | --- | --- | --- | | Honeypot simulation | `eth_simulateV1` buy → transfer → approve → sell from a fresh wallet through the Uniswap v2 router, at the current block, for `amount_usd` (default $100). | Tokens without a v2 WETH pair (v3 / v4 / curve only) are not simulated. Traps that whitelist fresh wallets, trigger later (time, block or trade count), depend on trade size, or block only certain wallets or contracts can pass. | | Realized honeypot rule | Flags 20+ buys with no successful sell by anyone but the developer. | A brand-new token with fewer than 20 buys can't be flagged by this rule yet. A trap that lets a few insider wallets sell to fake activity can pass. | | Realized taxes | The median of the latest 50 real trades per side in the last 30 days, compared with what the pool paid out. | A tax raised a minute ago only shows once new trades come in; a median hides a tax charged only on some trades (large sells, specific wallets). `max_sell_pct_seen` shows the worst single trade. | | Contract powers | Function selectors found in the token's code (and its implementation, for proxies): mint, blacklist, pause, tax changes, limits, self-destruct. | Powers behind renamed or obfuscated functions, or in another contract the token calls. An upgradeable proxy can change all of this later (it is flagged as `upgradeable_proxy`). | | Liquidity locks | LP held by burn addresses and by lockers Crius recognises (registry lockers and launchpad lock contracts). | A lock in a contract Crius doesn't know shows as held by that contract, so locks can be understated, not overstated. A lock can expire: check `next_unlock_ts`. | | Uniswap v4 hook | The hook's code, permissions, owner, its own pools' outcomes and its code family's history. | A new hook with no history gets `new_unknown`, not a verdict. Clean history doesn't stop an owner-controlled hook from changing behaviour later. | | Launch risk | Buyers in the first 10 blocks, wallet farms, uniform balances and LP concentration. | Insiders who fund wallets through exchanges, bridges or relayers look unrelated, and buyers after block 10 aren't counted as snipers. | ## How to read the confidence fields Every security response carries the evidence behind its answer. Check these before you trust a verdict: - **`tax.source`**: `realized` (measured from real trades), `realized+simulated` (measured, and the simulation agrees), `simulated` (no recent trades, simulation only) or `none` (neither: the tax is unknown, not zero). - **`tax.confidence`**: `high` with 20 or more measured trades, `medium` with 3 or more, `low` below that. A `low` confidence tax of 0% says little. - **`tax.realized.samples`**: how many buys and sells the realized numbers come from, and `max_sell_pct_seen`, the worst single sell. - **`meta.simulation`**: `eth_simulateV1 via Uniswap V2 router at head` when a simulation ran, or `no V2 WETH pair: realized tax only` when it couldn’t. - **`honeypot.reason`**: which check made the call (`simulated sell failed` or `buys but no successful sells by non-dev wallets`). - **`hook.observed`** and **`hook.family`**: how many traded pools the hook verdict rests on. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### Little evidence: a token with no simulation Recast (0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a) trades only on Uniswap v4. Which parts of its verdict are measured, and which are missing? GET/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 188 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "tax_over_5pct", "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x441568fdd10b00ddc90b4a95aee03d8d06242283", "liquidity_usd": 2.08528, "pct": 0.0195019 }, "sniper_supply_pct": 0.61622, "sniper_top_wallet_pct": 0.61622, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "locked", "summary": { "burned_pct": 0, "locked_pct": 99.9805, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.019502, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 80, "tax": { "buy_pct": 6.99, "confidence": "high", "realized": { "buy_pct": 6.99, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793223683000, "max_sell_pct_seen": 1, "samples": { "buys": 1107, "sells": 530 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 82850924, "pct": 0, "side": "buy" }, { "from_block": 82929088, "pct": 0, "side": "sell" }, { "from_block": 85677230, "pct": 1, "side": "buy" }, { "from_block": 85686101, "pct": 0, "side": "buy" }, { "from_block": 90626923, "pct": 7, "side": "buy" } ], "tax_history_total": 9, "tax_mode": "dynamic", "token": "0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a" }, "meta": { "block": 100406621, "block_age_ms": 400, "block_ts": 1793225060000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 10, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `tax.simulated: null` and `meta.simulation: "no V2 WETH pair: realized tax only"`: no buy-and-sell simulation ran, because the token has no v2 WETH pair. - `tax.source: "realized"` with `tax.confidence: "high"`: the 6.99% buy tax and 0% sell tax are measured from real trades (`tax.realized.samples`), so the tax answer is solid even without a simulation. - The honeypot verdict rests on the realized rule only: real wallets have sold, so it isn’t a honeypot for them. A trap that targets only some wallets would not show here. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Little%20evidence%3A%20a%20token%20with%20no%20simulation&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Fsecurity-score-limits%2F%23no-simulation%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xb656eadd009b3b409d7a0971e50df2f0e4ddef5a%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Timing: how fresh a result is - Results are cached for **15 seconds** per token and `amount_usd`. On paid plans, `fresh=1` skips the cache and simulates again at the current block (20 credits). - The simulation runs at the **current block** only. It says nothing about what the owner can switch on tomorrow; that is what the contract-power and proxy flags are for. - Realized taxes cover the **last 30 days**; older trades only appear in `tax_history`. - Every response’s `meta.block` tells you the block the answer was read at. Store it with any decision you make. ## Use the score safely 1. **Gate on `risk`, then read the evidence.** Block `critical` and `high`. For `low` and `medium`, check `tax.confidence` and `meta.simulation` before treating the tax as known. 2. **Treat missing evidence as unknown, not as safe.** `tax.source: "none"`, `tax.confidence: "low"` or no simulation on a token with few trades means “not enough data yet”, not “no tax”. 3. **Re-check before every trade on new tokens.** Taxes, LP locks and hook behaviour can change after launch. Re-call `/security` (or subscribe to `tax:` and `lp:` events on the [WebSocket stream](https://docs.crius.sh/reference/stream/)) instead of caching a verdict for hours. 4. **Size for being wrong.** Use the score to remove obvious traps, combine it with holder and launch data ([bundles and snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/), [holders](https://docs.crius.sh/guides/get-token-holders/)), and never risk more than you can lose on a token the checks can’t fully see. Found a token the score got wrong? Send the token address, the response’s `meta.block` and what happened to [support@crius.sh](mailto:support@crius.sh?subject=Security%20score%20miss). Misses are how the checks improve; every report is read. ## Frequently asked questions **Can a token with a score of 100 be a scam?** Yes. The score finds known trap mechanics on-chain. It can't see a team that abandons the project, a coordinated dump by wallets that look unrelated, a trap that turns on later, or a contract that treats some wallets differently from the ones the checks use. Treat the score as a filter that removes obvious traps, then size positions as if it could be wrong. **Why is \`tax.simulated\` null for my token?** The buy-and-sell simulation runs through the Uniswap v2 router, so it needs a v2 pool against WETH with liquidity. Tokens that trade only on Uniswap v3 or v4, or still on a launchpad curve, get no simulation; `meta.simulation` says `no V2 WETH pair: realized tax only` and the verdict rests on real trades alone. **How fresh is a security result?** Results are cached for 15 seconds per token and trade size, so they are close to live. Taxes come from the last 30 days of trades (the median of the latest 50 per side), so a tax change shows up as new trades arrive, not instantly. On paid plans `fresh=1` skips the cache and simulates again at the current block. **Which result fields tell me how confident the answer is?** `tax.source` (`realized`, `realized+simulated`, `simulated` or `none`), `tax.confidence` (`high` with 20+ measured trades, `medium` with 3+, `low` below that), `tax.realized.samples` (buy and sell counts), `meta.simulation` (whether a simulation ran) and, for the hook, `hook.observed` and `hook.family` (how much history the verdict is based on). ## Related [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Concept **Token taxes** How Crius measures buy, sell and transfer taxes on Robinhood Chain tokens from real trades and from a simulated buy and sell, how the two are combined, and how tax changes are tracked. Read](https://docs.crius.sh/concepts/taxes/) [Concept **Launch risk** How Crius spots insider control of a Robinhood Chain token with a clean contract (snipers, wallet farms, uniform holders, LP control) and the thresholds it uses. Read](https://docs.crius.sh/concepts/launch-risk/) [API reference **Security checks API** Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. Read](https://docs.crius.sh/reference/security/security-checks/) --- # How Crius measures token taxes (realized vs simulated) > How Crius measures buy, sell and transfer taxes on Robinhood Chain tokens from real trades and from a simulated buy and sell, how the two are combined, and how tax changes are tracked. Source: https://docs.crius.sh/concepts/taxes/ · Updated 2026-10-28 A token’s tax is the part of a trade that doesn’t reach the trader: the pool sends 1,000 tokens and the buyer receives 930. Crius measures taxes two ways for every Robinhood Chain token. **Realized** taxes come from real trades: what traders actually paid. **Simulated** taxes come from a test buy, transfer and sell run against the latest block. Real trades are the ground truth when there are enough of them; the simulation fills the gap for new tokens and catches tokens that block sells. ## Realized tax: from real trades For every trade, Crius compares the tokens the pool sent (or received) with what the trader’s wallet received (or sent). The difference is that trade’s tax, whoever takes it: the token contract, a fee-on-transfer mechanism or the pool’s Uniswap v4 hook. Each trade on the [trade tape](https://docs.crius.sh/reference/trades/trade-tape/) carries it as `fees.token_tax.pct`. From those per-trade taxes, `/security` builds the current rate: - **The median of the latest 50 trades per side**, within the last 30 days (`tax.realized.window: "30d"`). A median ignores the odd trade that paid much more or less than the rest. - **The developer is measured separately.** `tax.realized.by_wallet_class` has `others_sell_pct` for ordinary sellers and `dev_sell_pct` for the developer, so a developer who sells tax-free doesn’t hide the tax everyone else pays. The headline rate uses ordinary wallets. - **`tax.confidence`** is `high` with 20+ measured trades, `medium` with 3+ and `low` below that. `tax.realized.samples` gives the counts. Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/security/security-checks/) ### A median that ignores outliers: CHARGE Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) shows a 0% sell tax, but one sell paid far more. Which is right? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/security", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 177 lines (arrays trimmed)** ```json { "data": { "contract": { "blacklist": false, "can_change_limits": false, "can_change_tax": false, "cooldown": false, "implementation": null, "is_proxy": false, "mintable": false, "owner": null, "ownership": "none", "pausable": false, "proxy_kind": null, "self_destruct": false, "trading_switch": false, "upgradeable": false, "verified": null }, "flags": [ "unverified" ], "honeypot": { "is_honeypot": false, "reason": null, "selective": false }, "hook": { "address": "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207140434, "code_hash": "0xc21b1e6c1b45403e81a581f22ed6d9c747997af1cfdac1b1dc9f4b1d346a10db", "family": "0xabda3266e50c", "kind": "contract", "logic": null, "owner": "0x263ed295dafae1d9aadd6e56c4b6f9f38ee019dd", "ownership": "active", "size": 15167 }, "family": { "honeypot_pct": 0, "hooks": 22, "id": "0xabda3266e50c", "liquidity_pulled_pct": 0.684086, "pools_traded": 10525, "taxed_pct": 51.9715, "verified_hooks": 1 }, "flags": [], "name": "PonsV2MemeHook", "observed": { "dynamic_tax_pools": 13, "first_trade_ts": 1785866942000, "honeypot_pools": 0, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.66813, "liquidity_pulled_pools": 70, "max_buy_tax_pct": 10.99, "max_sell_tax_pct": 0.7, "median_pool_life_min": 53423.5, "pools": 10478, "pools_traded": 10477, "tax_measured_pools": 10392, "taxed_10pct_pools": 35, "taxed_pools": 5463, "volume_usd": 5384607135 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterSwap", "afterSwapReturnDelta" ], "risk": [ "can_modify_swap_amounts" ], "risk_level": "low" }, "known_asset": false, "launch": { "flags": [], "lp_top_wallet": { "address": "0x2d424d69b1ead72b30de4c7fe4c53e4853e1419d", "liquidity_usd": 3.0953, "pct": 0.0551662 }, "sniper_supply_pct": 6.09195, "sniper_top_wallet_pct": 6.09195, "sniper_wallets": 1, "sniper_window_blocks": 10, "uniform_holders": null, "wallet_farm": null }, "limits": {}, "liquidity": { "status": "partially_locked", "summary": { "burned_pct": 0, "locked_pct": 99.8878, "next_unlock_ts": null, "protocol_fee_pct": 0, "unlocked_in_wallets_pct": 0.1122, "weighting": "by pool liquidity_usd" } }, "primary_dex": "uniswap_v4", "risk": "low", "score": 95, "tax": { "buy_pct": 2.99, "confidence": "high", "realized": { "buy_pct": 2.99, "by_wallet_class": { "dev_sell_pct": null, "others_sell_pct": 0 }, "last_sample_ts": 1793196204000, "max_sell_pct_seen": 96.64, "samples": { "buys": 2539, "sells": 1873 }, "sell_pct": 0, "window": "30d" }, "sell_pct": 0, "simulated": null, "source": "realized", "transfer_pct": null }, "tax_history": [ { "from_block": 88385895, "pct": 0, "side": "buy" }, { "from_block": 88387118, "pct": 0, "side": "sell" }, { "from_block": 88461329, "pct": 3, "side": "buy" } ], "tax_history_total": 29, "tax_mode": "dynamic", "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8" }, "meta": { "block": 100406827, "block_age_ms": 1163, "block_ts": 1793225080000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 64, "safe_block": 100401329, "simulation": "no V2 WETH pair: realized tax only" } } ``` What this tells you - `tax.sell_pct: 0` while `tax.realized.max_sell_pct_seen: 96.64`. Ordinary sells pay nothing; one sell lost almost everything. The median of recent sells is the rate a new seller can expect. - `tax.buy_pct: 2.99`, from 2,539 buys and 1,873 sells measured (`confidence: "high"`). - `tax_history_total: 29` and `tax_mode: "dynamic"`: the measured rate has changed many times. The first entries show 0% on both sides at launch, then 3% on buys from block 88461329, eight blocks after its v4 liquidity was locked in the Pons launch locker at block 88461321 (see the [liquidity example](https://docs.crius.sh/guides/check-liquidity-locked/)): the launchpad’s fee on the graduated pool. - `tax.simulated: null`, `meta.simulation: "no V2 WETH pair: realized tax only"`: with no Uniswap v2 pair to simulate through, real trades are the whole answer. [Security checks reference](https://docs.crius.sh/reference/security/security-checks/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20median%20that%20ignores%20outliers%3A%20CHARGE&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Ftaxes%2F%23median%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fsecurity%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Simulated tax: a test trade at the latest block When a token has a Uniswap v2 pair with WETH, Crius simulates a full round trip through the Uniswap v2 router at the latest block, without sending anything on chain: 1. **Buy** about `amount_usd` worth (default $100) and compare the tokens received with what the router quoted: the buy tax. 2. **Transfer** 10% of the tokens to a second wallet: the transfer tax (`tax.transfer_pct`), and whether transfers work at all (`can_transfer`). 3. **Approve and sell** half of the rest. The sell tax is the share of tokens that never reached the pair, which doesn’t depend on price impact. The result is in `tax.simulated`: `can_buy`, `can_sell`, `buy_pct`, `sell_pct`, `transfer_pct`, gas used, and `revert_reason` when a step fails. A buy that works followed by a sell that fails is a honeypot (see [How to detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/)). Results are cached briefly; `fresh=1` runs a new simulation (Starter plan, 20 credits). ## How the two are combined | Real trades available | `tax.buy_pct` / `tax.sell_pct` | `tax.source` | | --- | --- | --- | | Recent buys and sells | Both realized | `realized` | | Recent buys but no recent sells by ordinary wallets | Buy realized, sell simulated | `realized+simulated` (or `realized` without a simulation) | | No recent buys | Simulated where available | `simulated`, or `none` without a v2 WETH pair | When both a realized and a simulated sell tax exist and they differ by more than 2 percentage points, the token gets the `tax_mismatch` flag (−10 points). In the [security score](https://docs.crius.sh/guides/token-security-score/), a buy or sell tax above 5% costs 15 points (`tax_over_5pct`) and above 10% costs 30 (`high_tax`). ## Tax history and dynamic taxes `tax_history` turns the per-trade taxes of ordinary wallets into segments: a new entry (`from_block`, `side`, `pct` in whole percent) starts when a side’s rate changes and stays changed for at least two trades in a row, so one odd trade doesn’t create a change. `tax_mode` is `dynamic` when either side has more than one segment, else `static`. The response holds the newest 100 segments; `tax_history_total` counts all of them. A dynamic tax isn’t always a trap. Launchpad tokens often go from 0% on the bonding curve to the launchpad’s fee after graduation, as CHARGE did. What matters is whether someone can still change it: `contract.can_change_tax` with an active owner, or a hook with a fee setter (`fee_changeable` in `hook.flags`). ## Known assets WETH, USDG and tokenized stocks (`known_asset: true`) have no tax to measure and no WETH pair to simulate against: their tax fields are empty and their trade noise isn’t treated as a tax history. ## Frequently asked questions **Why does Crius use real trades instead of reading the tax from the contract?** Because the contract is often not where the tax is. On Robinhood Chain many taxes are taken by a Uniswap v4 hook, some contracts tax only certain wallets or sizes, and a tax variable can say one thing while the transfer logic does another. Comparing what the pool sent with what the wallet received catches all of these. **Why is the sell tax 0 when one sell paid 96%?** The headline rate is the median of the latest 50 sells by ordinary wallets, so one odd trade doesn't set it. `tax.realized.max_sell_pct_seen` keeps the worst single sell so you can still see it. **What does tax\_mismatch mean?** The simulated sell tax and the realized sell tax differ by more than 2 percentage points. The token may tax differently by wallet or size, or the tax changed recently. It costs 10 points in the security score. ## Related [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Detect a honeypot** Check whether a Robinhood Chain token can be sold before you buy it. One API call simulates a buy and a sell and checks real trades; a real honeypot example shows the evidence. Read](https://docs.crius.sh/guides/detect-honeypot/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Concept **v4 hook risk** How Crius rates every Uniswap v4 hook on Robinhood Chain, from its permissions, its code and owner, what happened in its pools and its code family's record, with each risk flag and its threshold. Read](https://docs.crius.sh/concepts/uniswap-v4-hooks/) [API reference **Security checks API** Contract checks (ownership, mint, pause, blacklist, proxy, limits), realized and simulated buy/sell tax, honeypot verdict and, for v4 tokens, the pool hook's permissions and risk. Read](https://docs.crius.sh/reference/security/security-checks/) --- # How Robinhood Chain token prices work (confidence and thin liquidity) > How the Crius API prices Robinhood Chain tokens from on-chain pools, how the price pool is picked, and what confidence and thin_liquidity mean. Source: https://docs.crius.sh/concepts/token-prices/ · Updated 2026-10-28 Every USD price in the Crius API is read from Robinhood Chain’s own pools. For each token, Crius picks the market a trade could actually use (the pool with the most liquidity within ±2% of its current price), reads the token’s price in that pool’s quote asset (ETH, WETH, USDG or another token), and converts the quote to USD through the deepest ETH/USDG pool. Each price comes with the pool it came from, that pool’s liquidity and a `confidence` level, so you can tell a deep market from a pool that holds a few dollars. ## One price and its source Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### CHARGE: a graduated Pons token priced from its v4 pool What is Charge AI (0x7b8892cea949bc60d494681d1bc3ea96071ab0b8) worth in USD, and where does that number come from? GET/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "medium", "dex": "uniswap_v4", "eth": 0.00000000165124, "eth_usd": 2355.49, "liquidity_usd": 5604.57, "quote": "0x0000000000000000000000000000000000000000", "quote_liquidity_usd": 2802.29, "source_pool": "0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913", "symbol": "CHARGE", "thin_liquidity": false, "token": "0x7b8892cea949bc60d494681d1bc3ea96071ab0b8", "usd": 0.00000388948 }, "meta": { "block": 100406772, "block_age_ms": 654, "block_ts": 1793225075000, "chain": "robinhood", "finalized_block": 100397649, "lag_ms": 66, "safe_block": 100401329 } } ``` What this tells you - `usd: 0.00000388948` and `eth: 0.00000000165124` are the price of one whole token. - `source_pool` is the Uniswap v4 pool `0x871b166182fd708d5d16a4daa9a42f05a653fa51ee2b195097f425e0d9ca4913` (`dex: "uniswap_v4"`), quoted in native ETH (`quote: "0x0000000000000000000000000000000000000000"`). - `eth_usd: 2355.49` is the ETH/USD rate used to convert, read from the deepest ETH/USDG pool at the same block. - `quote_liquidity_usd: 2802.29` is the ETH side of the pool; `liquidity_usd: 5604.57` is twice that, the convention DEX screeners use. - `confidence: "medium"`: the pool holds between $1,000 and $10,000, so a large sell would move the price a lot. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20CHARGE%3A%20a%20graduated%20Pons%20token%20priced%20from%20its%20v4%20pool&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Ftoken-prices%2F%23price-source%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x7b8892cea949bc60d494681d1bc3ea96071ab0b8%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## How the price pool is chosen 1. **Bonding tokens: the curve.** While a launchpad token is still on its bonding curve, the curve is its market, whatever its size. Its liquidity is twice the real quote raised (the curve’s virtual reserves can’t be withdrawn). 2. **Everything else: the deepest market.** All the token’s pools (v2, v3 and v4, every fee tier) are candidates. They are ranked by **±2% depth**: the value of the liquidity within 2% of the pool’s current price. Liquidity parked far from the price doesn’t count, because no trade can use it at that price. 3. **Pools that never set a price.** A pool is skipped when its swap fee is 25% or more (decoy pools nobody trades in), when its in-range liquidity is under $50 while a real market exists, when it is one-sided (within ±2% of its price the token side is worth less than 1% of the quote side: a lone bid at an absurd price), when the price would make the token’s FDV more than 1,000,000 times the pool’s liquidity, or when a v3/v4 pool’s position math claims more tokens than the pool or the PoolManager actually holds. 4. **Converting the quote to USD.** ETH and WETH convert through the deepest ETH/USDG pool, and USDG counts as $1. Any other quote asset (a tokenized stock, another token) converts through its own direct ETH or USDG market, one hop only. That market must hold at least $5,000, or $100,000 for quote tokens Crius hasn’t marked as trusted, and a token that calls itself USDG, WETH or ETH without being the real contract is never used as a quote. A pool quoted through an untrusted hop must be four times deeper than the best direct ETH or USDG pool to win, because its price carries its quote’s own market error. Trusted quotes (tokenized stocks, launchpad quote tokens) compete on depth alone. The [Uniswap concept page](https://docs.crius.sh/concepts/uniswap/) explains how v3 and v4 in-range liquidity is measured. ## Confidence and thin liquidity | Value | When | | --- | --- | | `confidence: "high"` | The price pool's `liquidity_usd` is $10,000 or more | | `confidence: "medium"` | $1,000 to $10,000 | | `confidence: "low"` | Under $1,000, or a thin price | | `thin_liquidity: true` | No pool passed the checks above. The price comes from the deepest of the thin pools as a fallback (a fresh single-sided launch pool, for example), and `confidence` is always `low` | Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### A thin price: no real market behind it COGE (0x0e18c1d0413b573ecfd70b192b95a178119d5222) has a price. Can I trust it? GET/v1/robinhood/token/0x0e18c1d0413b573ecfd70b192b95a178119d5222/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0x0e18c1d0413b573ecfd70b192b95a178119d5222/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0x0e18c1d0413b573ecfd70b192b95a178119d5222/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0x0e18c1d0413b573ecfd70b192b95a178119d5222/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "low", "dex": "uniswap_v4", "eth": 0.00000000369817, "eth_usd": 2355.49, "liquidity_usd": 0, "quote": "0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea", "quote_liquidity_usd": 0, "source_pool": "0x2ca6e3aec9006c83b96a8e600feba99827195ceec87040ff01d19306352c6c92", "symbol": "COGE", "thin_liquidity": true, "token": "0x0e18c1d0413b573ecfd70b192b95a178119d5222", "usd": 0.000008711 }, "meta": { "block": 100410192, "block_age_ms": 522, "block_ts": 1793225425000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 77, "safe_block": 100405028 } } ``` What this tells you - `thin_liquidity: true` and `confidence: "low"`: no pool of this token passed the checks, so the price is a fallback. - `liquidity_usd: 0` and `quote_liquidity_usd: 0`: there is nothing on the other side to sell into. - `quote` is `0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea`, another token rather than ETH or USDG, so the USD value also depends on that token’s own market (a one-hop quote). - `usd: 0.000008711` is a last price, not a value anyone could realize. Show it with a warning, and leave it out of portfolio totals and automated trades. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20thin%20price%3A%20no%20real%20market%20behind%20it&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Ftoken-prices%2F%23thin-price%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0x0e18c1d0413b573ecfd70b192b95a178119d5222%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) Example [Anonymous · no key · 1 credit](https://docs.crius.sh/reference/tokens/token-price/) ### A tokenized stock: NVDA priced against USDG What is the on-chain price of NVIDIA's Robinhood token (0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec)? GET/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price"); const { data, meta } = await res.json(); ``` **Python** ```python import requests r = requests.get( "https://api.crius.sh/v1/robinhood/token/0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec/price", ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 25 lines (arrays trimmed)** ```json { "data": { "confidence": "high", "dex": "uniswap_v3", "eth": 0.090983, "eth_usd": 2355.49, "liquidity_usd": 1415158, "quote": "0x5fc5360d0400a0fd4f2af552add042d716f1d168", "quote_liquidity_usd": 707579, "source_pool": "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3", "symbol": "NVDA", "thin_liquidity": false, "token": "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec", "usd": 214.31 }, "meta": { "block": 100410171, "block_age_ms": 448, "block_ts": 1793225423000, "chain": "robinhood", "finalized_block": 100401329, "lag_ms": 138, "safe_block": 100405028 } } ``` What this tells you - `usd: 214.31` from a Uniswap v3 pool (`dex: "uniswap_v3"`, `source_pool: "0xd4eb21209c4d6093f80b5b84f5c45cc093ea14a3"`) quoted in USDG (`quote: "0x5fc5360d0400a0fd4f2af552add042d716f1d168"`). - `liquidity_usd: 1415158`: well above $10,000, so `confidence: "high"`. - `eth: 0.090983` is the same price in ETH, converted at `eth_usd: 2355.49`. - Tokenized stocks follow exactly the same rules as any other token: the price is what the chain’s pools say, not a feed from the stock exchange. [Token price reference](https://docs.crius.sh/reference/tokens/token-price/) Runs from your browser on the anonymous plan [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20A%20tokenized%20stock%3A%20NVDA%20priced%20against%20USDG&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Ftoken-prices%2F%23stock-price%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Ftoken%2F0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec%2Fprice%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Where the price is used - **Market cap and FDV.** `market_cap_usd` is the price × (total supply − burned tokens), and `fdv_usd` is the price × total supply. See [Responses & conventions](https://docs.crius.sh/conventions/#numbers-and-amounts). - **Holdings.** `value_usd` on holders and wallet holdings is the balance × price, capped at what the price pool’s quote side could pay out: a position is never worth more than the market that prices it. - **Trades.** `price_usd` and `value_usd` on each trade are fixed when the trade is indexed, with that block’s ETH/USD (`eth_usd_at_trade`). They don’t change when the price moves later. - **Candles.** USD candles merge the token’s real markets (pools with at least $1,000 or 2% of its liquidity, plus its launch curve) and leave out outlier trades, so a $1 trade in a side pool can’t draw a wick. See [OHLCV candles](https://docs.crius.sh/guides/get-ohlcv-candles/). - **Rankings.** `list=top_market_cap` leaves out prices from thin markets. ## Use it in your app 1. **Read the price with its context.** Use `/token/{address}/price` for one token or `/prices` for up to 100 at a time (1 credit per call, no key needed). 2. **Gate on `confidence`.** Use `high` prices for valuations and alerts. Show `medium` prices with the pool’s liquidity next to them. Treat `low` and `thin_liquidity` prices as indicative only. 3. **Compare liquidity with your trade size.** `quote_liquidity_usd` is roughly what the whole pool could pay for tokens. An order that is a large share of it will move the price far from `usd`. 4. **Handle tokens with no price.** A token with no usable market yet returns `data: null`. Show “no market” instead of $0. ```js // Price with a trust level, for a portfolio total or an alert. const res = await fetch(`https://api.crius.sh/v1/robinhood/token/${token}/price`); const { data, meta } = await res.json(); if (!data) { console.log("no market yet"); } else if (data.thin_liquidity || data.confidence === "low") { console.log(`~$${data.usd} (indicative only: $${data.liquidity_usd} liquidity)`); } else { console.log(`$${data.usd} from ${data.dex} pool ${data.source_pool} at block ${meta.block}`); } ``` A price is not a quote `usd` is the pool’s current price for a small trade. What a large buy or sell would really get depends on the pool’s depth. Check `liquidity_usd` against your size before acting, and see [pools & liquidity](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) for every market a token trades in. ## Frequently asked questions **Where do Crius token prices come from?** From Robinhood Chain's own pools only. Each token is priced in its deepest market (a Uniswap v2, v3 or v4 pool, or its launchpad bonding curve while it is still bonding), and the quote asset is converted to USD through the deepest ETH/USDG pool. No exchange or off-chain price feed is used. **What does \`confidence\` mean on a price?** How much liquidity backs it. `high` means the price pool holds $10,000 or more (`liquidity_usd`), `medium` $1,000 to $10,000, `low` under $1,000. A price with `thin_liquidity: true` is always `low`. **Why does a token show a large market cap with almost no liquidity?** Market cap is price × supply, and the price can come from a small pool. A $1 billion market cap backed by a few thousand dollars of liquidity can't be sold at that value. Check `liquidity_usd` and `confidence` before you trust a valuation. Holder and wallet `value_usd` are capped at what the price pool's quote side could pay out. **Are tokenized stock prices the same as the stock exchange price?** No. Tokenized stocks such as NVDA are priced from their Robinhood Chain pools like every other token, so the price is what traders on the chain are paying. It can differ from the exchange price, for example outside market hours. **How often do prices update?** Every block (about every 100 ms). A price is recomputed for the newest block when you ask for it, and `meta.block` tells you which block it reflects. For a push feed, subscribe to `price:` on the WebSocket stream. ## Related [Guide **Get a token price** Get the live USD and ETH price of any Robinhood Chain token, the pool it comes from and how much to trust it, with one fast API call. Real examples, no key. Read](https://docs.crius.sh/guides/get-token-price/) [Guide **Pools and liquidity** Robinhood Chain liquidity API: list every Uniswap v2, v3 and v4 pool and launch curve of a token, with USD liquidity, fees, hooks and the price pool. No key. Read](https://docs.crius.sh/guides/get-token-pools-and-liquidity/) [Guide **Market cap, FDV and supply** Robinhood Chain token supply API: total, burned, locked and circulating supply plus market cap and FDV of any token in one call, and how each is computed. Read](https://docs.crius.sh/guides/market-cap-fdv-and-supply/) [Guide **OHLCV candles** Robinhood Chain OHLCV API: candles for any token from 1 second to 1 day, with buy volume, trade count and market cap per candle. Real examples and chart code. Read](https://docs.crius.sh/guides/get-ohlcv-candles/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [API reference **Token price API** The fastest call: USD and ETH price, the pool it came from, that pool's liquidity and a confidence level. Read](https://docs.crius.sh/reference/tokens/token-price/) --- # Uniswap v4 hook risk: levels, flags and code families > How Crius rates every Uniswap v4 hook on Robinhood Chain, from its permissions, its code and owner, what happened in its pools and its code family's record, with each risk flag and its threshold. Source: https://docs.crius.sh/concepts/uniswap-v4-hooks/ · Updated 2026-10-28 A Uniswap v4 hook is a contract the pool calls around swaps and liquidity changes. It can take a fee, change swap amounts, block swaps or stop liquidity from moving, so a hook is part of a token’s risk even when the token’s own contract is clean. Crius rates every hook on Robinhood Chain from four kinds of evidence, turns each finding into a flag with a severity and an evidence sentence, and sets the hook’s `risk_level` to its worst flag. ## Four kinds of evidence | Evidence | What it is | Field | | --- | --- | --- | | Permissions | The callbacks the hook can run, fixed in the low 14 bits of its address when it is deployed. They say what the hook could do. See [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/) for the table. | `permissions`, `flags_hex`, `capabilities` | | Code | What sits at the address and who controls it: `kind` (`contract`, `minimal_proxy`, `upgradeable_proxy`, `beacon_proxy`, `delegated` wallet or `no_code`), `owner` and `ownership`, and the `admin_functions` found in its code (`fee_setter`, `pause`, `blacklist`, `withdraw`, `upgrade`, `arbitrary_call`). | `code` | | Observed | What happened in its own pools. A pool counts as traded with 10+ trades; as a honeypot with 10+ buys and no sells; as pulled when 80%+ of the liquidity added was removed again; as taxed when its median tax is 1% or more over 5+ measured trades; as dynamic when its sell tax swings by 5 points or more. | `observed` | | Family and pattern | The same record summed over every hook with the same code (`family`) and over every hook with the same swap permissions (`pattern`). A new hook carries its family's history. | `family`, `pattern` | Example [Free plan · 2 credits](https://docs.crius.sh/reference/pools/hook-detail/) ### Shares, not counts: DopplerHookInitializer DopplerHookInitializer (0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544) runs more pools than any other hook, and some of them were honeypots. Why is it low risk? GET/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544 **cURL** ```bash curl "https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544" \ -H "x-api-key: $CRIUS_API_KEY" ``` **JavaScript** ```js const res = await fetch("https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", { headers: { "x-api-key": process.env.CRIUS_API_KEY }, }); const { data, meta } = await res.json(); ``` **Python** ```python import os, requests r = requests.get( "https://api.crius.sh/v1/robinhood/hook/0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", headers={"x-api-key": os.environ["CRIUS_API_KEY"]}, ) body = r.json() print(body["data"]) ``` **Real response 200 Captured Oct 28, 2026 · 124 lines (arrays trimmed)** ```json { "data": { "abi_events": [ "Collect(bytes32,uint256,uint256)", "Create(address,address,address)", "DelegateAuthority(address,address)" ], "address": "0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544", "attribution": "unattributed", "capabilities": { "can_block_swaps": false, "can_gate_liquidity": false, "can_modify_liquidity_amounts": false, "can_modify_swap_amounts": true }, "code": { "admin_functions": [], "checked_ts": 1793207143998, "code_hash": "0xc41a91106002f15bf70ae266824317f3f3ac638ac72ca5253bae395fa47ee631", "family": "0xaa37a5a3457a", "kind": "contract", "logic": null, "owner": null, "ownership": "none", "size": 25533 }, "events": [ { "emitted_in_scan": 7796, "event": "Swap(address,(address,address,uint24,int24,address),bytes32,(bool,int256,uint160),int128,int128,bytes)", "topic0": "0x1d9f7b5e406d8c887155e1a78e070d2d41c5d0444dab8b21612f846835c27183" }, { "emitted_in_scan": 1724, "event": "ModifyLiquidity((address,address,uint24,int24,address),(int24,int24,int256,bytes32))", "topic0": "0xdb675a606e5aa8f039e93c54673258dc875053bdaa5dbb96de1670bfdece53b3" }, { "emitted_in_scan": 545, "event": "Create(address,address,address)", "topic0": "0xb224da6575b2c2ffd42454faedb236f7dbe5f92a0c96bb99c0273dbe98464c7e" } ], "family": { "honeypot_pct": 0.0318652, "hooks": 1, "id": "0xaa37a5a3457a", "liquidity_pulled_pct": 0.0389463, "pools_traded": 28244, "taxed_pct": 1.78091, "verified_hooks": 1 }, "fee_tiers_in_scan": [ { "fee": 10000, "pools": 3 }, { "fee": 15000, "pools": 2 }, { "fee": 16000, "pools": 1 } ], "flags": [], "flags_hex": "0x2544", "launchpad": null, "launchpad_name": null, "name": "DopplerHookInitializer", "observed": { "dynamic_tax_pools": 24, "first_trade_ts": 1782922953000, "honeypot_pools": 9, "last_trade_ts": 1793223683000, "liquidity_pulled_pct": 0.0389463, "liquidity_pulled_pools": 11, "max_buy_tax_pct": 99.52, "max_sell_tax_pct": 93.49, "median_pool_life_min": 2138, "pools": 224061, "pools_traded": 28244, "tax_measured_pools": 5814, "taxed_10pct_pools": 29, "taxed_pools": 503, "volume_usd": 1968346259 }, "pattern": { "description": "hooks that change swap amounts only", "honeypot_pct": 0.0696347, "id": "swap_delta_only", "liquidity_pulled_pct": 7.93603, "pools_traded": 43082, "taxed_pct": 15.7537 }, "permissions": [ "beforeInitialize", "afterAddLiquidity", "afterRemoveLiquidity" ], "pools": 224090, "risk": [ "can_modify_swap_amounts" ], "risk_level": "low", "stats": { "pools_created_24h": 1181, "trades_24h": 59387, "volume_usd_24h": 7478239 }, "verified": true }, "meta": { "block": 100406861, "block_age_ms": 985, "block_ts": 1793225084000, "chain": "robinhood", "finalized_block": 100397649, "intel_computed_ts": 1793223685333, "lag_ms": 107, "safe_block": 100401329 } } ``` What this tells you - `observed.honeypot_pools: 9` and `liquidity_pulled_pools: 11` out of `pools_traded: 28244`. In absolute numbers that sounds bad; as shares it is 0.03% and 0.04% (`family.honeypot_pct: 0.0318652`, `liquidity_pulled_pct: 0.0389463`). - `observed.max_buy_tax_pct: 99.52` is one pool’s tax; only 29 of 5,814 measured pools take 10% or more (`taxed_10pct_pools`, `tax_measured_pools`), far short of the half that would flag `high_tax_observed`. - `verified: true` and `code.ownership: "none"`: a known protocol hook with no owner, so its permissions and pattern don’t add flags. `flags: []`, `risk_level: "low"`. - `pattern.id: "swap_delta_only"`: hooks that change swap amounts but can’t block swaps. Across 43,082 traded pools, 0.07% of them became honeypots. - `events` shows what it emits (7,796 `Swap` and 1,724 `ModifyLiquidity` events in the scan) and `fee_tiers_in_scan` the pool fees seen, such as 10000 (1%) in 3 pools. [Hook detail reference](https://docs.crius.sh/reference/pools/hook-detail/) [Data looks wrong? Report it](mailto:support@crius.sh?subject=Wrong%20data%20in%20docs%20example%3A%20Shares%2C%20not%20counts%3A%20DopplerHookInitializer&body=Page%3A%20https%3A%2F%2Fdocs.crius.sh%2Fconcepts%2Funiswap-v4-hooks%2F%23doppler%0ARequest%3A%20GET%20%2Fv1%2Frobinhood%2Fhook%2F0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544%0A%0AWhat's%20wrong%20or%20missing%3F%0A%0A) ## Risk flags | Flag | Severity | Raised when | | --- | --- | --- | | `no_code` | critical | There is no contract at the hook address: every callback the pool makes to it fails. | | `delegated_wallet` | critical | The hook is a wallet delegating to code (EIP-7702): its owner can replace the code at any time. | | `honeypot_observed` | critical | 20% or more of its own traded pools had 10+ buys and no sells. | | `honeypot_family` | critical | 20% or more of its code family's traded pools (10+ needed) became honeypots. | | `rug_family` | high (medium with a clean record) | Liquidity was pulled in 80% or more of its family's traded pools. | | `rugs_observed` | high | Liquidity was pulled in 80% or more of its own traded pools (3+ needed). | | `can_block_swaps` | high (medium with a clean record) | It runs before swaps without taking a delta, a pattern with a high honeypot rate. The evidence quotes that rate. | | `high_tax_observed` | high | Half or more of its measured pools take 10% or more per trade. | | `upgradeable` | medium | It is an upgradeable or beacon proxy: what it does can change after launch. | | `tax_observed` | medium | A fifth or more of its measured pools take 1% or more per trade. | | `dynamic_tax` | medium | A tenth or more of its measured pools had their tax swing by 5 points or more. | | `honeypot_pools_seen` | medium | Some of its pools were honeypots, but fewer than 20%. | | `fee_changeable` | medium | It has a fee or tax setter and an owner that hasn't renounced. | | `owner_controls` | medium | Its owner can call pause, blacklist, withdraw, upgrade or arbitrary-call functions. | | `new_unknown` | medium | Its first trade was under 24 hours ago and its code family has fewer than 10 traded pools. | | `can_modify_swap_amounts` | low | It can take part of every swap. For information: this is how launchpad fee hooks work, and the safest pattern on chain. | Real examples of the critical flags, with their evidence sentences (`no_code` with 142 of 143 pools rugged, `honeypot_family`, `honeypot_observed`), are in the [critical hooks example](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/#critical-hooks). A **clean record** is 20+ traded pools of its own, no honeypots and liquidity pulled in under a fifth of them. It outweighs the family and permission statistics, which is why those two flags drop to `medium` for a hook that has proven itself. **Verified hooks** (`verified: true`: launchpads and known protocols) can only get `honeypot_observed`, `high_tax_observed` and `dynamic_tax` from what happened in their pools, and `no_code` or `delegated_wallet` from their code. Family, permission and ownership flags, and the milder tax and honeypot flags, don’t apply to them. ## How hook risk reaches a token `/security` attaches the hook of the pool the token is priced from. The token loses 60 points for a `critical` hook (`hook_critical_risk`, which also makes the token `high` risk), 30 for `high` (`hook_high_risk`) and 10 for `medium` (`hook_medium_risk`). If the hook can block swaps, `hook_can_block_swaps` is listed for information. For an example of a medium-risk hook that taxes, and how to show the evidence in an app, see [Check the risk of a Uniswap v4 hook](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). ## Frequently asked questions **What is a hook code family?** Hooks whose code has the same set of functions belong to one family, even when values set at deployment differ. Families are how a hook deployed a minute ago can already have a history: if other hooks with the same code trapped their buyers, the new one is flagged `honeypot_family`. Hook `0x593da569c2a5a6999f59fcc5b06477d8bb4dc080` is critical with no traded pools of its own, because 94% of the 35 traded pools of its family `0x6f11e9734465` (34 hooks) became honeypots. **Why are verified hooks treated differently?** Hooks verified in Crius's registry (launchpad and known protocol hooks) have known code and a known operator, so their permissions and family statistics say little. They are judged only on what happened in their own pools, and a launchpad's standard fee isn't flagged as a tax. **Can a hook's risk level change?** Yes. Risk is recomputed every 30 minutes from what happens in its pools, and hooks whose code can change (proxies, delegated wallets) are re-inspected every 6 hours. A new hook with no history can drop from `high` to `medium` once it has a long clean record of its own. ## Related [Guide **Check v4 hook risk** Find out what a Robinhood Chain token's Uniswap v4 hook can do and what happened in its pools (taxes, honeypots, rugs). Real examples, including critical hooks. Read](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [Guide **Check token taxes** Get the real buy and sell tax of any Robinhood Chain token in one call, measured from recent trades and checked by simulation. Real examples with a 5% sell tax and a 7% buy tax. Read](https://docs.crius.sh/guides/check-token-taxes/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [API reference **Hook detail API** One hook: decoded permissions, code (kind, owner, admin functions), what happened in its pools, its code family's history, flags with evidence and risk level, and the events it emits. Read](https://docs.crius.sh/reference/pools/hook-detail/) --- # Uniswap v2, v3 & v4 > How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Source: https://docs.crius.sh/concepts/uniswap/ · Updated 2026-10-28 Crius indexes every Uniswap deployment on Robinhood Chain: v2 pairs, v3 pools at every fee tier, and v4 pools (including dynamic-fee and hooked pools). ## Identifying pools | Version | Pool id in the API | | --- | --- | | v2 | Pair contract address (20 bytes) | | v3 | Pool contract address (20 bytes) | | v4 | Pool id (32 bytes): all v4 pools live inside one PoolManager contract | ## Liquidity - For v2, reserves are the pair’s balances. - For v3 and v4, only **in-range** liquidity counts toward depth, computed from the pool’s tick map. - `liquidity_usd` is 2 × the quote side (ETH, WETH or USDG), the convention used by DEX screeners; `quote_liquidity_usd` is the quote side alone. ## v4 hooks A Uniswap v4 pool can attach a **hook**: a contract called before or after swaps and liquidity changes. Hooks enable features like launch taxes and dynamic fees, but a hook can also block swaps, change amounts or stop liquidity removal. The hook’s **permissions** are encoded in the low 14 bits of its address, so they can be read without trusting the hook’s code. Crius decodes them and turns them into risk flags: | Permission | Risk flag | | --- | --- | | `beforeSwap` | `can_block_or_reprice_swaps` | | `beforeSwapReturnDelta` / `afterSwapReturnDelta` | `can_modify_swap_amounts` | | `beforeRemoveLiquidity` | `can_gate_liquidity_removal` | | `beforeAddLiquidity` | `can_gate_liquidity_add` | | `afterAddLiquidityReturnDelta` / `afterRemoveLiquidityReturnDelta` | `can_modify_liquidity_amounts` | | unverified source | `unverified` | See [`/hooks`](https://docs.crius.sh/reference/pools/uniswap-v4-hooks/) and [`/hook/{address}`](https://docs.crius.sh/reference/pools/hook-detail/). A token’s security check includes its pool hook’s permissions and any **hook tax** measured from real trades. --- # For AI agents & LLMs > How AI assistants and agents can read the Crius documentation (llms.txt, llms-full.txt, Markdown pages) and call the Crius API (OpenAPI document, anonymous endpoints). Source: https://docs.crius.sh/ai/ · Updated 2026-10-28 The Crius documentation is built to be read by language models as easily as by people. | Resource | URL | Use | | --- | --- | --- | | `llms.txt` | [`https://docs.crius.sh/llms.txt`](https://docs.crius.sh/llms.txt) | Index of the docs with one-line summaries ([llmstxt.org](https://llmstxt.org) format) | | `llms-full.txt` | [`https://docs.crius.sh/llms-full.txt`](https://docs.crius.sh/llms-full.txt) | All documentation in one Markdown file | | Markdown pages | `https://docs.crius.sh/.md` | Any docs page as clean Markdown, e.g. [`/quickstart.md`](https://docs.crius.sh/quickstart.md) or [`/guides/token-security-score.md`](https://docs.crius.sh/guides/token-security-score.md) | | OpenAPI 3 | [`https://api.crius.sh/openapi.json`](https://api.crius.sh/openapi.json) | Machine-readable endpoints and parameters, for tool or function definitions | Every docs page also has a **Copy as Markdown** button, and links to open the page in ChatGPT or Claude. ## Giving an agent access to the API - Core endpoints (prices, token profiles, pools, trades, candles, search, stats) work **without a key**, so an agent can explore at 2 requests per second. - For anything more, create a dedicated API key for the agent with only the `read` scope, an IP allow-list if it runs on a fixed host, and a per-key rate limit. Rotate or revoke it from the dashboard at any time. - Responses are compact JSON with plain decimal numbers and a `meta.block` that lets the agent cite exactly which block its answer reflects. ## Suggested system prompt snippet ```text You can call the Crius API (https://api.crius.sh) for Robinhood Chain (chain id 4663) data. Docs: https://docs.crius.sh/llms.txt. Send the key in the x-api-key header. Token price: GET /v1/robinhood/token/{address}/price. Token profile: GET /v1/robinhood/token/{address}. Candles: GET /v1/robinhood/token/{address}/candles?interval=1h. Search: GET /v1/robinhood/search?q=. Amounts are in human units, USD values are plain decimals, timestamps are unix milliseconds. ``` --- # Changelog > Every change to the Crius Robinhood Chain API, the dashboard and the documentation, newest first, with new endpoints, fields and behaviour changes. Source: https://docs.crius.sh/changelog/ · Updated 2026-10-28 New endpoints, fields and behaviour changes are listed here, newest first. Additive changes (new fields, new endpoints) can ship at any time; breaking changes are announced here first. ## October 2026 - **Documentation moved to [docs.crius.sh](https://docs.crius.sh/).** A new site with step-by-step guides that use real responses, one reference page per endpoint (runnable in the browser for anonymous endpoints), launchpad pages, use cases, concepts and a glossary. Every old `crius.sh/docs/...` link redirects to the same page here. - **`/holders` takes `exclude=infra`** to leave pools, lockers, burn addresses and protocol contracts out of the list. - **`GET /v1/{chain}/launchpads/{id}`** is documented: one launchpad’s stats, daily history and top tokens. - **Bubble maps show only real holders and real clusters.** Infrastructure is listed under `hidden_infra`, funding from exchanges, bridges and app relayers no longer links wallets, and each cluster lists its members and why they are linked. - **Account API moved to `account.crius.sh`.** Accounts, keys and usage are now served by a dedicated control plane. `api.crius.sh/v1/account/*` keeps working. - **Dashboard sessions.** Signing in to the dashboard issues a 7-day session key that can manage the account but can’t call data endpoints; API keys can no longer manage the account. New `GET /v1/account/sessions`. - **Account calls are free.** `/v1/account/*` no longer costs credits and has its own rate limit. - **On-chain billing.** Plans can be paid in USDG, ETH or WETH on Robinhood Chain, for 1, 6 or 12 months, with optional auto-renew. New `GET /v1/account/billing` and `POST /v1/account/billing/claim`. - **Email sign-up and wallet sign-in** for the dashboard, with linked wallets. ## Earlier - Launch of the Crius API for Robinhood Chain: tokens, prices, pools, trades, candles, holders (live, snapshots, cohorts, history), traders, security, liquidity, launchpads, fees, wallets, bundles, bubble maps, hooks, discovery, chain stats and the WebSocket stream. --- # FAQ > Answers to common questions about the Crius Robinhood Chain API - pricing, free plan, data freshness, coverage, history, rate limits, payments and support. Source: https://docs.crius.sh/faq/ · Updated 2026-10-28 ## What is the Crius API? A data API for Robinhood Chain (chain id 4663). It serves real-time and historical token prices, OHLCV candles, trades, holders, pools, launchpad data, security checks and wallet analytics over REST and WebSocket, from Crius' own archive nodes. ## Is there a free plan? Yes. The Free plan includes 1,000,000 credits a month, 10 requests per second and one WebSocket connection, with no card required. Core endpoints such as prices, tokens, trades and candles also work without a key at 2 requests per second per IP. ## How fresh is the data? Each block is decoded as it arrives from our own node, typically within a fraction of a second. Every response includes meta.block and meta.lag\_ms so you can see exactly how fresh it is. ## Which tokens and DEXs are covered? Every ERC-20 on Robinhood Chain, every Uniswap v2, v3 and v4 pool (including v4 hooks), launchpads such as Pons, Flap.sh, Bankr, Long.xyz, Flywheel and King of the Markets, LP lockers, and tokenized stocks priced from on-chain pools. ## How far back does history go? To block one of Robinhood Chain. Candles, trades and holder history are available from each token's first block. ## What counts as a credit? Each request costs credits depending on the endpoint, from 1 (prices, token profiles) to 20 (a fresh security simulation). Account API calls are free. Credits reset at the start of each UTC month. ## How do I pay? On-chain on Robinhood Chain in USDG, ETH or WETH through the CriusPayments contract, from the Billing page of the dashboard. 6 months are 10% off and 12 months 20% off. Optional auto-renew uses a price cap you set. ## Do you store card details? No. Payments are on-chain from your own wallet; we never hold funds or payment details. ## Can I use the API from a browser? Yes, with care. Anonymous endpoints work directly. For keyed requests, restrict a key to your site's origin (it becomes read-only) or proxy requests through your backend so the key never reaches the page. ## Is the price data financial advice? No. Data is provided as is for building products and research. Always verify before trading. ## How do I get help? Email support@crius.sh. Service status and incidents are at status.crius.sh. ## Frequently asked questions **What is the Crius API?** A data API for Robinhood Chain (chain id 4663). It serves real-time and historical token prices, OHLCV candles, trades, holders, pools, launchpad data, security checks and wallet analytics over REST and WebSocket, from Crius' own archive nodes. **Is there a free plan?** Yes. The Free plan includes 1,000,000 credits a month, 10 requests per second and one WebSocket connection, with no card required. Core endpoints such as prices, tokens, trades and candles also work without a key at 2 requests per second per IP. **How fresh is the data?** Each block is decoded as it arrives from our own node, typically within a fraction of a second. Every response includes meta.block and meta.lag\_ms so you can see exactly how fresh it is. **Which tokens and DEXs are covered?** Every ERC-20 on Robinhood Chain, every Uniswap v2, v3 and v4 pool (including v4 hooks), launchpads such as Pons, Flap.sh, Bankr, Long.xyz, Flywheel and King of the Markets, LP lockers, and tokenized stocks priced from on-chain pools. **How far back does history go?** To block one of Robinhood Chain. Candles, trades and holder history are available from each token's first block. **What counts as a credit?** Each request costs credits depending on the endpoint, from 1 (prices, token profiles) to 20 (a fresh security simulation). Account API calls are free. Credits reset at the start of each UTC month. **How do I pay?** On-chain on Robinhood Chain in USDG, ETH or WETH through the CriusPayments contract, from the Billing page of the dashboard. 6 months are 10% off and 12 months 20% off. Optional auto-renew uses a price cap you set. **Do you store card details?** No. Payments are on-chain from your own wallet; we never hold funds or payment details. **Can I use the API from a browser?** Yes, with care. Anonymous endpoints work directly. For keyed requests, restrict a key to your site's origin (it becomes read-only) or proxy requests through your backend so the key never reaches the page. **Is the price data financial advice?** No. Data is provided as is for building products and research. Always verify before trading. **How do I get help?** Email [support@crius.sh](mailto:support@crius.sh). Service status and incidents are at status.crius.sh. --- # Robinhood Chain glossary > Plain definitions of Robinhood Chain, DeFi, launchpad, token-safety and Crius API terms, from bonding curves and honeypots to v4 hooks and credits. Source: https://docs.crius.sh/glossary/ · Updated 2026-10-28 Short definitions of the terms used across the Crius docs and API responses. Each one links to the page that explains it in full. ## Robinhood Chain ### Robinhood Chain An Ethereum layer-2 network built on Arbitrum Orbit, with chain id 4663 (`0x1237`). A sequencer orders transactions about every 100 ms, and batches are settled on Ethereum. ETH is the gas token. See [Robinhood Chain](https://docs.crius.sh/concepts/robinhood-chain/). ### Sequencer The node that orders Robinhood Chain transactions into blocks. A transaction is visible as soon as the sequencer includes it, which is the `latest` finality level. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/). ### L1 block The Ethereum block number. Inside a Robinhood Chain contract, `block.number` returns the L1 block (about every 12 seconds), not the L2 block (about every 100 ms), so per-block contract rules act on L1 blocks. Responses report the L2 `block` and add `l1_block` where it matters. See [Robinhood Chain](https://docs.crius.sh/concepts/robinhood-chain/#two-block-numbers). ### Finality How settled a block is. `latest` means included by the sequencer, `safe` means its batch is posted to Ethereum, and `finalized` means Ethereum has finalized that batch. Every response’s `meta` carries `safe_block` and `finalized_block`. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/). ### Reorg A chain reorganization: blocks that were seen are replaced by others. On Robinhood Chain it is rare. REST responses simply reflect the new chain; WebSocket clients get a `reorg` message and every affected event again with `"removed": true`. See [Finality & reorgs](https://docs.crius.sh/concepts/finality/#reorgs). ### WETH Wrapped ETH, the ERC-20 version of ETH, at `0x0bd7d308f8e1639fab988df18a8011f41eacad73`. Pools quote tokens in native ETH (`0x0000000000000000000000000000000000000000`) or in WETH, and Crius treats both as ETH for pricing. See [Robinhood Chain](https://docs.crius.sh/concepts/robinhood-chain/#assets-youll-see-everywhere). ### USDG The dollar stablecoin on Robinhood Chain, at `0x5fc5360d0400a0fd4f2af552add042d716f1d168`, with 6 decimals. Crius converts ETH to USD through the deepest ETH/USDG pool and counts USDG as $1. Tokens that copy the USDG symbol at other addresses are never used as a price quote. See [Token prices](https://docs.crius.sh/concepts/token-prices/). ### Tokenized stock An ERC-20 token that tracks a listed company’s shares, such as NVIDIA’s Robinhood token NVDA at `0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec`. Crius prices tokenized stocks from their Robinhood Chain pools like any other token, so the price can differ from the stock exchange’s. They are known assets and always `low` risk in the security check. See [Token prices](https://docs.crius.sh/concepts/token-prices/). ### Smart account A wallet controlled by contract code. On Robinhood Chain this is usually an EIP-7702 account: an ordinary address whose code points to a `delegate` contract. Crius tags it `smart_account` and counts it as a holder; ERC-4337 accounts are attributed the same way, with the bundler as `executor`. See [Holder classes](https://docs.crius.sh/concepts/holder-classes/). ### Relay solver A wallet that pays out funds for a cross-chain bridge (Relay). It shows up as the first funder of many wallets, labeled `bridge:Relay solver`. Bridge funding never links wallets into a cluster. See [Find connected wallets](https://docs.crius.sh/guides/find-connected-wallets/). ## Tokens and markets ### Market cap The token’s price × (total supply − tokens burned at `0x0000000000000000000000000000000000000000` or `0x000000000000000000000000000000000000dead`), with unsold bonding-curve tokens included. In the API it is `market_cap_usd`. It can be far larger than what the token’s pools could pay, so read it next to liquidity. See [Market cap, FDV and supply](https://docs.crius.sh/guides/market-cap-fdv-and-supply/). ### FDV Fully diluted valuation: price × total supply, burned tokens included (`fdv_usd`). For tokens with nothing burned it equals the market cap. See [Market cap, FDV and supply](https://docs.crius.sh/guides/market-cap-fdv-and-supply/). ### Circulating supply Total supply minus burned tokens (`circulating_supply` on the token profile). Tokens held by LP lockers are still counted as circulating; they are reported separately as `locked`. See [Market cap, FDV and supply](https://docs.crius.sh/guides/market-cap-fdv-and-supply/). ### Liquidity How much a token’s pools can trade. `liquidity_usd` is 2 × the quote side (ETH, WETH or USDG) of a pool, the convention DEX screeners use, and `quote_liquidity_usd` is the quote side alone. For Uniswap v3 and v4 only in-range liquidity counts. See [Responses & conventions](https://docs.crius.sh/conventions/#numbers-and-amounts). ### TVL Total value locked: the liquidity of every pool on the chain added up. `/stats` reports it as `liquidity.tvl_usd`, measured as 2 × the quote side of every pool, in range for v3 and v4. See [Build a chain stats dashboard](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/). ### Quote asset The asset a token is priced and traded against in a pool: native ETH, WETH, USDG, or another token such as a tokenized stock. A pool’s `quote` field holds its address. See [Token prices](https://docs.crius.sh/concepts/token-prices/). ### Price confidence How much liquidity backs a price: `high` for $10,000 or more in the price pool, `medium` for $1,000 to $10,000, `low` below that. Use it before you trust a valuation or act on a price. See [Token prices](https://docs.crius.sh/concepts/token-prices/#confidence-and-thin-liquidity). ### Thin liquidity A price with no real market behind it. `thin_liquidity: true` means no pool passed Crius’s checks (all are dust, one-sided or implausible), so the price is a fallback and its confidence is `low`. See [Token prices](https://docs.crius.sh/concepts/token-prices/#confidence-and-thin-liquidity). ### OHLCV candle Open, high, low, close and volume for one time bucket, from `1s` to `1d`. Crius returns candles in columnar form (`t`, `o`, `h`, `l`, `c`, `v`, plus `bv`, `n` and `mc`) and keeps outlier trades from setting prices. See [OHLCV candles](https://docs.crius.sh/guides/get-ohlcv-candles/). ### All-time high (ATH) The highest price (`price.ath_usd`) and market cap (`price.ath_market_cap_usd`) a token has reached, with the time (`ath_ts`). It is computed from the token’s credible markets, so a spike in a side pool doesn’t set it. See [All-time high and price change](https://docs.crius.sh/guides/get-all-time-high-and-price-change/). ### Wash trading Volume that isn’t real demand. Crius counts same-transaction round trips (buys and sells of one token in one pool inside one transaction that cancel within 2%) as `wash_volume_usd`, apart from organic `volume_usd`. See [Build a chain stats dashboard](https://docs.crius.sh/guides/build-a-chain-stats-dashboard/). ## Launchpads ### Launchpad A platform that lets anyone create a token in one transaction, usually starting on a bonding curve. Crius attributes tokens to their launchpad (Pons, Flap.sh, Bankr, Long.xyz, Flywheel, King of the Markets) from the factory that created them. See [Launchpads](https://docs.crius.sh/concepts/launchpads/). ### Bonding curve A launchpad contract that sells a new token at a price that rises with each buy, against a quote asset such as ETH. While a token is bonding, the curve is its only market and its price comes from there. See [Track bonding and graduating tokens](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/). ### Graduation The moment a bonding-curve token raises its target and moves to a DEX: the launchpad puts the raised quote and part of the supply into a Uniswap pool, often locking the LP. In the API, `status` changes from `bonding` to `graduated`. See [Launchpads](https://docs.crius.sh/concepts/launchpads/). ### Graduation threshold The amount of quote a curve must raise before the token graduates (`graduation_threshold`, or `progress.threshold` on `/launch`). CHARGE graduated from Pons after raising 4.2 ETH. `progress_pct` shows how close a token is. See [Track bonding and graduating tokens](https://docs.crius.sh/guides/track-bonding-and-graduating-tokens/). ### Creator fee The share of each trade a launchpad pays to the token’s creator, such as `creator_tax_bps: 200` (2%) on a Pons token. `/token/{address}/fees` shows what was earned, who receives it and what was claimed. See [Fees and creator rewards](https://docs.crius.sh/guides/get-token-fees-and-creator-rewards/). ### Snipe tax A high temporary tax some launchpads charge in the first seconds of trading to discourage bots. On Pons it starts at 9,900 bps (99%) and lasts 3 seconds (`fees.snipe_tax` on `/launch`). See [Launchpads](https://docs.crius.sh/concepts/launchpads/). ## Uniswap ### Uniswap v2, v3 and v4 The three Uniswap versions on Robinhood Chain. v2 pairs hold two reserves, v3 pools concentrate liquidity in price ranges, and v4 pools live inside one PoolManager contract and can attach hooks. See [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/). ### PoolManager The single Uniswap v4 contract that holds every v4 pool’s tokens, at `0x8366a39cc670b4001a1121b8f6a443a643e40951` on Robinhood Chain. It often looks like a token’s largest holder; Crius labels it `uniswap_v4_pool_manager` and leaves it out of holder stats. See [Holder classes](https://docs.crius.sh/concepts/holder-classes/). ### Pool id How a pool is identified in the API: the pair or pool contract address for v2 and v3, and a 32-byte id for v4 pools, since they have no contract of their own. See [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/#identifying-pools). ### v4 hook A contract a Uniswap v4 pool calls before or after swaps and liquidity changes. Hooks enable launch taxes and dynamic fees, but a hook can also block swaps, change amounts or stop liquidity removal. Its permissions are encoded in its address. See [Check the risk of a Uniswap v4 hook](https://docs.crius.sh/guides/check-uniswap-v4-hook-risk/). ### Hook tax A fee a v4 hook takes from swaps, on top of the pool’s own fee. Crius measures it from real trades, so it appears in a token’s realized tax even when the token contract itself has no tax. See [Check token taxes](https://docs.crius.sh/guides/check-token-taxes/). ### In-range liquidity The part of a v3 or v4 pool’s liquidity whose price range includes the current price. Only that part can be traded right now, so it is the only part counted in `liquidity_usd`. See [Uniswap v2, v3 & v4](https://docs.crius.sh/concepts/uniswap/#liquidity). ### LP position A liquidity provider’s share of a pool: LP tokens for v2, an NFT position for v3 and v4. Whoever holds it can withdraw the liquidity, which is why lock and burn status matters. See [Check if liquidity is locked](https://docs.crius.sh/guides/check-liquidity-locked/). ## Safety and risk ### Security score A 0–100 summary of a token’s risk from `/token/{address}/security`, starting at 100 with points taken off for each problem. It comes with a `risk` level (`low`, `medium`, `high`, `critical`) and the `flags` that cost points. See [Token security score](https://docs.crius.sh/guides/token-security-score/). ### Honeypot A token you can buy but not sell. Crius flags one when a simulated sell fails, or when 20 or more buys have no sells from anyone but the developer. A honeypot is always `critical` risk. See [Detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/). ### Selective honeypot A token where only the developer has managed to sell (`honeypot.selective: true`). Ordinary buyers are stuck while the developer exits. It costs 60 points in the security score. See [Detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/). ### Buy and sell tax The percentage taken from a buy or a sell, by the token contract or by its pool’s hook (`tax.buy_pct`, `tax.sell_pct`). Over 5% costs 15 points in the security score and over 10% costs 30. See [Check token taxes](https://docs.crius.sh/guides/check-token-taxes/). ### Realized tax Tax measured from real trades over the last 30 days: what the pool sent compared with what the wallet received. `tax.realized.samples` says how many buys and sells it is based on. See [Check token taxes](https://docs.crius.sh/guides/check-token-taxes/). ### Simulated tax Tax measured by simulating a buy, a transfer and a sell at the head block (`tax.simulated`). It covers tokens nobody has sold yet, and a failed simulated sell marks the token as a honeypot. See [Detect a honeypot](https://docs.crius.sh/guides/detect-honeypot/). ### LP lock Liquidity held by a locker contract until a date or forever, so nobody can withdraw it before then. Crius follows the Pons launch locker, UNCX, Team Finance, TitanLocker, HoodLock and others, with the unlock time. See [Check if liquidity is locked](https://docs.crius.sh/guides/check-liquidity-locked/). ### LP burn Liquidity sent to a burn address, which can never be withdrawn. `liquidity.summary.burned_pct` reports the burned share. See [Check if liquidity is locked](https://docs.crius.sh/guides/check-liquidity-locked/). ### Rug pull A token whose team pulls the liquidity or dumps its supply, leaving holders unable to sell at a fair price. The developer profile counts a token as `rugged` when its market cap is under 10% of its ATH (above $5,000) and its liquidity is under $500. See [Check developer history](https://docs.crius.sh/guides/check-developer-history/). ### Renounced ownership An owner that has given up control of the contract (`contract.ownership: "renounced"`). Owner powers such as minting, blacklisting or changing taxes stop counting against the score once nobody owns the contract. See [Token security score](https://docs.crius.sh/guides/token-security-score/). ### Upgradeable proxy A contract whose code can be replaced by its owner, so its rules can change after you buy. The security check reports `is_proxy` and `upgradeable`, and the `upgradeable_proxy` flag costs 15 points. See [Token security score](https://docs.crius.sh/guides/token-security-score/). ### Sniper A wallet that bought within the first 10 blocks after a token’s first trade, about one second on Robinhood Chain. A few snipers holding much of the supply is a warning sign. See [Detect bundles and snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/). ### Bundle Coordinated buying that looks like several buyers but is one actor: one transaction buying for several recipients, a launch transaction that also buys, wallets with a shared funder buying in the same block, or wallets forwarding tokens to a common wallet. See [Detect bundles and snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/). ### Insider launch A launch where a few wallets, including the developer or wallets linked to it, sniped most of the supply. It costs 50 points and always makes the risk `high`. Rebot is an example: four wallets took about 61% of the supply. See [Detect bundles and snipers](https://docs.crius.sh/guides/detect-bundles-and-snipers/). ### Wallet farm Many holder wallets created and funded together by one party, to fake a broad holder base. It costs 50 points and makes the risk `high`. See [Token security score](https://docs.crius.sh/guides/token-security-score/). ### Uniform holders Holder balances that are suspiciously equal, typical of an airdrop to controlled wallets. The security check reports how many of the top holders share the same balance (`launch.uniform_holders`), and the flag costs 30 points. See [Token security score](https://docs.crius.sh/guides/token-security-score/). ### Address poisoning Sending dust from an address that looks like one a victim uses, hoping they copy the wrong address later. Crius ignores such lookalike dust transfers when it links wallets in bubble maps. See [Read a bubble map](https://docs.crius.sh/guides/read-a-bubble-map/). ## Wallets and holders ### Holder An address that holds a token and isn’t infrastructure. Pools, the PoolManager, lockers, burn addresses, hooks, routers and other contracts are left out of holder counts and concentration stats. See [Holder classes](https://docs.crius.sh/concepts/holder-classes/). ### Dev wallet The wallet that created or deployed a token, tagged `dev`. Its holding (`holders.dev_pct`), its early buys and its other launches are some of the strongest risk signals. See [Check developer history](https://docs.crius.sh/guides/check-developer-history/). ### Whale A holder with 1% or more of a token’s total supply, tagged `whale`. Infrastructure such as a pool or locker is never a whale, however much it holds. See [Holder classes](https://docs.crius.sh/concepts/holder-classes/). ### Trader attribution Working out who really traded when a swap was sent by a router, aggregator, solver, bundler or bot contract. Crius makes the address whose balance changed the `trader`, and reports the infrastructure as `executor` and `signer`. See [Trader attribution](https://docs.crius.sh/concepts/attribution/). ### Bubble map A graph of a token’s top holders as nodes, with edges for funding and transfers between them. Linked holders form clusters, which often reveal one party behind many wallets. See [Read a bubble map](https://docs.crius.sh/guides/read-a-bubble-map/). ### Holder cohort The wallets that held a token through a window, such as from the $50k market cap mark until now, above a size threshold. Use it to find holders who didn’t sell. See [Find diamond-hand holders](https://docs.crius.sh/guides/find-diamond-hand-holders/). ### PnL Profit and loss. Crius uses the average-cost method: realized PnL from sells, unrealized PnL from what is still held at the current price, with USD values from trade time. See [How PnL is computed](https://docs.crius.sh/concepts/pnl/). ## Using the API ### API key The secret that identifies your account, sent in the `x-api-key` header. Core endpoints work without one; a free key raises the limits and unlocks more endpoints. See [Authentication & API keys](https://docs.crius.sh/authentication/). ### Anonymous plan Requests without a key: 2 requests per second per IP, on the core endpoints only (prices, token profiles, pools, trades, candles, search, stats, the cached security check). See [Plans, limits & credits](https://docs.crius.sh/plans-and-limits/). ### Credits The unit of usage. Each request costs 1 to 20 credits depending on the endpoint, and each plan includes a monthly amount, shared by all of an account’s keys and reset at the start of each UTC month. The `x-credits-cost` header shows what a request cost. See [Plans, limits & credits](https://docs.crius.sh/plans-and-limits/). ### Rate limit How many requests per second a key (or, without a key, an IP address) can send, with a burst of twice that. Going over returns `429 rate_limited` with a `retry-after` header. See [Plans, limits & credits](https://docs.crius.sh/plans-and-limits/#rate-limit-headers). ### meta.block The latest Robinhood Chain block a response reflects, in every response’s `meta`, next to `block_ts` and `lag_ms`. Use it to cache, to compare two answers, and to cite exactly what your data was based on. See [Responses & conventions](https://docs.crius.sh/conventions/#the-envelope). ### Cursor The token for the next page of a list (`meta.next_cursor`). Pass it back as `cursor`; cursors are opaque and stable. See [Responses & conventions](https://docs.crius.sh/conventions/#pagination). ### WebSocket stream One connection that pushes trades, prices, live candles, launches, graduations, new pools, tax and LP changes and wallet activity as blocks are decoded. It needs a Free key or higher and costs 1 credit per connection. See [WebSocket stream](https://docs.crius.sh/reference/stream/). ## Frequently asked questions **What is a bonding curve on Robinhood Chain?** A launchpad contract that sells a new token at a price that rises with every buy, against a quote asset such as ETH. When the curve has raised its target, the token graduates: the raised liquidity moves into a Uniswap pool and trading continues there. **What is the difference between market cap and FDV?** Market cap is the price times the supply that isn't burned. FDV (fully diluted valuation) is the price times the total supply. On the Crius API they differ only by tokens burned at the zero or dead address. **What does realized tax mean?** The tax buyers and sellers actually paid, measured from real trades: what the pool sent compared with what the wallet received. It catches taxes taken by Uniswap v4 hooks that a contract check alone would miss. ## Related [Concept **Robinhood Chain** What Robinhood Chain is (chain id 4663), its block times, gas, L1 settlement, native assets (ETH, WETH, USDG), tokenized stocks, and how Crius indexes it. Read](https://docs.crius.sh/concepts/robinhood-chain/) [Concept **Launchpads** How token launchpads on Robinhood Chain work (bonding curves, graduation to Uniswap pools, LP locks) and which launchpads Crius attributes, including Pons, Flap.sh, Bankr, Long.xyz and Flywheel. Read](https://docs.crius.sh/concepts/launchpads/) [Concept **Uniswap v2, v3 & v4** How Crius indexes Uniswap v2 pairs, v3 concentrated-liquidity pools and v4 singleton pools with hooks on Robinhood Chain, including liquidity definitions and v4 hook permissions. Read](https://docs.crius.sh/concepts/uniswap/) [Concept **Holder classes** How the Crius API tells real holders from pools, the PoolManager, lockers and contracts, and how it tags devs, snipers, whales and smart accounts. Read](https://docs.crius.sh/concepts/holder-classes/) [Guide **Token security score** Score any Robinhood Chain token from 0 to 100 with one API call. Honeypot, buy and sell taxes, owner powers, LP locks, v4 hook risk and insider launches, with real examples. Read](https://docs.crius.sh/guides/token-security-score/) [Docs **Responses & conventions** The Crius API response envelope, meta block, number and amount formats, timestamps, addresses, pagination, finality levels and liquidity and market-cap definitions. Read](https://docs.crius.sh/conventions/) --- # Report an issue or get help > How to report wrong Robinhood Chain data or a docs issue to Crius, what to include so it can be checked, account and billing help, and the status page. Source: https://docs.crius.sh/support/ · Updated 2026-10-28 Write to **[support@crius.sh](mailto:support@crius.sh)** for anything: data that looks wrong, a docs page that is unclear, account, key and billing questions, or a launchpad you’d like attributed. It is the only support address. Before you write about an outage, check **[status.crius.sh](https://status.crius.sh)**. ## Is it down, or is it me? 1. **Check [status.crius.sh](https://status.crius.sh)** for ongoing incidents and uptime history. 2. **Call `GET /v1/status`.** It is public and needs no key. `status: "live"` with a small `lag_ms` means the index is following the chain; `catching_up` or `stalled` means data is behind for now. See [Service status](https://docs.crius.sh/reference/chain/service-status/). 3. **Read the error code.** A `4xx` with `error.code` usually says exactly what to change (a key, a plan, a parameter). The [errors page](https://docs.crius.sh/errors/) lists every code and what to do about it. ## Report wrong data If a price, holder count, tax, PnL or label looks wrong, tell us. Data reports are the most useful messages we get, and a precise one can be checked the same way you checked it. **[Email a data report](mailto:support@crius.sh?subject=Wrong%20data%3A%20%3Ctoken%20address%3E&body=Endpoint%20and%20full%20request%3A%0A%0Ameta.block%20of%20the%20response%3A%0A%0AWhat%20the%20API%20returned%3A%0A%0AWhat%20you%20expected%2C%20and%20where%20you%20saw%20it%20%28explorer%20link%2C%20tx%20hash%29%3A%0A)**, and include: - **The address**: the full token, pool, wallet or hook address (`0x` and 40 hex characters, or the 32-byte id of a v4 pool). - **The request**: the endpoint and the full path with its query, for example `GET /v1/robinhood/token/0x7b8892cea949bc60d494681d1bc3ea96071ab0b8/holders?limit=5`. Leave out your API key. - **The block**: `meta.block` from the response, so we can look at the chain exactly as the API saw it. If you compared with a specific transaction, add its hash. - **What you expected and why**: the value you think is right and where it comes from: an explorer page ([Etherscan](https://robin.etherscan.io) or [Hoodscan](https://hoodscan.co)), a transaction, the token’s own contract. - **When**: the time you made the request, if `meta.block` isn’t at hand. Every example on this site has a **Data looks wrong? Report it** link that opens an email with the example and its request already filled in. ```text Subject: Wrong data: Request: GET /v1/robinhood/token/
/security meta.block: Returned: Expected: Source: ``` Some values are not wrong, only measured differently from other sites: `liquidity_usd` is 2 × the quote side of a pool, `market_cap_usd` leaves out burned tokens, concentration stats leave out pools and lockers, and candles leave out outlier trades. The [conventions](https://docs.crius.sh/conventions/), [token prices](https://docs.crius.sh/concepts/token-prices/) and [holder classes](https://docs.crius.sh/concepts/holder-classes/) pages explain each. If a number still looks off after reading them, send it anyway. ## Report a docs issue Every page ends with **Report an issue with this page**, which opens an email with the page address filled in. Tell us what was wrong, missing or hard to follow, or **[email a docs issue](mailto:support@crius.sh?subject=Docs%20issue%3A%20%3Cpage%3E&body=Page%20URL%3A%0A%0AWhat%20is%20wrong%20or%20missing%3A%0A)** directly. A broken example, a field that doesn’t match the response or a guide that skips a step are all worth a message. ## Account, keys and billing Most account tasks are self-serve on the [dashboard](https://dashboard.crius.sh): creating, rotating and revoking keys, usage, and plans on the [Billing page](https://dashboard.crius.sh/billing). For anything else, **[email account or billing help](mailto:support@crius.sh?subject=Account%20or%20billing%3A%20%3Cyour%20account%20email%3E)** with: - the email address of your Crius account; - for a key problem, the key’s public **prefix** (the `AbCd1234` part of `crs_live_AbCd1234_…`) and the error code you got; - for a payment, the wallet address you paid from and the transaction hash of the payment on Robinhood Chain. Never send a key’s secret, a seed phrase or a private key: nobody at Crius needs them or will ask for them. A lost key can’t be recovered (only a hash of it is stored), so [rotate it](https://docs.crius.sh/authentication/) instead. Payments are on-chain and final; refunds follow the [refund policy](https://crius.sh/refunds/). For more than the Business plan, or an Enterprise agreement, write to the same address. ## Launchpads and contracts If your launchpad’s tokens show `creation.attribution` other than `known_launchpad`, or a contract of yours has no label, **[email an attribution request](mailto:support@crius.sh?subject=Attribution%20request%3A%20%3Cproject%20name%3E)** with the project’s name and website and every contract address (factory, curve, hook, locker, router). ## What to expect We read every message. We try to reply within a few business days. Data issues sometimes need a fix to the indexer and a re-check of history, so a correction can take longer than the first reply. There is no guaranteed response time. Changes to the API are listed in the [changelog](https://docs.crius.sh/changelog/). If you’ve found a security problem in the API or the dashboard, email it with **Security** in the subject and don’t share it publicly until we’ve answered. ## Frequently asked questions **How do I contact Crius support?** Email [support@crius.sh](mailto:support@crius.sh). It is the only support address, for data issues, docs, accounts, billing and partnerships alike. **How quickly does Crius answer?** We read every message and try to reply within a few business days. A data issue that needs investigation can take longer to fix than to acknowledge. There is no guaranteed response time, so for outages check status.crius.sh first. **Should I send my API key when I report a problem?** No. Never send the secret part of a key, a seed phrase or a private key, and nobody from Crius will ask for them. The key's public prefix (the `AbCd1234` part of `crs_live_AbCd1234_…`) is enough for us to find it. **The API looks down. Where can I check?** status.crius.sh shows uptime and incidents. `GET /v1/status` (public, no key) shows the index's own state: `live`, `catching_up`, `stalled` or `starting`, with the indexed block and the lag behind the chain. ## Related [Docs **Errors** Crius API error format, HTTP status codes and every error code with its meaning and what to do about it. Read](https://docs.crius.sh/errors/) [Docs **FAQ** Answers to common questions about the Crius Robinhood Chain API - pricing, free plan, data freshness, coverage, history, rate limits, payments and support. Read](https://docs.crius.sh/faq/) [Docs **Plans, limits & credits** Crius API plans (Free, Starter, Pro, Business, Enterprise), monthly credits, requests per second, WebSocket limits, credit cost per endpoint and the rate-limit response headers. Read](https://docs.crius.sh/plans-and-limits/) [Docs **Authentication & API keys** How to authenticate Crius API requests with the x-api-key header, key scopes, IP allow-lists, browser origins, expiry, rotation with a grace period, and dashboard sessions. Read](https://docs.crius.sh/authentication/) [API reference **Service status API** Per-chain index health: status (live, catching\_up, stalled, starting), indexed block, lag behind the chain head, safe and finalized blocks, and how many tokens, pools and addresses are indexed. Read](https://docs.crius.sh/reference/chain/service-status/) [Docs **Changelog** Every change to the Crius Robinhood Chain API, the dashboard and the documentation, newest first, with new endpoints, fields and behaviour changes. Read](https://docs.crius.sh/changelog/) ---