From d0ebec203a0c7c412dd421b33ae984c10cfb9e86 Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 19:46:37 +0530 Subject: [PATCH 1/9] Add Robinhood Liquidity & Slippage API page with live-tested queries All 22 queries and both streams verified against streaming.bitquery.io. Fixes composite limitBy pool identity, documents PancakeSwap protocols, price-field semantics, and USD data caveats; adds price watchlist, volatility screener, 5-minute TVL series, and pool-depth screeners. Co-Authored-By: Claude Fable 5 --- .../robinhood/robinhood-liquidity.md | 1441 +++++++++++++++++ 1 file changed, 1441 insertions(+) create mode 100644 docs/blockchain/robinhood/robinhood-liquidity.md diff --git a/docs/blockchain/robinhood/robinhood-liquidity.md b/docs/blockchain/robinhood/robinhood-liquidity.md new file mode 100644 index 00000000..9b098f28 --- /dev/null +++ b/docs/blockchain/robinhood/robinhood-liquidity.md @@ -0,0 +1,1441 @@ +--- +title: "Robinhood Liquidity & Slippage API" +description: "Query & stream Robinhood DEX pool liquidity, TVL, and slippage with Bitquery GraphQL: Uniswap V2/V3/V4 and PancakeSwap reserves, depth, and price impact." +sidebar_position: 3 +keywords: + - Robinhood liquidity API + - Robinhood DEX pool liquidity + - Robinhood slippage API + - Robinhood price impact + - Robinhood TVL API + - Robinhood pool depth + - Robinhood Uniswap V4 liquidity + - Robinhood PancakeSwap liquidity + - Robinhood tokenized stock liquidity + - Robinhood liquidity stream websocket + - Robinhood pool reserves + - DEXPoolEvents Robinhood + - DEXPoolSlippages Robinhood + - Bitquery Robinhood liquidity +--- +# Robinhood Liquidity & Slippage API + +Track **DEX pool liquidity, TVL, and slippage / price impact** on Robinhood with Bitquery GraphQL — across **Uniswap V2 / V3 / V4 and PancakeSwap** pools, including **tokenized stock pairs (AAPL, NVDA)**. Use: + +| Cube | What it returns | +| --- | --- | +| **`DEXPoolEvents`** | Pool reserves, spot prices (A↔B), protocol metadata, and the tx that changed pool state | +| **`DEXPoolSlippages`** | Max trade size and min out at fixed slippage tolerances (0.1%–10%) for both swap directions | + +Both cubes sit on the `EVM` root with `network: robinhood`. For how pool records and price tables are built, see the [DEXPools Cube](/docs/cubes/evm-dexpool/). + +Paste any example below into the [Bitquery IDE](https://ide.bitquery.io/) to run it against live Robinhood data. Every query on this page was executed against the production endpoint before publishing. + +:::warning Realtime dataset only +Robinhood **`DEXPoolEvents`** and **`DEXPoolSlippages`** are available only on **`dataset: realtime`**. + +`archive` and `combined` return errors such as *no archive or API tables found for cube DEXPoolEvent / DEXPoolSlippage*. Always use realtime (or omit `dataset`, which defaults to realtime). +::: + +:::note API Key Required +To query or stream outside the Bitquery IDE, you need an API access token. + +Follow: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: + +:::tip Related docs +- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/) +- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/) +- [DEXPools Cube](/docs/cubes/evm-dexpool/) +- [Base Liquidity API](/docs/blockchain/Base/base-liquidity-api/) +- [Base Slippage API](/docs/blockchain/Base/base-slippage-api/) +::: + +**On this page:** [Latest liquidity](#latest-liquidity-events) · [By pool](#liquidity-for-a-specific-pool) · [By token](#liquidity-for-pools-involving-a-token) · [Protocols](#filter-by-dex-protocol) · [Largest pools](#largest-recent-liquidity-readings-by-usd) · [Price watchlist](#live-price-watchlist-latest-state-per-pool) · [Active pools & ranges](#most-active-pools-and-price-ranges-1-hour-window) · [TVL time series](#pool-tvl-and-price-time-series-5-minute-buckets) · [Stream](#stream-liquidity-updates) · [Slippage](#slippage-and-price-impact) · [FAQ](#faq) + +--- + +## Useful contracts and example pools + +| Item | Value | +| --- | --- | +| Network | `network: robinhood` | +| ETH (native, `CurrencyA` on most V4 pools) | `0x` | +| WETH | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` | +| USDG (Global Dollar) | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` | +| AAPL (Apple · Robinhood Token) | `0xaf3d76f1834a1d425780943c99ea8a608f8a93f9` | +| NVDA (NVIDIA · Robinhood Token) | `0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec` | +| Example Uniswap V4 manager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | +| Example ETH/USDG PoolId (V4) | `0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32` | +| Example USDG/AAPL PoolId (V4) | `0xc748f4671a867db48b552f6b7650bf3255e05f80f00e3f7aad1b17ccb7898fdb` | +| Example CASHCAT/WETH pool (V3) | `0xa70fc67c9f69da90b63a0e4c05d229954574e313` | + +:::note Example pools +The example `PoolId` and pool addresses are **illustrative addresses that were active when this page was last tested**. Meme and long-tail pools can go quiet — replace them with any pool you care about. +::: + +:::tip Pool identity: V2/V3 vs V4 +- **Uniswap V2/V3:** each pool is its own contract — filter with `Pool.SmartContract`; `PoolId` is empty (`0x`). +- **Uniswap V4:** many pools share the same manager `SmartContract` — use **`Pool.PoolId`** to select a specific pool. +- **Mixed sets (rankings, watchlists):** a pool's unique key is the **pair** (`Pool.SmartContract`, `Pool.PoolId`). Deduplicate with `limitBy: { by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId], count: 1 }` so neither family collapses into one row. +::: + +--- + +## How to read pool prices + +Price fields are directional and quoted in the pool's own currencies. For the ETH/USDG V4 pool (`CurrencyA` = ETH, `CurrencyB` = USDG), a live row read: + +| Field | Meaning | Live value | +| --- | --- | --- | +| `AtoBPrice` | Units of **CurrencyA** per 1 **CurrencyB** | `0.000525` (ETH per USDG) | +| `AtoBPriceInUSD` | USD price of 1 **CurrencyB** | `0.998` (USDG ≈ $1) | +| `BtoAPrice` | Units of **CurrencyB** per 1 **CurrencyA** | `1905.83` (USDG per ETH) | +| `BtoAPriceInUSD` | USD price of 1 **CurrencyA** | often `0` (see below) | + +Sanity check: `AtoBPrice × BtoAPrice ≈ 1`. The same convention holds on every pool — on CASHCAT/WETH (V3), `AtoBPrice ≈ 43,072` is CASHCAT per 1 WETH. + +:::note When `*InUSD` is 0 +USD enrichment is not populated for every row — `BtoAPriceInUSD` and the `Liquidity.*InUSD` fields frequently return `0`, especially on V2/V3 pools and non-ETH-quoted pairs. When you have reserves, derive the missing price yourself: `AmountCurrencyAInUSD ÷ AmountCurrencyA` gives the USD price of CurrencyA (≈ $1,902 per ETH in the row above). +::: + +--- + +## Latest liquidity events + +Recent pool updates with reserves and spot prices. Useful for dashboards and pool health monitors. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + Number + } + PoolEvent { + AtoBPrice + AtoBPriceInUSD + BtoAPrice + BtoAPriceInUSD + Dex { + SmartContract + ProtocolName + ProtocolVersion + ProtocolFamily + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Name + Symbol + SmartContract + } + CurrencyB { + Name + Symbol + SmartContract + } + } + } + Transaction { + Hash + From + To + CostInUSD + } + } + } +} +``` + +Example response shape (fields truncated): + +```json +{ + "EVM": { + "DEXPoolEvents": [ + { + "Block": { "Number": "17339306", "Time": "2026-07-23T13:55:06Z" }, + "PoolEvent": { + "AtoBPrice": 0.0005247070221230388, + "AtoBPriceInUSD": 0.9981142611098761, + "BtoAPrice": 1905.8255615234375, + "BtoAPriceInUSD": 0, + "Dex": { + "ProtocolName": "uniswap_v4", + "ProtocolVersion": "4", + "SmartContract": "0x8366a39cc670b4001a1121b8f6a443a643e40951" + }, + "Liquidity": { + "AmountCurrencyA": 152.95826721191406, + "AmountCurrencyAInUSD": 290962.04438267834, + "AmountCurrencyB": 4398114.5, + "AmountCurrencyBInUSD": 0 + }, + "Pool": { + "PoolId": "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32", + "CurrencyA": { "Name": "Ethereum", "SmartContract": "0x", "Symbol": "ETH" }, + "CurrencyB": { "Name": "Global Dollar", "Symbol": "USDG" } + } + } + } + ] + } +} +``` + +Note the `BtoAPriceInUSD: 0` and `AmountCurrencyBInUSD: 0` — real rows carry USD gaps; see [How to read pool prices](#how-to-read-pool-prices). + +--- + +## Liquidity for a specific pool + +### Uniswap V3 pool (by SmartContract) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + PoolEvent: { + Pool: { + SmartContract: { + is: "0xa70fc67c9f69da90b63a0e4c05d229954574e313" + } + } + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + Number + } + PoolEvent { + AtoBPrice + BtoAPrice + Dex { + ProtocolName + ProtocolVersion + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + SmartContract + CurrencyA { + Symbol + SmartContract + } + CurrencyB { + Symbol + SmartContract + } + } + } + Transaction { + Hash + } + } + } +} +``` + +### Uniswap V4 pool (by PoolId) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + PoolEvent: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + Number + } + PoolEvent { + AtoBPrice + AtoBPriceInUSD + BtoAPrice + BtoAPriceInUSD + Dex { + ProtocolName + ProtocolVersion + SmartContract + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Name + Symbol + SmartContract + } + CurrencyB { + Name + Symbol + SmartContract + } + } + } + Transaction { + Hash + From + To + } + } + } +} +``` + +--- + +## Liquidity for pools involving a token + +**Trading / RWA / stablecoins:** find pools where a token is CurrencyA or CurrencyB. Examples: WETH, USDG, AAPL, NVDA. + +### WETH pools + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + any: [ + { + PoolEvent: { + Pool: { + CurrencyA: { + SmartContract: { + is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" + } + } + } + } + } + { + PoolEvent: { + Pool: { + CurrencyB: { + SmartContract: { + is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" + } + } + } + } + } + ] + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + PoolEvent { + AtoBPrice + BtoAPrice + Dex { + ProtocolName + ProtocolVersion + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + SmartContract + } + CurrencyB { + Symbol + SmartContract + } + } + } + Transaction { + Hash + } + } + } +} +``` + +### Tokenized stock pools (AAPL) + +Robinhood tokenized equities trade in ordinary DEX pools. AAPL's most liquid venue at the time of testing was the **USDG/AAPL Uniswap V4 pool** (`PoolId 0xc748f467…`), where `AtoBPrice ≈ 320.79` — the AAPL price quoted in USDG. Swap in the NVDA address (`0xd0601ce1…`) for NVIDIA pools. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + any: [ + { + PoolEvent: { + Pool: { + CurrencyA: { + SmartContract: { + is: "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9" + } + } + } + } + } + { + PoolEvent: { + Pool: { + CurrencyB: { + SmartContract: { + is: "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9" + } + } + } + } + } + ] + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + PoolEvent { + AtoBPrice + BtoAPrice + Dex { + ProtocolName + ProtocolVersion + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Name + Symbol + SmartContract + } + CurrencyB { + Name + Symbol + SmartContract + } + } + } + Transaction { + Hash + } + } + } +} +``` + +### Find pools by token symbol + +When you only know the ticker, filter on `Currency.Symbol`. One latest row per pool via the composite `limitBy`. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { PoolEvent: { Pool: { CurrencyB: { Symbol: { is: "NVDA" } } } } } + limitBy: { by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId], count: 1 } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + PoolEvent { + AtoBPriceInUSD + Dex { + ProtocolName + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + SmartContract + } + CurrencyB { + Name + Symbol + SmartContract + } + } + } + } + } +} +``` + +:::warning Symbols are not unique +Running this exact query returned **two different contracts both claiming the NVDA symbol**: the canonical `NVIDIA • Robinhood Token` (`0xd0601ce1…`) and a copycat named just `NVDA` (`0xdecf74e4…`). Use symbol filters for discovery, then pin the `SmartContract` address in anything that trades. Also check the other side of the pair — the ETH/NVDA pool has NVDA as `CurrencyB`, but flip the filter to `CurrencyA` (or use `any:`) for full coverage. +::: + +--- + +## Filter by DEX protocol + +Isolate one protocol's pool updates — Uniswap V2/V3/V4 or PancakeSwap. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + PoolEvent: { + Dex: { ProtocolName: { is: "uniswap_v4" } } + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + PoolEvent { + Dex { + ProtocolName + ProtocolVersion + ProtocolFamily + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + } + } + } +} +``` + +### Protocol activity breakdown + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + limit: { count: 10 } + orderBy: { descendingByField: "count" } + ) { + PoolEvent { + Dex { + ProtocolName + ProtocolVersion + ProtocolFamily + } + } + count + } + } +} +``` + +Protocols observed on Robinhood pool events when this page was last tested: + +| `ProtocolFamily` | `ProtocolName` | Share of pool events* | +| --- | --- | --- | +| Uniswap | `uniswap_v3` | ~63% | +| Uniswap | `uniswap_v4` | ~29% | +| Uniswap | `uniswap_v2` | ~7% | +| PancakeSwap | `pancake_swap_v3` | under 1% | +| PancakeSwapInfinity | `pancakeswap_infinity` | trace | + +*Share of the realtime window at the time of writing (~16.7M pool updates across ~85,000 pools); it shifts constantly. + +### Network-wide totals + +One-row dashboard stat: total pool updates and distinct pool contracts in the realtime window. `count(distinct: …)` is exact; `uniq(of: …)` is a faster approximate alternative. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents { + updates: count + pools: count(distinct: PoolEvent_Pool_SmartContract) + } + } +} +``` + +Note: this counts distinct **contracts** — every V2/V3 pool individually, while all V4 pools share their manager contract. Count `PoolEvent_Pool_PoolId` instead to enumerate V4 pools. + +--- + +## Largest recent liquidity readings by USD + +**Trading / risk:** rank recent pool **events** by `AmountCurrencyAInUSD` within the realtime window. + +Without `limitBy`, the same busy pool fills the top rows (many updates, one pool). Deduplicate on the **composite pool key** — using `PoolId` alone would merge every V2/V3 pool into a single row, since they all share `PoolId: "0x"`: + +``` +limitBy: { by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId], count: 1 } +``` + +:::note Float filters and USD gaps +`AmountCurrencyAInUSD` / `AmountCurrencyBInUSD` filters expect **Float** values (for example `gt: 10000`), not quoted strings. Because V2/V3 and non-ETH-quoted rows often report `0` USD, a USD threshold effectively ranks the native-ETH V4 pools — combine with token filters, or rank raw amounts per token, when you need the rest. +::: + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + PoolEvent: { + Liquidity: { AmountCurrencyAInUSD: { gt: 10000 } } + } + } + limit: { count: 20 } + limitBy: { by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId], count: 1 } + orderBy: { descending: PoolEvent_Liquidity_AmountCurrencyAInUSD } + ) { + Block { + Time + } + PoolEvent { + AtoBPrice + AtoBPriceInUSD + Dex { + ProtocolName + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + SmartContract + } + CurrencyB { + Symbol + SmartContract + } + } + } + Transaction { + Hash + } + } + } +} +``` + +--- + +## Live price watchlist (latest state per pool) + +One call, one **latest** row per active pool: spot prices both directions plus current reserves in USD. This is the query behind a screener or watchlist page — poll it, or move to the [stream](#stream-liquidity-updates) for push updates. The `gt: 100` USD floor drops dust pools. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { PoolEvent: { Liquidity: { AmountCurrencyAInUSD: { gt: 100 } } } } + limitBy: { by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId], count: 1 } + limit: { count: 30 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + PoolEvent { + AtoBPrice + AtoBPriceInUSD + BtoAPrice + BtoAPriceInUSD + Dex { + ProtocolName + } + Liquidity { + AmountCurrencyAInUSD + AmountCurrencyBInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + } + } + } +} +``` + +--- + +## Most active pools and price ranges (1-hour window) + +**Momentum / volatility screening:** group the last hour of pool events per pool and get update count, price high/low/last, and current TVL — a volatility screener in a single query. + +The `Field(maximum: OtherField)` syntax is an **argmax**: it returns this field's value on the row where `OtherField` is highest. So `AtoBPriceInUSD(maximum: PoolEvent_AtoBPriceInUSD)` is the window high, and `AtoBPriceInUSD(maximum: Block_Number)` is the **latest** price (value at the highest block). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + Block: { Time: { since_relative: { hours_ago: 1 } } } + PoolEvent: { + AtoBPriceInUSD: { gt: 0 } + Liquidity: { AmountCurrencyAInUSD: { gt: 1000 } } + } + } + limit: { count: 10 } + orderBy: { descendingByField: "updates" } + ) { + PoolEvent { + Dex { + ProtocolName + } + Pool { + SmartContract + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + } + updates: count + price_high: PoolEvent { AtoBPriceInUSD(maximum: PoolEvent_AtoBPriceInUSD) } + price_low: PoolEvent { AtoBPriceInUSD(minimum: PoolEvent_AtoBPriceInUSD) } + price_last: PoolEvent { AtoBPriceInUSD(maximum: Block_Number) } + price_avg: average(of: PoolEvent_AtoBPriceInUSD) + tvl_last: PoolEvent { Liquidity { AmountCurrencyAInUSD(maximum: Block_Number) } } + } + } +} +``` + +Live sample from this query — the ETH/NVDA pool over one hour: 413 updates, high `210.52`, low `208.04`, last `209.16` (the tokenized NVIDIA price in USD), TVL ≈ `$44,940`. Meme pools show far wider ranges (an ETH/MARSCOIN pool printed a 2× intra-hour swing). Compute swing % client-side as `(high − low) ÷ low`; use absolute `since:`/`till:` timestamps if you prefer fixed windows. + +--- + +## Pool TVL and price time series (5-minute buckets) + +**Charting / TWAP checks:** bucket one pool's events into intervals with `Time(interval: …)` and take close values via argmax on `Block_Number`. This builds candles for **price and TVL** from pool state — complementary to trade-based OHLCV in [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/). + +Note `orderBy: { descendingByField: "interval_Time" }` — the sort key is the alias plus `_Time`, the name the server generates for the interval field. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolEvents( + where: { + PoolEvent: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + } + Block: { Time: { since_relative: { hours_ago: 2 } } } + } + limit: { count: 24 } + orderBy: { descendingByField: "interval_Time" } + ) { + interval: Block { Time(interval: { count: 5, in: minutes }) } + updates: count + price_avg: average(of: PoolEvent_BtoAPrice) + price_close: PoolEvent { BtoAPrice(maximum: Block_Number) } + tvl_eth_close: PoolEvent { Liquidity { AmountCurrencyA(maximum: Block_Number) } } + tvl_usd_close: PoolEvent { Liquidity { AmountCurrencyAInUSD(maximum: Block_Number) } } + } + } +} +``` + +Live sample (ETH/USDG V4 pool — `BtoAPrice` is USDG per ETH): + +| Interval (UTC) | Updates | Close | Avg | Pool ETH | ETH side USD | +| --- | --- | --- | --- | --- | --- | +| 13:55 | 126 | 1898.60 | 1902.26 | 156.04 | 296,749 | +| 13:50 | 123 | 1905.83 | 1901.66 | 152.96 | 290,961 | +| 13:45 | 84 | 1901.55 | 1904.09 | 160.11 | 304,924 | +| 13:40 | 77 | 1906.09 | 1904.22 | 152.65 | 290,604 | + +The realtime window only reaches back a number of hours — this is for intraday series, not multi-month TVL history. + +--- + +## Stream liquidity updates + +Live pool reserve and spot-price updates for bots and alerting, over GraphQL subscriptions. + +:::warning Filter production streams +Robinhood pool events are frequent. Prefer filters by `PoolId`, `SmartContract`, token, or protocol in production. +::: + +```graphql +subscription { + EVM(network: robinhood) { + DEXPoolEvents( + where: { + PoolEvent: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + } + } + ) { + Block { + Time + Number + } + PoolEvent { + AtoBPrice + BtoAPrice + Dex { + ProtocolName + } + Liquidity { + AmountCurrencyA + AmountCurrencyAInUSD + AmountCurrencyB + AmountCurrencyBInUSD + } + Pool { + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + } + Transaction { + Hash + } + } + } +} +``` + +:::tip WebSocket connection +Connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol (`connection_init` → `connection_ack` → `subscribe`). This exact subscription delivered its first live event within seconds when tested. See [WebSocket authentication](/docs/authorization/websocket/). +::: + +--- + +## Slippage and price impact + +`DEXPoolSlippages` answers: *how much can I trade before I exceed X% price impact?* + +**In this section:** [Latest rows](#latest-slippage-rows) · [Curve for one pool](#slippage-curve-for-one-pool-all-bps-levels) · [1% tolerance](#fixed-tolerance-1--100-bps) · [USDG at 1%](#usdg-pools-at-1-slippage) · [Deepest pools](#deepest-pools-by-executable-trade-size) · [Capacity screeners](#whale-capacity-and-thin-liquidity-screeners) · [Pool stream](#stream-slippage-for-a-pool) · [Screener stream](#stream-a-network-wide-slippage-screener) + +Each row is one slippage level for a pool update: + +| `SlippageBasisPoints` | Tolerance | +| --- | --- | +| 10 | 0.1% | +| 50 | 0.5% | +| 100 | 1% | +| 200 | 2% | +| 500 | 5% | +| 1000 | 10% | +| 0 | Spot / zero-slippage reference (often empty max amounts) | + +For each level you get **AtoB** and **BtoA**: + +- **`MaxAmountIn` / `MaxAmountInInUSD`** — largest input that stays within that slippage +- **`MinAmountOut` / `MinAmountOutInUSD`** — minimum output at that size +- **`Price` / `PriceInUSD`** — average execution price for that size + +### Latest slippage rows + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + limit: { count: 12 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + Number + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + MinAmountOutInUSD + Price + PriceInUSD + } + BtoA { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + MinAmountOutInUSD + Price + PriceInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Name + Symbol + SmartContract + Decimals + } + CurrencyB { + Name + Symbol + SmartContract + Decimals + } + } + Dex { + SmartContract + ProtocolName + ProtocolVersion + ProtocolFamily + } + } + Transaction { + Hash + From + To + } + } + } +} +``` + +### Slippage curve for one pool (all bps levels) + +Pull recent levels for a V4 `PoolId`. Compare `MaxAmountIn` across 10 → 1000 bps to build a depth curve. Rows for all seven levels (0, 10, 50, 100, 200, 500, 1000) come back interleaved. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + where: { + Price: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + Price + } + BtoA { + MaxAmountIn + MinAmountOut + MinAmountOutInUSD + Price + } + Pool { + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +### Fixed tolerance (1% = 100 bps) + +`SlippageBasisPoints` filters use **Int** (`eq: 100`), not strings. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + where: { + Price: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + SlippageBasisPoints: { eq: 100 } + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + Price + } + BtoA { + MaxAmountIn + MinAmountOut + MinAmountOutInUSD + Price + } + } + } + } +} +``` + +### USDG pools at 1% slippage + +**Payments / stablecoin routing:** size trades against USDG pairs at a fixed tolerance. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + where: { + any: [ + { + Price: { + Pool: { + CurrencyA: { + SmartContract: { + is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" + } + } + } + } + } + { + Price: { + Pool: { + CurrencyB: { + SmartContract: { + is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" + } + } + } + } + } + ] + Price: { SlippageBasisPoints: { eq: 100 } } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + } + BtoA { + MaxAmountIn + MinAmountOut + MinAmountOutInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + SmartContract + } + CurrencyB { + Symbol + SmartContract + } + } + Dex { + ProtocolName + ProtocolVersion + } + } + } + } +} +``` + +### Deepest pools by executable trade size + +**Venue routing:** rank pools by how much you can actually trade at 1% impact. Ranking the **raw** `MaxAmountIn` on native-ETH-quoted pools (`CurrencyA` = `0x`) gives a depth leaderboard in ETH terms — "which pool absorbs the most ETH at 1%". One row per pool via composite `limitBy`. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + where: { + Price: { + SlippageBasisPoints: { eq: 100 } + Pool: { CurrencyA: { SmartContract: { is: "0x" } } } + AtoB: { MaxAmountIn: { gt: 0.1, lt: 10000 } } + } + } + limitBy: { by: [Price_Pool_SmartContract, Price_Pool_PoolId], count: 1 } + limit: { count: 10 } + orderBy: { descending: Price_AtoB_MaxAmountIn } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + } + Pool { + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + Name + SmartContract + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +Live sample: ETH/CASHCAT `140.3 ETH` (≈$260k), ETH/dollars `136.8 ETH`, ETH/FIRE `133.1 ETH`, ETH/AnsemCat `118.9 ETH`, down to ETH/SUBT `27.3 ETH` (≈$51k). + +:::warning Degenerate pools report absurd depth +Without the `lt` cap, testing surfaced pools claiming capacity of **850 million ETH** (and USD values in the trillions) — one-sided or broken V4 pools whose curve math degenerates. Keep a sanity band on `MaxAmountIn`, and cross-check any surprising top row against the pool's actual reserves in `DEXPoolEvents` before routing (the sample's own top row — 5,625 ETH against a meme token — deserves exactly that check). The same applies to `MaxAmountInInUSD` screeners: long-tail token USD prices can be wildly inflated. +::: + +### Whale capacity and thin liquidity screeners + +Flip one filter to screen from either side. Pools that can absorb **at least $50k** at 1% (whale-tradeable): + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + DEXPoolSlippages( + where: { + Price: { + SlippageBasisPoints: { eq: 100 } + AtoB: { MaxAmountInInUSD: { ge: 50000 } } + } + } + limitBy: { by: [Price_Pool_SmartContract, Price_Pool_PoolId], count: 1 } + limit: { count: 20 } + orderBy: { descending: Price_AtoB_MaxAmountInInUSD } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountInInUSD + MinAmountOutInUSD + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +For a **thin-liquidity warning list** — pools where even $1k of input breaches 1% impact — change the filter to `AtoB: { MaxAmountInInUSD: { lt: 1000, gt: 0 } }` and order `ascending`. Remember the USD-inflation caveat above when reading either screen. + +### Stream slippage for a pool + +```graphql +subscription { + EVM(network: robinhood) { + DEXPoolSlippages( + where: { + Price: { + Pool: { + PoolId: { + is: "0x54f7883914619af9105355bf83ed678bcf9f63560218ac61c9963b9503d0ba32" + } + } + SlippageBasisPoints: { in: [10, 50, 100, 200, 500, 1000] } + } + } + ) { + Block { + Time + Number + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + Price + } + BtoA { + MaxAmountIn + MinAmountOut + MinAmountOutInUSD + Price + } + Pool { + PoolId + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + } + } + } +} +``` + +### Stream a network-wide slippage screener + +Drop the pool filter and keep one tolerance to watch **every pool's 1% depth** as it changes — the push-based version of the screeners above. This subscription delivered its first event in about a second when tested live. + +```graphql +subscription { + EVM(network: robinhood) { + DEXPoolSlippages( + where: { Price: { SlippageBasisPoints: { eq: 100 } } } + ) { + Block { + Time + } + Price { + SlippageBasisPoints + AtoB { + MaxAmountIn + MaxAmountInInUSD + MinAmountOut + } + Pool { + PoolId + SmartContract + CurrencyA { + Symbol + } + CurrencyB { + Symbol + } + } + Dex { + ProtocolName + } + } + } + } +} +``` + +--- + +## Useful product patterns + +| Goal | Cube | Approach | +| --- | --- | --- | +| Live reserve / TVL monitor | `DEXPoolEvents` | Filter by `PoolId` or token; track `Liquidity.*` on the **short realtime window** or via subscription (not long archive history) | +| Price watchlist / screener page | `DEXPoolEvents` | Composite `limitBy` → one latest row per pool ([query](#live-price-watchlist-latest-state-per-pool)) | +| Volatility / momentum screen | `DEXPoolEvents` | Argmax high/low/last per pool over `since_relative` window ([query](#most-active-pools-and-price-ranges-1-hour-window)) | +| Intraday TVL & price candles | `DEXPoolEvents` | `Time(interval: …)` buckets + argmax close ([query](#pool-tvl-and-price-time-series-5-minute-buckets)) | +| Liquidity add/remove alerts | `DEXPoolEvents` | Stream a pool; alert when reserves jump or drain | +| Trade sizing / RFQ | `DEXPoolSlippages` | Pick bps (e.g. 100); read `MaxAmountIn` / `MinAmountOut` for AtoB and BtoA | +| Best venue for a size | `DEXPoolSlippages` | Rank raw `MaxAmountIn` at fixed bps with a sanity cap ([query](#deepest-pools-by-executable-trade-size)) | +| Whale capacity / thin-liquidity flags | `DEXPoolSlippages` | `MaxAmountInInUSD` `ge` / `lt` screeners at 100 bps | +| RWA / tokenized stock depth (AAPL, NVDA) | both | Token filter on the stock token; pair with USDG/ETH pools | +| Protocol share | `DEXPoolEvents` | Aggregate `count` by `Dex.ProtocolName` (realtime window only) | + +:::tip Interpreting a slippage row +If you want to sell up to `MaxAmountIn` of CurrencyA for CurrencyB at 1% impact, use the **AtoB** fields on the `SlippageBasisPoints: 100` row. `MinAmountOut` is the guaranteed CurrencyB received at that size. See also the [slippage FAQ](/docs/API-Blog/slippage-faq-using-dexpool-stream/). +::: + +--- + +## Response fields (quick reference) + +### DEXPoolEvents + +| Group | Fields | +| --- | --- | +| **Liquidity** | `AmountCurrencyA`, `AmountCurrencyB`, `AmountCurrencyAInUSD`, `AmountCurrencyBInUSD` | +| **Prices** | `AtoBPrice` (A per 1 B), `BtoAPrice` (B per 1 A), `AtoBPriceInUSD` (USD price of B), `BtoAPriceInUSD` (USD price of A) — see [How to read pool prices](#how-to-read-pool-prices) | +| **Pool** | `PoolId`, `SmartContract`, `CurrencyA.*`, `CurrencyB.*` | +| **Dex** | `ProtocolName`, `ProtocolVersion`, `ProtocolFamily`, `SmartContract` | + +### DEXPoolSlippages + +| Group | Fields | +| --- | --- | +| **Level** | `SlippageBasisPoints` | +| **AtoB / BtoA** | `MaxAmountIn`, `MinAmountOut`, `Price`, plus `*InUSD` variants | +| **Pool / Dex** | Same identity fields as pool events | + +Aggregations available on both cubes: `count` (with `distinct:`/`if:`), `sum`, `average`, `median`, `quantile`, `standard_deviation`, `uniq`, plus per-field argmax/argmin via `Field(maximum: Other_Field)` / `Field(minimum: Other_Field)`. + +--- + +## Tips + +1. Always use **`dataset: realtime`** for Robinhood liquidity and slippage (archive/combined are not supported). Use these cubes for **live and short-window** monitoring, not multi-month TVL history. +2. A pool's identity is the pair **(`Pool.SmartContract`, `Pool.PoolId`)**: filter with `SmartContract` for V2/V3 and `PoolId` for V4, and always deduplicate mixed sets with the composite `limitBy` — `by: [PoolEvent_Pool_SmartContract, PoolEvent_Pool_PoolId]` (V2/V3 pools all share `PoolId: "0x"`; V4 pools all share the manager contract). +3. Use **Float** for USD liquidity filters (`gt: 10000`) and **Int** for `SlippageBasisPoints` (`eq: 100`). +4. Treat `*InUSD: 0` as "USD unknown" (common on V2/V3 and non-ETH-quoted rows) and treat extreme `*InUSD` values on long-tail tokens as suspect — size with raw token amounts and sanity caps, and derive prices from `AmountCurrencyAInUSD ÷ AmountCurrencyA` when needed. +5. Window queries with `Block: { Time: { since_relative: { hours_ago: 1 } } }` (or absolute `since:`/`till:` ISO timestamps). +6. Filter WebSocket subscriptions by pool, token, or protocol — unfiltered streams are very noisy. Connect with the `graphql-transport-ws` subprotocol and the token in the URL ([WebSocket auth](/docs/authorization/websocket/)). +7. Symbol filters (`Currency.Symbol`) are handy for discovery but **symbols are not unique** — pin `SmartContract` addresses in production. +8. Combine with [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/) for execution prints and [Transfers](/docs/blockchain/robinhood/robinhood-transfers/) for token movements around LP activity. + +--- + +## FAQ + +### Is Robinhood liquidity available in archive history? + +No. `DEXPoolEvents` and `DEXPoolSlippages` on Robinhood work only with the **realtime** dataset. Archive and combined queries error. Build live monitors and short-window views here — not long historical TVL series from these cubes. + +### How do I choose between DEXPoolEvents and DEXPoolSlippages? + +Use **DEXPoolEvents** for current reserves and spot price after each pool update. Use **DEXPoolSlippages** when you need trade-size capacity and price impact at standard slippage tolerances. + +### How do I size a swap with 1% max impact? + +Query `DEXPoolSlippages` with `SlippageBasisPoints: { eq: 100 }` for your pool. Read `AtoB.MaxAmountIn` / `MinAmountOut` (or `BtoA` for the opposite direction). + +### How do I find the deepest pool to trade a token? + +Rank `DEXPoolSlippages` rows at a fixed tolerance by `MaxAmountIn` (raw units, with a sanity cap) or `MaxAmountInInUSD`, deduplicated per pool — see [Deepest pools by executable trade size](#deepest-pools-by-executable-trade-size). Cross-check winners against reserves in `DEXPoolEvents`. + +### Can I get a TVL or price time series for a Robinhood pool? + +Yes, within the realtime window: bucket `DEXPoolEvents` with `Time(interval: { count: 5, in: minutes })` and take closes via `Field(maximum: Block_Number)` — see [the time-series query](#pool-tvl-and-price-time-series-5-minute-buckets). For longer trade-based OHLCV history, use the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades/). + +### Which DEX protocols run on Robinhood? + +Pool events at the time of testing came from `uniswap_v3` (~63%), `uniswap_v4` (~29%), `uniswap_v2` (~7%), plus small shares of `pancake_swap_v3` and `pancakeswap_infinity`. Run the [protocol breakdown query](#protocol-activity-breakdown) for current numbers. + +### Why are some USD fields 0 — or absurdly large? + +USD enrichment covers mainly native-ETH-quoted pools; V2/V3 and exotic pairs often report `0`, and broken or one-sided pools can report inflated USD capacity (test runs saw trillion-dollar readings on meme pools). Prefer raw token amounts with sanity bounds, and derive USD from reserves where needed. + +### Why is PoolId `0x` on some rows? + +V2/V3 pools leave `PoolId` empty and identify the pool via `Pool.SmartContract`. V4 pools use a non-zero `PoolId` under a shared manager contract. From cd7ee8400b4d61876954b86189d041f13ab32225 Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:02:36 +0530 Subject: [PATCH 2/9] Rework Robinhood Transfers API page with live-tested queries All 31 queries and 3 subscriptions verified against streaming.bitquery.io. Corrects realtime-window claims (~4 days observed, variable), documents native-ETH-only AmountInUSD enrichment, exclusive Date after/before bounds, and symbol collisions; fixes top-tokens ranking to count-based; adds tokenized stock section (NVDA), token activity pulse, transfer size stats, daily volume series, dataset-window probe, and wallet-tracker stream. Co-Authored-By: Claude Fable 5 --- .../robinhood/robinhood-transfers.md | 1506 ++++++++++++++++- 1 file changed, 1463 insertions(+), 43 deletions(-) diff --git a/docs/blockchain/robinhood/robinhood-transfers.md b/docs/blockchain/robinhood/robinhood-transfers.md index 317ec311..c6b7e793 100644 --- a/docs/blockchain/robinhood/robinhood-transfers.md +++ b/docs/blockchain/robinhood/robinhood-transfers.md @@ -1,30 +1,115 @@ --- -title: "Robinhood Transfers API" -description: "Robinhood Transfers API: monitor Robinhood native and token transfers in real time with Bitquery GraphQL APIs. Keep queries fast with indexed filters." +title: "Robinhood Transfers API & Streams" +description: "Query & stream Robinhood transfers with Bitquery GraphQL: ETH, USDG, tokenized stocks (AAPL, NVDA), whale alerts, wallet ledgers, and compliance monitors." sidebar_position: 2 keywords: - - Robinhood transfers API + - Robinhood Transfers API - Robinhood token transfers - - EVM Transfers Robinhood - - Robinhood wallet transfers - - Robinhood token transfers api - - Robinhood wallet transfers api + - Robinhood ETH transfers + - Robinhood whale transfers + - Robinhood wallet transfers GraphQL + - Robinhood USDG transfers + - Robinhood WETH transfers + - Robinhood tokenized stock transfers + - Robinhood NVDA transfers + - Robinhood RWA token transfers + - Robinhood transfer volume API + - Robinhood daily transfer volume + - stream Robinhood transfers --- -# Robinhood Transfers +# Robinhood Transfers API & Streams -Bitquery exposes **Robinhood** transfer data through the **EVM Transfers** APIs. Use `network: robinhood` on the `EVM` root to scope queries and subscriptions to Robinhood. +Use the **Robinhood Transfers API** to query and stream on-chain transfers on Robinhood with Bitquery GraphQL (`network: robinhood` on `EVM`). This is the shared **EVM Transfers** cube scoped to Robinhood — not a separate schema. + +Track native ETH, WETH, stablecoins such as USDG, **tokenized stocks (AAPL, NVDA, GOOGL, GME)**, and meme-token movements in real time or across historical windows. Build whale alerts, address ledgers, transfer-volume dashboards, and compliance monitors from the same cube. Every query on this page was executed against the production endpoint before publishing, and each subscription was verified live over WebSocket. + +| Use case | What you can build | +| --- | --- | +| **Trading / desks** | Whale alerts, large ETH moves, hourly volume, liquidity-hub flows | +| **DeFi / bots** | Token transfer feeds, WETH wrap/unwrap, router counterparties | +| **Accounting / portfolio** | Inbound vs outbound, sent/received volume by token, date-range ledgers | +| **Compliance / forensics** | Address timelines, top counterparties, failed transfers, address-pair flows | +| **Token analytics** | Most-transferred tokens, transfer size stats, daily volume, unique senders/receivers | + +**On this page:** [Stream](#stream-real-time-transfers) · [Latest](#latest-transfers) · [By token](#transfers-for-a-specific-token) · [Token pulse](#latest-transfer-per-token-activity-pulse) · [USDG](#usdg-stablecoin-transfers) · [Tokenized stocks](#tokenized-stock-transfers-aapl-nvda) · [By address](#transfers-for-an-address) · [Whales](#whale-transfers-by-usd-value) · [Top tokens](#most-transferred-tokens-24h) · [Size stats](#eth-transfer-size-statistics-24h) · [Daily volume](#daily-transfer-volume-7-days) · [Historical](#historical-transfers-by-date) · [FAQ](#faq) + +:::note API Key Required +To query or stream data outside the Bitquery IDE, you need an API access token. + +Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorization/how-to-generate/) +::: :::tip Related docs +- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/) +- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity/) +- [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply/) +- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches/) +- [EVM Transfers schema](/docs/schema/evm/transfers/) - [ERC20 Token Transfers API (Ethereum)](/docs/blockchain/Ethereum/transfers/erc20-token-transfer-api/) -- [EVM Transfers](/docs/schema/evm/transfers/) -- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades) +- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/) +::: + +--- + +## Network and useful contracts + +| Item | Value | +| --- | --- | +| GraphQL network | `network: robinhood` on `EVM` | +| Native currency | ETH (`Currency.Native: true`, `SmartContract: "0x"`) | +| WETH | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` | +| USDG (Global Dollar) | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` | +| AAPL (Apple · Robinhood Token) | `0xaf3d76f1834a1d425780943c99ea8a608f8a93f9` | +| NVDA (NVIDIA · Robinhood Token) | `0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec` | +| FREN (example meme token) | `0xd387e5bba711457faf4d013d20e02e8c91f07fa4` | +| Zero address (wrap/unwrap, mint/burn) | `0x0000000000000000000000000000000000000000` | +| Example address used below | `0xcaf681a66d020601342297493863e78c959e5cb2` | + +:::note Example addresses +`0xcaf681a6…` is a **high-activity address** on Robinhood (often involved in routing/liquidity flows). Treat it as a sample — replace it with any wallet or contract you want to track. FREN is an illustrative meme token and may change over time. +::: + +`Transfer.Type` commonly returns `token` (ERC-20 log), `call` (internal value move), or `transaction` (top-level ETH value). + +:::tip AmountInUSD on Robinhood transfers +In practice **only native ETH carries a populated `AmountInUSD`** on this cube. Verified over a 24h window: 6.6M WETH transfers and 2.4M USDG transfers both summed to `$0` USD. Consequences: + +- USD thresholds and USD rankings effectively select **ETH flows only**. +- For USDG, treat `Transfer.Amount` as ≈ USD (it is a dollar stablecoin). +- For every other token (including tokenized stocks), filter and rank by `Transfer.Amount` in token units. ::: +:::tip Choosing a dataset +- **`realtime`** — a rolling window of recent blocks. Its depth **varies**: at the time of testing it held ~4 days (~110M transfers), but it can be much shorter. Don't assume a fixed depth. +- **`combined`** — archive + realtime union. The safe choice for any fixed window (24h, 48h, 7d). +- **`archive`** — full history; its head lags the chain by minutes (observed ~30 minutes). Unlike the [liquidity cubes](/docs/blockchain/robinhood/robinhood-liquidity/), Transfers **does** support archive. +::: + +### Check the dataset window + +Don't guess the realtime depth — measure it. `Time(minimum: …)` / `Time(maximum: …)` return the bounds of whatever the dataset currently holds (swap in `archive` to see the archive head). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers { + count + earliest: Block { Time(minimum: Block_Time) } + latest: Block { Time(maximum: Block_Time) } + } + } +} +``` + --- -## Stream Real time Transfers on Robinhood +## Stream real-time transfers + +Stream live transfers for dashboards, bots, and alerting. -Stream real time transfers on Robinhood via a GraphQL subscription on `EVM.Transfers`. +:::warning Filter live streams +Robinhood transfer volume is very high (tested: an unfiltered stream delivered its first batch in about a second). Prefer a `where` filter (token, address, or `AmountInUSD`) in production. An unfiltered subscription is fine for exploration, but it can overwhelm clients and burn stream quota. +::: ▶️ [Run in IDE](https://ide.bitquery.io/real-time-transfers-on-robinhood) @@ -37,6 +122,8 @@ subscription { AmountInUSD Sender Receiver + Type + Success Currency { Name Symbol @@ -58,11 +145,105 @@ subscription { } ``` +:::tip WebSocket connection +Connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol (`connection_init` → `connection_ack` → `subscribe`). Events arrive in per-block batches. See [WebSocket authentication](/docs/authorization/websocket/). +::: + +### Stream whale transfers (USD threshold) + +Alert when a successful transfer exceeds a USD size. Exclude the zero address to skip wrap/unwrap and mint/burn noise. Because USD is populated for native ETH, this is effectively a **large ETH move alert** — when tested live it caught a $13.7k ETH transfer within seconds. + +```graphql +subscription { + EVM(network: robinhood) { + Transfers( + where: { + Transfer: { + AmountInUSD: { gt: "10000" } + Success: true + Sender: { not: "0x0000000000000000000000000000000000000000" } + Receiver: { not: "0x0000000000000000000000000000000000000000" } + } + } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + Native + SmartContract + } + } + Transaction { + Hash + From + To + } + Block { + Number + Time + } + } + } +} +``` + +### Stream transfers for an address (wallet tracker) + +Watch one wallet's inbound and outbound transfers live — the core of a wallet tracker or deposit monitor. Replace the sample address with yours. + +```graphql +subscription { + EVM(network: robinhood) { + Transfers( + where: { + any: [ + { + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + } + } + { + Transfer: { + Receiver: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + } + } + ] + Transfer: { Success: true } + } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Type + Currency { + Symbol + SmartContract + Native + } + } + Transaction { + Hash + } + Block { + Time + Number + } + } + } +} +``` + --- -## Latest Transfers on Robinhood +## Latest transfers -Query the most recent transfers on Robinhood that contains details such as transfer amount, amount in USD, token details, sneder and reciever address, tansfer time and transaction hash. +Query the most recent transfers with amount, USD value, token metadata, sender, receiver, time, and transaction hash. ▶️ [Run in IDE](https://ide.bitquery.io/latest-transfers-on-robinhood) @@ -78,30 +259,113 @@ Query the most recent transfers on Robinhood that contains details such as trans AmountInUSD Sender Receiver + Type + Success Currency { Name Symbol SmartContract + Native } } Transaction { Hash + From + To } Block { Time + Number } } } } ``` +Example response shape: + +```json +{ + "EVM": { + "Transfers": [ + { + "Block": { + "Number": "17306406", + "Time": "2026-07-23T13:00:09Z" + }, + "Transaction": { + "From": "0x8c72ce85b70972de417919a8f999145e6d9bd303", + "Hash": "0x1a60e55cddedbd7534eea1e721a59a6abd8ce1e68c06313272621eaf9958488b", + "To": "0xcaf681a66d020601342297493863e78c959e5cb2" + }, + "Transfer": { + "Amount": "0.020000000000000000", + "AmountInUSD": "38.05729248046875", + "Currency": { + "Name": "Ethereum", + "Native": true, + "SmartContract": "0x", + "Symbol": "ETH" + }, + "Receiver": "0x0bd7d308f8e1639fab988df18a8011f41eacad73", + "Sender": "0xcaf681a66d020601342297493863e78c959e5cb2", + "Success": true, + "Type": "call" + } + } + ] + } +} +``` + --- -## Transfers for a specific token +## Native ETH transfers -Bitquery's Robinhood API allows us to fetch latest transfers for a specific token by filtering based on `Transfer.Currency.SmartContract` field. +Useful for gas/treasury monitoring and large native ETH value moves (`Type` is often `call` or `transaction`). -▶️ [Run in IDE](https://ide.bitquery.io/Transfers-for-a-token-on-robinhood) +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Currency: { Native: true } + Success: true + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Type + Currency { + Symbol + Native + } + } + Transaction { + Hash + From + To + } + Block { + Time + } + } + } +} +``` + +--- + +## Token transfers (exclude native ETH) + +Track ERC-20 style movements — WETH, USDG, tokenized stocks, meme tokens — without native ETH noise. ```graphql { @@ -109,9 +373,8 @@ Bitquery's Robinhood API allows us to fetch latest transfers for a specific toke Transfers( where: { Transfer: { - Currency: { - SmartContract: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } - } + Currency: { Native: false } + Success: true } } limit: { count: 10 } @@ -122,6 +385,7 @@ Bitquery's Robinhood API allows us to fetch latest transfers for a specific toke AmountInUSD Sender Receiver + Type Currency { Name Symbol @@ -141,21 +405,23 @@ Bitquery's Robinhood API allows us to fetch latest transfers for a specific toke --- -## Transfers for a Wallet on Robinhood +## Transfers for a specific token -We can filter out transfers involving a specific wallet, where the target address is either `Transfer.Sender` or `Transfer.Receiver`. +Filter with `Transfer.Currency.SmartContract`. Example: WETH on Robinhood. -▶️ [Run in IDE](https://ide.bitquery.io/transfers-for-a-wallet-on-Robinhood) +▶️ [Run in IDE](https://ide.bitquery.io/Transfers-for-a-token-on-robinhood) ```graphql { EVM(network: robinhood, dataset: realtime) { Transfers( where: { - any: [ - {Transfer: {Sender: {is: "0xcaf681a66d020601342297493863e78c959e5cb2"}}} - {Transfer: {Receiver: {is: "0xcaf681a66d020601342297493863e78c959e5cb2"}}} - ] + Transfer: { + Currency: { + SmartContract: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } + } + Success: true + } } limit: { count: 10 } orderBy: { descending: Block_Time } @@ -182,34 +448,108 @@ We can filter out transfers involving a specific wallet, where the target addres } ``` +### Multiple tokens in one query + +Monitor a watchlist (WETH + a meme token) with `SmartContract.in`. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Currency: { + SmartContract: { + in: [ + "0x0bd7d308f8e1639fab988df18a8011f41eacad73" + "0xd387e5bba711457faf4d013d20e02e8c91f07fa4" + ] + } + } + Success: true + } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + Sender + Receiver + Currency { + Symbol + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + --- - +``` + +### USDG 24h activity summary + +Use `dataset: combined` so the full 24h window is covered regardless of the current realtime depth. When tested this returned **2.4M USDG transfers moving over $1B (1.045B USDG) between ~17k senders and ~18k receivers in one day**. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Currency: { + SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } + } + Success: true + } + } + ) { + count + amount: sum(of: Transfer_Amount) + receivers: uniq(of: Transfer_Receiver) + senders: uniq(of: Transfer_Sender) + } + } +} +``` + +--- + +## Tokenized stock transfers (AAPL, NVDA) + +**Trading / custody:** monitor tokenized equity movements. Robinhood's stock tokens are ordinary ERC-20s here — AAPL below; swap in NVDA (`0xd0601ce1…`) or any other. Live testing also saw GOOGL, GME, INTC, and SNDK tokens moving. `AmountInUSD` is `0` for these, so read `Transfer.Amount` as the **share count**. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Currency: { + SmartContract: { is: "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9" } + } + Success: true + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Name + Symbol + SmartContract + } + } + Transaction { + Hash + From + To + } + Block { + Time + Number + } + } + } +} +``` + +:::warning Ticker symbols are not unique +The 24h most-transferred list surfaced **two different contracts both using the GME symbol** (`0x1b0e319c…` and `0xc2362aff…`). Always resolve and pin the `SmartContract` address (the canonical Robinhood stock tokens are named like `NVIDIA • Robinhood Token`) instead of trusting a ticker. +::: + +--- + +## Transfers for an address + +Filter where the address is either `Transfer.Sender` or `Transfer.Receiver` to build a full transfer history. Replace the sample address with your wallet or contract. + +▶️ [Run in IDE](https://ide.bitquery.io/transfers-for-a-wallet-on-Robinhood) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + any: [ + { + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + } + } + { + Transfer: { + Receiver: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + } + } + ] + Transfer: { Success: true } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Name + Symbol + SmartContract + Native + } + } + Transaction { + Hash + From + To + } + Block { + Time + Number + } + } + } +} +``` + +### Inbound only (deposits) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Receiver: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Success: true + } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + Native + SmartContract + } + } + Transaction { + Hash + From + To + } + Block { + Time + Number + } + } + } +} +``` + +### Outbound only (withdrawals) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Success: true + } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + Native + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + +--- + +## Whale transfers by USD value + +**Trading / compliance:** find the largest successful transfers by `AmountInUSD`, excluding zero-address wrap/unwrap and mint/burn rows. Since only native ETH carries USD, this surfaces **large ETH moves** (top row in testing: a $4.8M ETH transfer). For token whales, use raw-amount thresholds like the [meme-token example](#large-meme-token-transfers-by-token-amount). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + AmountInUSD: { gt: "10000" } + Success: true + Sender: { not: "0x0000000000000000000000000000000000000000" } + Receiver: { not: "0x0000000000000000000000000000000000000000" } + } + } + limit: { count: 20 } + orderBy: { descending: Transfer_AmountInUSD } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Type + Currency { + Symbol + Native + SmartContract + } + } + Transaction { + Hash + From + To + } + Block { + Time + Number + } + } + } +} +``` + +### Large top-level ETH value transfers + +`Transfer.Type: transaction` focuses on ETH moved as the transaction value (typical for large treasury moves). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Type: { is: transaction } + Success: true + AmountInUSD: { gt: "100" } + } + } + limit: { count: 10 } + orderBy: { descending: Transfer_AmountInUSD } + ) { + Transfer { + Amount + AmountInUSD + Type + Sender + Receiver + Currency { + Symbol + Native + } + } + Transaction { + Hash + From + To + } + Block { + Time + } + } + } +} +``` + +--- + +## Large meme-token transfers (by token amount) + +When `AmountInUSD` is `0`, rank by raw `Transfer.Amount`. Example uses FREN (`0xd387e5bba711457faf4d013d20e02e8c91f07fa4`). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Currency: { + SmartContract: { is: "0xd387e5bba711457faf4d013d20e02e8c91f07fa4" } + } + Amount: { gt: "1000000" } + Success: true + } + } + limit: { count: 20 } + orderBy: { descending: Transfer_Amount } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + +--- + +## WETH wrap/unwrap and mint/burn (zero address) + +**DeFi / supply:** on Robinhood, transfers from or to the zero address are most often **WETH wrap/unwrap**. For other tokens they can also represent mints or burns. Filter by `Currency.SmartContract` when you care about one asset. + +### From zero (wrap-in / mint) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Sender: { is: "0x0000000000000000000000000000000000000000" } + Currency: { Native: false } + Success: true + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Name + Symbol + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + +### To zero (unwrap / burn) + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Receiver: { is: "0x0000000000000000000000000000000000000000" } + Currency: { Native: false } + Success: true + } + } + limit: { count: 10 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + Sender + Receiver + Currency { + Name + Symbol + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + +--- + +## Transfers between two addresses + +**Compliance / accounting:** activity between two addresses (example: high-activity sample address ↔ WETH). Replace either side with the pair you care about. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + any: [ + { + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Receiver: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } + } + } + { + Transfer: { + Sender: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } + Receiver: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + } + } + ] + Transfer: { Success: true } + } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + Native + } + } + Transaction { + Hash + } + Block { + Time + } + } + } +} +``` + +--- + +## Address volume: sent vs received + +**Accounting / tax / portfolio:** aggregate transfer counts and volumes for an address over the last 24 hours. Results group by currency. Use `combined` so the full day is covered regardless of realtime depth. Replace the sample address with yours. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + sent: Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Success: true + } + } + limit: { count: 50 } + orderBy: { descendingByField: "usd" } + ) { + Transfer { + Currency { + Symbol + SmartContract + Native + } + } + count + usd: sum(of: Transfer_AmountInUSD) + amount: sum(of: Transfer_Amount) + } + received: Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Receiver: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Success: true + } + } + limit: { count: 50 } + orderBy: { descendingByField: "usd" } + ) { + Transfer { + Currency { + Symbol + SmartContract + Native + } + } + count + usd: sum(of: Transfer_AmountInUSD) + amount: sum(of: Transfer_Amount) + } + } +} +``` + +--- + +## Top counterparties for an address + +**Compliance / AML:** who received the most USD volume from an address in the last 24 hours. The `AmountInUSD > 0` filter limits this to native ETH flows; drop it and rank `count` (or per-token `amount`) to include token counterparties. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Sender: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } + Success: true + AmountInUSD: { gt: "0" } + } + } + limit: { count: 20 } + orderBy: { descendingByField: "usd" } + ) { + Transfer { + Receiver + Currency { + Symbol + Native + } + } + count + usd: sum(of: Transfer_AmountInUSD) + } + } +} +``` + +--- + +## Most transferred tokens (24h) + +**Trading / market structure:** rank currencies by **transfer count**. Ranking by summed USD only works for native ETH (every other token sums to `0`), so activity count is the meaningful network-wide leaderboard; USD volume is kept as a secondary column. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { Success: true } + } + limit: { count: 20 } + orderBy: { descendingByField: "transfers" } + ) { + Transfer { + Currency { + Name + Symbol + SmartContract + Native + } + } + transfers: count + usd_volume: sum(of: Transfer_AmountInUSD) + senders: uniq(of: Transfer_Sender) + } + } +} +``` + +Live 24h sample when tested — note the tokenized stocks in the top ranks, and **two distinct GME contracts**: + +| Token | Transfers | Unique senders | +| --- | --- | --- | +| ETH (native) | 8.90M | 227,568 | +| WETH | 6.64M | 56,850 | +| USDG | 2.40M | 16,872 | +| GME (`0x1b0e319c…`) | 1.09M | 1,558 | +| NVDA | 625k | 2,359 | +| GME (`0xc2362aff…`) | 573k | 14,505 | +| SPCX | 535k | 1,700 | +| GOOGL | 409k | 1,388 | + +--- + +## Top receivers by ETH inflow (liquidity hubs) + +**DeFi / trading:** addresses receiving the most native ETH (USD) in 24 hours — often routers, pools, or bridges. Use `combined` for the full 24h window. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Success: true + Currency: { Native: true } + AmountInUSD: { gt: "0" } + } + } + limit: { count: 20 } + orderBy: { descendingByField: "usd_in" } + ) { + Transfer { + Receiver + } + count + usd_in: sum(of: Transfer_AmountInUSD) + } + } +} +``` + +--- + +## Token accumulation: top receivers of a meme token + +**Trading / analytics:** who accumulated the most units of a token over a window (exclude zero address). Use `combined` for a 48h window. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 48 } } } + Transfer: { + Currency: { + SmartContract: { is: "0xd387e5bba711457faf4d013d20e02e8c91f07fa4" } + } + Success: true + Receiver: { not: "0x0000000000000000000000000000000000000000" } + } + } + limit: { count: 20 } + orderBy: { descendingByField: "amount" } + ) { + Transfer { + Receiver + Currency { + Symbol + SmartContract + } + } + count + amount: sum(of: Transfer_Amount) + } + } +} +``` + +--- + +## Unique senders and receivers for a token + +**Distribution / compliance:** count distinct participants for WETH over 24 hours. Tested result: 6.64M transfers between ~57k senders and ~51k receivers (and `usd: 0` — WETH carries no USD enrichment; see [the USD note](#network-and-useful-contracts)). + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Currency: { + SmartContract: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } + } + Success: true + } + } + ) { + count + receivers: uniq(of: Transfer_Receiver) + senders: uniq(of: Transfer_Sender) + usd: sum(of: Transfer_AmountInUSD) + } + } +} +``` + +--- + +## ETH transfer size statistics (24h) + +**Market microstructure:** distribution stats for native ETH transfer sizes — average, median, and 90th percentile in one aggregate call. Tested values: 8.9M ETH transfers in 24h totalling **$1.19B**, average **$133**, median **$13.88**, p90 **$237** from ~228k senders (a long-tail distribution — the average sits far above the median). + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 24 } } } + Transfer: { + Currency: { Native: true } + Success: true + AmountInUSD: { gt: "0" } + } + } + ) { + count + total_usd: sum(of: Transfer_AmountInUSD) + avg_usd: average(of: Transfer_AmountInUSD) + median_usd: median(of: Transfer_AmountInUSD) + p90_usd: quantile(of: Transfer_AmountInUSD, level: 0.9) + senders: uniq(of: Transfer_Sender) + } + } +} +``` + +Also available: `standard_deviation`, other `quantile` levels, and `count(distinct: …)` for exact distinct counts (`uniq` is approximate). + +--- + +## Hourly ETH transfer volume + +**Trading / ops:** time series of native ETH transfer count and USD volume (12 hours). Use `combined` so the whole window is covered. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 12 } } } + Transfer: { + Currency: { Native: true } + Success: true + AmountInUSD: { gt: "0" } + } + } + orderBy: { ascendingByField: "Block_Time" } + limit: { count: 12 } + ) { + Block { + Time(interval: { in: hours, count: 1 }) + } + count + usd: sum(of: Transfer_AmountInUSD) + eth: sum(of: Transfer_Amount) + } + } +} +``` + +--- + +## Daily transfer volume (7 days) + +**Dashboards:** one row per day — total transfers, ETH-denominated USD volume, and how many distinct tokens moved. Live sample when tested: + +| Day | Transfers | USD volume (native ETH) | Active tokens | +| --- | --- | --- | --- | +| 2026-07-22 | 29.7M | $1.21B | 60,365 | +| 2026-07-21 | 28.2M | $1.26B | 62,836 | +| 2026-07-20 | 24.3M | $1.17B | 52,488 | +| 2026-07-19 | 18.4M | $0.95B | 42,234 | + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { Time: { since_relative: { days_ago: 7 } } } + Transfer: { Success: true } + } + limit: { count: 7 } + orderBy: { descendingByField: "Block_Time" } + ) { + Block { + Time(interval: { in: days, count: 1 }) + } + count + usd: sum(of: Transfer_AmountInUSD) + tokens: uniq(of: Transfer_Currency_SmartContract) + } + } +} +``` + +Remember the USD column reflects native ETH only; token flows are counted but not USD-valued. + +--- + +## Transfer types breakdown + +Understand how transfers are classified on Robinhood (`token`, `call`, `transaction`). Tested split over 6 hours: ~75% `token` (5.2M), ~24% `call` (1.6M), ~1% `transaction` (72k). + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Block: { Time: { since_relative: { hours_ago: 6 } } } + Transfer: { Success: true } + } + limit: { count: 10 } + orderBy: { descendingByField: "count" } + ) { + Transfer { + Type + } + count + } + } +} +``` + +--- + +## Failed transfers + +**Ops / compliance:** transfers marked `Transfer.Success: false` (often tied to reverted execution). Include `Call` fields for context. + +:::note Transfer Success vs Call Success +`Transfer.Success` and `Call.Success` are independent. You can see `Transfer.Success: false` with `Call.Success: true` and `Call.Reverted: true` (or other combinations). For forensics, return both. +::: + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { Transfer: { Success: false } } + limit: { count: 20 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Success + Type + Sender + Receiver + Currency { + Name + Symbol + SmartContract + } + } + Call { + Error + Reverted + Success + Signature { + Name + } + } + Transaction { + Hash + From + To + } + Block { + Time + } + } + } +} +``` + +--- + +## Historical transfers by date + +Use `dataset: combined` (or `archive`) with `Block.Date` for ledgers and backfills. Example: large USD transfers between two calendar dates. + +:::note after/before are exclusive +`Date.after: "2026-07-20"` with `Date.before: "2026-07-22"` returns **only 2026-07-21** (both bounds excluded — verified live). Use `since` / `till` when you want inclusive bounds. +::: + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + where: { + Block: { + Date: { + after: "2026-07-20" + before: "2026-07-22" + } + } + Transfer: { + AmountInUSD: { gt: "10000" } + Success: true + } + } + limit: { count: 20 } + orderBy: { descending: Transfer_AmountInUSD } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Currency { + Symbol + Native + SmartContract + } + } + Transaction { + Hash + } + Block { + Time + Date + Number + } + } + } +} +``` + +--- + +## Full transfer context (log, call, receipt) + +**Forensics / indexers:** join transfer value with log signature, call path, receipt status, and gas. + +```graphql +{ + EVM(network: robinhood, dataset: realtime) { + Transfers( + where: { + Transfer: { + Currency: { Native: false } + Type: { is: token } + Success: true + } + } + limit: { count: 5 } + orderBy: { descending: Block_Time } + ) { + Transfer { + Amount + AmountInUSD + Sender + Receiver + Type + Index + Id + Success + Currency { + Name + Symbol + SmartContract + Native + } + } + Log { + Index + SmartContract + Signature { + Name + Signature + SignatureHash + } + } + Call { + From + To + Success + Reverted + Signature { + Name + } + } + Receipt { + Status + GasUsed + } + Transaction { + Hash + From + To + CostInUSD + ValueInUSD + Gas + GasPrice + } + Block { + Number + Time + Hash + } + } + } +} +``` + +--- + +## Response fields (quick reference) + +| Group | Useful fields | +| --- | --- | +| **Transfer** | `Amount`, `AmountInUSD`, `Sender`, `Receiver`, `Type`, `Success`, `Index`, `Id`, `Currency.*` | +| **Currency** | `Name`, `Symbol`, `SmartContract`, `Native` | +| **Transaction** | `Hash`, `From`, `To`, `Value`, `ValueInUSD`, `Cost`, `CostInUSD`, `Gas`, `GasPrice` | +| **Block** | `Number`, `Time`, `Date`, `Hash` | +| **Log / Call / Receipt** | Event signature, call path, revert/error, receipt status | + +Aggregations: `count` (with `distinct:`/`if:`), `sum`, `average`, `median`, `quantile`, `standard_deviation`, `uniq`, plus argmin/argmax via `Field(minimum: Other_Field)` / `Field(maximum: Other_Field)` (used above to read dataset window bounds). + +For the full cube shape, see [EVM Transfers](/docs/schema/evm/transfers/). + +--- + +## Tips for fast, useful queries + +1. Always scope with `network: robinhood` and prefer a time window (`Block.Time` / `Block.Date`) on aggregates. +2. Realtime depth **varies** (observed anywhere from hours to ~4 days) — never assume it; use `combined` for any fixed window (24h/48h/7d) and `archive` for full history. Measure the current window with the [dataset window query](#check-the-dataset-window). +3. Filter WebSocket subscriptions in production — unfiltered Robinhood transfer streams are very noisy (first batch arrives in about a second). Connect with the `graphql-transport-ws` subprotocol and the token in the URL ([WebSocket auth](/docs/authorization/websocket/)). +4. Use `Transfer.Success: true` unless you specifically want failed flows; check `Call.Success` / `Call.Reverted` separately when debugging. +5. `AmountInUSD` is effectively **native-ETH-only** on Robinhood transfers — use it for ETH whales; use `Amount` for USDG (≈ dollars), tokenized stocks (shares), and meme tokens. +6. Exclude the zero address when you want address-to-address or whale alerts without wrap/unwrap noise. +7. Ticker symbols collide (two GME contracts observed) — resolve and pin `Currency.SmartContract` in production. +8. Keep `limit` tight on fact queries; use `sum` / `count` / `uniq` / `median` / `quantile` for analytics instead of pulling millions of rows. +9. For live products, start from the whale, wallet-tracker, or token subscription patterns above, then backfill with `combined` / `archive` date windows. + +--- + +## FAQ + +### How do I query Robinhood transfers with GraphQL? + +Use the `EVM` root with `network: robinhood` and the `Transfers` cube (same EVM Transfers API, Robinhood network). Add `dataset: realtime` for recent data, or `combined` / `archive` for longer history. + +### How do I stream Robinhood transfers in real time? + +Use a GraphQL `subscription` on `EVM(network: robinhood) { Transfers { ... } }` over WebSocket (`graphql-transport-ws` subprotocol). Filter by token, address, or `AmountInUSD` for whale alerts — avoid unfiltered production streams. + +### How do I get whale transfers on Robinhood? + +Filter `Transfer.AmountInUSD` with `gt`, set `Success: true`, and exclude the zero address — this captures large native ETH moves. For USDG and tokens (where `AmountInUSD` is `0`), filter by `Transfer.Amount` instead. + +### How do I get all transfers for an address? + +Use `where.any` with `Transfer.Sender` and `Transfer.Receiver` set to the same address. Split into inbound-only or outbound-only filters when you need deposits vs withdrawals, or use the [wallet-tracker subscription](#stream-transfers-for-an-address-wallet-tracker) for live updates. + +### How far back does the realtime dataset go? + +It varies — realtime is a rolling window of recent blocks (~4 days deep when tested, sometimes much less). Measure it with the [dataset window query](#check-the-dataset-window), and switch to `combined` whenever your window must be complete. + +### Why is AmountInUSD 0 for WETH, USDG, or stock tokens? + +USD enrichment on the Robinhood Transfers cube effectively covers native ETH only — verified: 24h sums for WETH and USDG both returned `$0` across millions of transfers. Use `Transfer.Amount` (USDG ≈ dollars, stock tokens ≈ shares) or join prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/). + +### How do I get hourly or daily transfer volume? + +Group with `Block { Time(interval: { in: hours, count: 1 }) }` (or `in: days`) plus `count` / `sum` aggregates on `dataset: combined` — see the [hourly](#hourly-eth-transfer-volume) and [daily](#daily-transfer-volume-7-days) examples. From f9ecea435dad0ed88d586687813c048b0e9bd28f Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:07:56 +0530 Subject: [PATCH 3/9] Add Robinhood Liquidity page to sidebar Co-Authored-By: Claude Fable 5 --- sidebars.js | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/sidebars.js b/sidebars.js index a7b1aa88..97be946e 100644 --- a/sidebars.js +++ b/sidebars.js @@ -849,11 +849,12 @@ const sidebars = { slug: "/blockchain/robinhood", title: "Robinhood APIs", description: - "APIs for accessing Robinhood trades, transfers, balances, and meme coin token launches via Bitquery Trading and EVM APIs.", + "APIs for accessing Robinhood trades, transfers, liquidity, slippage, balances, and meme coin token launches via Bitquery Trading and EVM APIs.", }, items: [ "blockchain/robinhood/robinhood-trades", "blockchain/robinhood/robinhood-transfers", + "blockchain/robinhood/robinhood-liquidity", "blockchain/robinhood/robinhood-meme-coin-launches", "blockchain/robinhood/flap-sh-api", "blockchain/robinhood/bags-fm-api", From 67c70915cdee42c760000318e5e4cb870cfb693b Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:15:57 +0530 Subject: [PATCH 4/9] Remove dated stat samples from liquidity and transfers pages Docs are evergreen: drop live-sample tables, point-in-time counts, and test-latency anecdotes; keep queries, response shapes, and durable behavioral caveats. Co-Authored-By: Claude Fable 5 --- .../robinhood/robinhood-liquidity.md | 45 ++++---------- .../robinhood/robinhood-transfers.md | 58 ++++++------------- 2 files changed, 30 insertions(+), 73 deletions(-) diff --git a/docs/blockchain/robinhood/robinhood-liquidity.md b/docs/blockchain/robinhood/robinhood-liquidity.md index 9b098f28..bf3c7ac5 100644 --- a/docs/blockchain/robinhood/robinhood-liquidity.md +++ b/docs/blockchain/robinhood/robinhood-liquidity.md @@ -84,9 +84,9 @@ The example `PoolId` and pool addresses are **illustrative addresses that were a ## How to read pool prices -Price fields are directional and quoted in the pool's own currencies. For the ETH/USDG V4 pool (`CurrencyA` = ETH, `CurrencyB` = USDG), a live row read: +Price fields are directional and quoted in the pool's own currencies. For the ETH/USDG V4 pool (`CurrencyA` = ETH, `CurrencyB` = USDG), a typical row reads: -| Field | Meaning | Live value | +| Field | Meaning | Example | | --- | --- | --- | | `AtoBPrice` | Units of **CurrencyA** per 1 **CurrencyB** | `0.000525` (ETH per USDG) | | `AtoBPriceInUSD` | USD price of 1 **CurrencyB** | `0.998` (USDG ≈ $1) | @@ -399,7 +399,7 @@ Note the `BtoAPriceInUSD: 0` and `AmountCurrencyBInUSD: 0` — real rows carry U ### Tokenized stock pools (AAPL) -Robinhood tokenized equities trade in ordinary DEX pools. AAPL's most liquid venue at the time of testing was the **USDG/AAPL Uniswap V4 pool** (`PoolId 0xc748f467…`), where `AtoBPrice ≈ 320.79` — the AAPL price quoted in USDG. Swap in the NVDA address (`0xd0601ce1…`) for NVIDIA pools. +Robinhood tokenized equities trade in ordinary DEX pools. An active AAPL venue is the **USDG/AAPL Uniswap V4 pool** (`PoolId 0xc748f467…`); its `AtoBPrice` is the AAPL price quoted in USDG. Swap in the NVDA address (`0xd0601ce1…`) for NVIDIA pools. ```graphql { @@ -519,7 +519,7 @@ When you only know the ticker, filter on `Currency.Symbol`. One latest row per p ``` :::warning Symbols are not unique -Running this exact query returned **two different contracts both claiming the NVDA symbol**: the canonical `NVIDIA • Robinhood Token` (`0xd0601ce1…`) and a copycat named just `NVDA` (`0xdecf74e4…`). Use symbol filters for discovery, then pin the `SmartContract` address in anything that trades. Also check the other side of the pair — the ETH/NVDA pool has NVDA as `CurrencyB`, but flip the filter to `CurrencyA` (or use `any:`) for full coverage. +Robinhood has **two different contracts both claiming the NVDA symbol**: the canonical `NVIDIA • Robinhood Token` (`0xd0601ce1…`) and a copycat named just `NVDA` (`0xdecf74e4…`). Use symbol filters for discovery, then pin the `SmartContract` address in anything that trades. Also check the other side of the pair — the ETH/NVDA pool has NVDA as `CurrencyB`, but flip the filter to `CurrencyA` (or use `any:`) for full coverage. ::: --- @@ -592,17 +592,7 @@ Isolate one protocol's pool updates — Uniswap V2/V3/V4 or PancakeSwap. } ``` -Protocols observed on Robinhood pool events when this page was last tested: - -| `ProtocolFamily` | `ProtocolName` | Share of pool events* | -| --- | --- | --- | -| Uniswap | `uniswap_v3` | ~63% | -| Uniswap | `uniswap_v4` | ~29% | -| Uniswap | `uniswap_v2` | ~7% | -| PancakeSwap | `pancake_swap_v3` | under 1% | -| PancakeSwapInfinity | `pancakeswap_infinity` | trace | - -*Share of the realtime window at the time of writing (~16.7M pool updates across ~85,000 pools); it shifts constantly. +Protocols observed on Robinhood pool events: **Uniswap** (`uniswap_v2`, `uniswap_v3`, `uniswap_v4`) and **PancakeSwap** (`pancake_swap_v3`, `pancakeswap_infinity`). Run the breakdown query above for the current split. ### Network-wide totals @@ -780,7 +770,7 @@ The `Field(maximum: OtherField)` syntax is an **argmax**: it returns this field' } ``` -Live sample from this query — the ETH/NVDA pool over one hour: 413 updates, high `210.52`, low `208.04`, last `209.16` (the tokenized NVIDIA price in USD), TVL ≈ `$44,940`. Meme pools show far wider ranges (an ETH/MARSCOIN pool printed a 2× intra-hour swing). Compute swing % client-side as `(high − low) ÷ low`; use absolute `since:`/`till:` timestamps if you prefer fixed windows. +Compute swing % client-side as `(high − low) ÷ low`; use absolute `since:`/`till:` timestamps if you prefer fixed windows. --- @@ -818,16 +808,7 @@ Note `orderBy: { descendingByField: "interval_Time" }` — the sort key is the a } ``` -Live sample (ETH/USDG V4 pool — `BtoAPrice` is USDG per ETH): - -| Interval (UTC) | Updates | Close | Avg | Pool ETH | ETH side USD | -| --- | --- | --- | --- | --- | --- | -| 13:55 | 126 | 1898.60 | 1902.26 | 156.04 | 296,749 | -| 13:50 | 123 | 1905.83 | 1901.66 | 152.96 | 290,961 | -| 13:45 | 84 | 1901.55 | 1904.09 | 160.11 | 304,924 | -| 13:40 | 77 | 1906.09 | 1904.22 | 152.65 | 290,604 | - -The realtime window only reaches back a number of hours — this is for intraday series, not multi-month TVL history. +The realtime window only reaches back a limited time — this is for intraday series, not multi-month TVL history. --- @@ -888,7 +869,7 @@ subscription { ``` :::tip WebSocket connection -Connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol (`connection_init` → `connection_ack` → `subscribe`). This exact subscription delivered its first live event within seconds when tested. See [WebSocket authentication](/docs/authorization/websocket/). +Connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol (`connection_init` → `connection_ack` → `subscribe`). See [WebSocket authentication](/docs/authorization/websocket/). ::: --- @@ -1204,10 +1185,8 @@ Pull recent levels for a V4 `PoolId`. Compare `MaxAmountIn` across 10 → 1000 b } ``` -Live sample: ETH/CASHCAT `140.3 ETH` (≈$260k), ETH/dollars `136.8 ETH`, ETH/FIRE `133.1 ETH`, ETH/AnsemCat `118.9 ETH`, down to ETH/SUBT `27.3 ETH` (≈$51k). - :::warning Degenerate pools report absurd depth -Without the `lt` cap, testing surfaced pools claiming capacity of **850 million ETH** (and USD values in the trillions) — one-sided or broken V4 pools whose curve math degenerates. Keep a sanity band on `MaxAmountIn`, and cross-check any surprising top row against the pool's actual reserves in `DEXPoolEvents` before routing (the sample's own top row — 5,625 ETH against a meme token — deserves exactly that check). The same applies to `MaxAmountInInUSD` screeners: long-tail token USD prices can be wildly inflated. +One-sided or broken V4 pools can report absurd capacity — millions of ETH, USD values in the trillions — because their curve math degenerates. Keep a sanity band on `MaxAmountIn`, and cross-check any surprising top row against the pool's actual reserves in `DEXPoolEvents` before routing. The same applies to `MaxAmountInInUSD` screeners: long-tail token USD prices can be wildly inflated. ::: ### Whale capacity and thin liquidity screeners @@ -1310,7 +1289,7 @@ subscription { ### Stream a network-wide slippage screener -Drop the pool filter and keep one tolerance to watch **every pool's 1% depth** as it changes — the push-based version of the screeners above. This subscription delivered its first event in about a second when tested live. +Drop the pool filter and keep one tolerance to watch **every pool's 1% depth** as it changes — the push-based version of the screeners above. ```graphql subscription { @@ -1430,11 +1409,11 @@ Yes, within the realtime window: bucket `DEXPoolEvents` with `Time(interval: { c ### Which DEX protocols run on Robinhood? -Pool events at the time of testing came from `uniswap_v3` (~63%), `uniswap_v4` (~29%), `uniswap_v2` (~7%), plus small shares of `pancake_swap_v3` and `pancakeswap_infinity`. Run the [protocol breakdown query](#protocol-activity-breakdown) for current numbers. +Pool events come from `uniswap_v3`, `uniswap_v4`, `uniswap_v2`, plus `pancake_swap_v3` and `pancakeswap_infinity`. Run the [protocol breakdown query](#protocol-activity-breakdown) for the current split. ### Why are some USD fields 0 — or absurdly large? -USD enrichment covers mainly native-ETH-quoted pools; V2/V3 and exotic pairs often report `0`, and broken or one-sided pools can report inflated USD capacity (test runs saw trillion-dollar readings on meme pools). Prefer raw token amounts with sanity bounds, and derive USD from reserves where needed. +USD enrichment covers mainly native-ETH-quoted pools; V2/V3 and exotic pairs often report `0`, and broken or one-sided pools can report inflated USD capacity (even trillion-dollar readings on meme pools). Prefer raw token amounts with sanity bounds, and derive USD from reserves where needed. ### Why is PoolId `0x` on some rows? diff --git a/docs/blockchain/robinhood/robinhood-transfers.md b/docs/blockchain/robinhood/robinhood-transfers.md index c6b7e793..2c44181b 100644 --- a/docs/blockchain/robinhood/robinhood-transfers.md +++ b/docs/blockchain/robinhood/robinhood-transfers.md @@ -72,7 +72,7 @@ Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorizat `Transfer.Type` commonly returns `token` (ERC-20 log), `call` (internal value move), or `transaction` (top-level ETH value). :::tip AmountInUSD on Robinhood transfers -In practice **only native ETH carries a populated `AmountInUSD`** on this cube. Verified over a 24h window: 6.6M WETH transfers and 2.4M USDG transfers both summed to `$0` USD. Consequences: +In practice **only native ETH carries a populated `AmountInUSD`** on this cube — WETH and USDG rows return `0` too, not just long-tail tokens. Consequences: - USD thresholds and USD rankings effectively select **ETH flows only**. - For USDG, treat `Transfer.Amount` as ≈ USD (it is a dollar stablecoin). @@ -80,9 +80,9 @@ In practice **only native ETH carries a populated `AmountInUSD`** on this cube. ::: :::tip Choosing a dataset -- **`realtime`** — a rolling window of recent blocks. Its depth **varies**: at the time of testing it held ~4 days (~110M transfers), but it can be much shorter. Don't assume a fixed depth. +- **`realtime`** — a rolling window of recent blocks. Its depth **varies** from hours to days — don't assume a fixed depth; measure it with the query below. - **`combined`** — archive + realtime union. The safe choice for any fixed window (24h, 48h, 7d). -- **`archive`** — full history; its head lags the chain by minutes (observed ~30 minutes). Unlike the [liquidity cubes](/docs/blockchain/robinhood/robinhood-liquidity/), Transfers **does** support archive. +- **`archive`** — full history; its head lags the chain by minutes. Unlike the [liquidity cubes](/docs/blockchain/robinhood/robinhood-liquidity/), Transfers **does** support archive. ::: ### Check the dataset window @@ -108,7 +108,7 @@ Don't guess the realtime depth — measure it. `Time(minimum: …)` / `Time(maxi Stream live transfers for dashboards, bots, and alerting. :::warning Filter live streams -Robinhood transfer volume is very high (tested: an unfiltered stream delivered its first batch in about a second). Prefer a `where` filter (token, address, or `AmountInUSD`) in production. An unfiltered subscription is fine for exploration, but it can overwhelm clients and burn stream quota. +Robinhood transfer volume is very high. Prefer a `where` filter (token, address, or `AmountInUSD`) in production. An unfiltered subscription is fine for exploration, but it can overwhelm clients and burn stream quota. ::: ▶️ [Run in IDE](https://ide.bitquery.io/real-time-transfers-on-robinhood) @@ -151,7 +151,7 @@ Connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `grap ### Stream whale transfers (USD threshold) -Alert when a successful transfer exceeds a USD size. Exclude the zero address to skip wrap/unwrap and mint/burn noise. Because USD is populated for native ETH, this is effectively a **large ETH move alert** — when tested live it caught a $13.7k ETH transfer within seconds. +Alert when a successful transfer exceeds a USD size. Exclude the zero address to skip wrap/unwrap and mint/burn noise. Because USD is populated for native ETH, this is effectively a **large ETH move alert**. ```graphql subscription { @@ -525,8 +525,6 @@ One call, one **latest** transfer per token: `limitBy` on the currency contract } ``` -When tested, the top rows all carried the same one-second timestamp — WETH, USDG, tokenized stocks (INTC), and meme tokens transfer many times per second on Robinhood. - --- ## USDG stablecoin transfers @@ -575,7 +573,7 @@ When tested, the top rows all carried the same one-second timestamp — WETH, US ### USDG 24h activity summary -Use `dataset: combined` so the full 24h window is covered regardless of the current realtime depth. When tested this returned **2.4M USDG transfers moving over $1B (1.045B USDG) between ~17k senders and ~18k receivers in one day**. +Use `dataset: combined` so the full 24h window is covered regardless of the current realtime depth. ```graphql { @@ -604,7 +602,7 @@ Use `dataset: combined` so the full 24h window is covered regardless of the curr ## Tokenized stock transfers (AAPL, NVDA) -**Trading / custody:** monitor tokenized equity movements. Robinhood's stock tokens are ordinary ERC-20s here — AAPL below; swap in NVDA (`0xd0601ce1…`) or any other. Live testing also saw GOOGL, GME, INTC, and SNDK tokens moving. `AmountInUSD` is `0` for these, so read `Transfer.Amount` as the **share count**. +**Trading / custody:** monitor tokenized equity movements. Robinhood's stock tokens are ordinary ERC-20s here — AAPL below; swap in NVDA (`0xd0601ce1…`) or any other. Other stock tokens (GOOGL, GME, INTC, SNDK) follow the same pattern. `AmountInUSD` is `0` for these, so read `Transfer.Amount` as the **share count**. ```graphql { @@ -647,7 +645,7 @@ Use `dataset: combined` so the full 24h window is covered regardless of the curr ``` :::warning Ticker symbols are not unique -The 24h most-transferred list surfaced **two different contracts both using the GME symbol** (`0x1b0e319c…` and `0xc2362aff…`). Always resolve and pin the `SmartContract` address (the canonical Robinhood stock tokens are named like `NVIDIA • Robinhood Token`) instead of trusting a ticker. +Multiple contracts can share one ticker — Robinhood has **two different contracts both using the GME symbol** (`0x1b0e319c…` and `0xc2362aff…`). Always resolve and pin the `SmartContract` address (the canonical Robinhood stock tokens are named like `NVIDIA • Robinhood Token`) instead of trusting a ticker. ::: --- @@ -787,7 +785,7 @@ Filter where the address is either `Transfer.Sender` or `Transfer.Receiver` to b ## Whale transfers by USD value -**Trading / compliance:** find the largest successful transfers by `AmountInUSD`, excluding zero-address wrap/unwrap and mint/burn rows. Since only native ETH carries USD, this surfaces **large ETH moves** (top row in testing: a $4.8M ETH transfer). For token whales, use raw-amount thresholds like the [meme-token example](#large-meme-token-transfers-by-token-amount). +**Trading / compliance:** find the largest successful transfers by `AmountInUSD`, excluding zero-address wrap/unwrap and mint/burn rows. Since only native ETH carries USD, this surfaces **large ETH moves**. For token whales, use raw-amount thresholds like the [meme-token example](#large-meme-token-transfers-by-token-amount). ```graphql { @@ -1172,19 +1170,6 @@ When `AmountInUSD` is `0`, rank by raw `Transfer.Amount`. Example uses FREN (`0x } ``` -Live 24h sample when tested — note the tokenized stocks in the top ranks, and **two distinct GME contracts**: - -| Token | Transfers | Unique senders | -| --- | --- | --- | -| ETH (native) | 8.90M | 227,568 | -| WETH | 6.64M | 56,850 | -| USDG | 2.40M | 16,872 | -| GME (`0x1b0e319c…`) | 1.09M | 1,558 | -| NVDA | 625k | 2,359 | -| GME (`0xc2362aff…`) | 573k | 14,505 | -| SPCX | 535k | 1,700 | -| GOOGL | 409k | 1,388 | - --- ## Top receivers by ETH inflow (liquidity hubs) @@ -1257,7 +1242,7 @@ Live 24h sample when tested — note the tokenized stocks in the top ranks, and ## Unique senders and receivers for a token -**Distribution / compliance:** count distinct participants for WETH over 24 hours. Tested result: 6.64M transfers between ~57k senders and ~51k receivers (and `usd: 0` — WETH carries no USD enrichment; see [the USD note](#network-and-useful-contracts)). +**Distribution / compliance:** count distinct participants for WETH over 24 hours. Note `usd` comes back `0` here — WETH carries no USD enrichment (see [the USD note](#network-and-useful-contracts)). ```graphql { @@ -1286,7 +1271,7 @@ Live 24h sample when tested — note the tokenized stocks in the top ranks, and ## ETH transfer size statistics (24h) -**Market microstructure:** distribution stats for native ETH transfer sizes — average, median, and 90th percentile in one aggregate call. Tested values: 8.9M ETH transfers in 24h totalling **$1.19B**, average **$133**, median **$13.88**, p90 **$237** from ~228k senders (a long-tail distribution — the average sits far above the median). +**Market microstructure:** distribution stats for native ETH transfer sizes — average, median, and 90th percentile in one aggregate call. Expect a long-tail distribution: the average typically sits far above the median. ```graphql { @@ -1350,14 +1335,7 @@ Also available: `standard_deviation`, other `quantile` levels, and `count(distin ## Daily transfer volume (7 days) -**Dashboards:** one row per day — total transfers, ETH-denominated USD volume, and how many distinct tokens moved. Live sample when tested: - -| Day | Transfers | USD volume (native ETH) | Active tokens | -| --- | --- | --- | --- | -| 2026-07-22 | 29.7M | $1.21B | 60,365 | -| 2026-07-21 | 28.2M | $1.26B | 62,836 | -| 2026-07-20 | 24.3M | $1.17B | 52,488 | -| 2026-07-19 | 18.4M | $0.95B | 42,234 | +**Dashboards:** one row per day — total transfers, ETH-denominated USD volume, and how many distinct tokens moved. ```graphql { @@ -1387,7 +1365,7 @@ Remember the USD column reflects native ETH only; token flows are counted but no ## Transfer types breakdown -Understand how transfers are classified on Robinhood (`token`, `call`, `transaction`). Tested split over 6 hours: ~75% `token` (5.2M), ~24% `call` (1.6M), ~1% `transaction` (72k). +Understand how transfers are classified on Robinhood (`token`, `call`, `transaction`). ```graphql { @@ -1468,7 +1446,7 @@ Understand how transfers are classified on Robinhood (`token`, `call`, `transact Use `dataset: combined` (or `archive`) with `Block.Date` for ledgers and backfills. Example: large USD transfers between two calendar dates. :::note after/before are exclusive -`Date.after: "2026-07-20"` with `Date.before: "2026-07-22"` returns **only 2026-07-21** (both bounds excluded — verified live). Use `since` / `till` when you want inclusive bounds. +`Date.after: "2026-07-20"` with `Date.before: "2026-07-22"` returns **only 2026-07-21** (both bounds excluded). Use `since` / `till` when you want inclusive bounds. ::: ```graphql @@ -1612,8 +1590,8 @@ For the full cube shape, see [EVM Transfers](/docs/schema/evm/transfers/). ## Tips for fast, useful queries 1. Always scope with `network: robinhood` and prefer a time window (`Block.Time` / `Block.Date`) on aggregates. -2. Realtime depth **varies** (observed anywhere from hours to ~4 days) — never assume it; use `combined` for any fixed window (24h/48h/7d) and `archive` for full history. Measure the current window with the [dataset window query](#check-the-dataset-window). -3. Filter WebSocket subscriptions in production — unfiltered Robinhood transfer streams are very noisy (first batch arrives in about a second). Connect with the `graphql-transport-ws` subprotocol and the token in the URL ([WebSocket auth](/docs/authorization/websocket/)). +2. Realtime depth **varies** (anywhere from hours to days) — never assume it; use `combined` for any fixed window (24h/48h/7d) and `archive` for full history. Measure the current window with the [dataset window query](#check-the-dataset-window). +3. Filter WebSocket subscriptions in production — unfiltered Robinhood transfer streams are very noisy. Connect with the `graphql-transport-ws` subprotocol and the token in the URL ([WebSocket auth](/docs/authorization/websocket/)). 4. Use `Transfer.Success: true` unless you specifically want failed flows; check `Call.Success` / `Call.Reverted` separately when debugging. 5. `AmountInUSD` is effectively **native-ETH-only** on Robinhood transfers — use it for ETH whales; use `Amount` for USDG (≈ dollars), tokenized stocks (shares), and meme tokens. 6. Exclude the zero address when you want address-to-address or whale alerts without wrap/unwrap noise. @@ -1643,11 +1621,11 @@ Use `where.any` with `Transfer.Sender` and `Transfer.Receiver` set to the same a ### How far back does the realtime dataset go? -It varies — realtime is a rolling window of recent blocks (~4 days deep when tested, sometimes much less). Measure it with the [dataset window query](#check-the-dataset-window), and switch to `combined` whenever your window must be complete. +It varies — realtime is a rolling window of recent blocks; its depth changes over time. Measure it with the [dataset window query](#check-the-dataset-window), and switch to `combined` whenever your window must be complete. ### Why is AmountInUSD 0 for WETH, USDG, or stock tokens? -USD enrichment on the Robinhood Transfers cube effectively covers native ETH only — verified: 24h sums for WETH and USDG both returned `$0` across millions of transfers. Use `Transfer.Amount` (USDG ≈ dollars, stock tokens ≈ shares) or join prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/). +USD enrichment on the Robinhood Transfers cube effectively covers native ETH only — WETH and USDG rows return `$0` as well. Use `Transfer.Amount` (USDG ≈ dollars, stock tokens ≈ shares) or join prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/). ### How do I get hourly or daily transfer volume? From a34e5acd00f6fb726f6827c4c40c5ff410ee289a Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:54:32 +0530 Subject: [PATCH 5/9] Rework Robinhood Trades page with live-tested queries Restores the historical trades section (verified working), adds missing limit/orderBy to trader query, adds limit to all-active supply query, names example tokens (ASSETH, SOLdiers), and adds tested buy/sell pressure, most-active-pools, multi-token price watchlist, and data-window queries plus WebSocket connection guidance. Co-Authored-By: Claude Fable 5 --- docs/blockchain/robinhood/robinhood-trades.md | 184 ++++++++++++++++-- 1 file changed, 173 insertions(+), 11 deletions(-) diff --git a/docs/blockchain/robinhood/robinhood-trades.md b/docs/blockchain/robinhood/robinhood-trades.md index f509d6a2..553381cc 100644 --- a/docs/blockchain/robinhood/robinhood-trades.md +++ b/docs/blockchain/robinhood/robinhood-trades.md @@ -1,6 +1,6 @@ --- title: "Robinhood Trades API" -description: "Robinhood Trades API: query and stream Robinhood on-chain data with Bitquery GraphQL examples for developers. Covers archive history and realtime data." +description: "Robinhood Trades API: live trades, USD prices, OHLCV candles, market cap, whale trades, buy/sell pressure, and top traders via Bitquery GraphQL & WebSockets." sidebar_position: 1 keywords: - Robinhood API @@ -14,6 +14,9 @@ keywords: - Robinhood top traders - Robinhood real-time trade stream - Robinhood K-line candles + - Robinhood buy sell pressure + - Robinhood most active pools + - Robinhood token price watchlist - Bitquery Robinhood Trading API --- # Robinhood Trades API & Streams @@ -27,9 +30,10 @@ Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorizat ::: :::tip Related docs -- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers) -- [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply) -- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) +- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/) +- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity/) +- [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply/) +- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches/) - [Trading data overview](/docs/trading/trading-data-overview/) - [Crypto Trades API](/docs/trading/crypto-trades-api/trades-api/) - [Crypto Price API](/docs/trading/crypto-price-api/introduction/) @@ -44,6 +48,17 @@ Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorizat | `NetworkBid` | `bid:robinhood` | Filter to select Robinhood data (indexed and faster) | | `Network` | `Robinhood` | Filter to select Robinhood data | +### Example tokens used on this page + +| Item | Value | +| --- | --- | +| ASSETH (AssetHood, example token) | `0x9077841e155faaf4e4e89470822c2187eeef7777` | +| Example pool trading ASSETH | `0xbbaefcfcd7b92ed0df1a3eec22a21ba6beb0b52b` | +| SOLdiers (first-buyers example) | `0xaf81aa091665c60cfa172f86a5a8d6b437a79353` | +| WETH | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` | + +These are live examples — meme tokens go quiet over time, so swap in any token, pool, or trader you care about. + --- ## Real-Time Trades on Robinhood @@ -103,11 +118,15 @@ subscription { } ``` +:::tip WebSocket connection +Run subscriptions against `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol (`connection_init` → `connection_ack` → `subscribe`). See [WebSocket authentication](/docs/authorization/websocket/). +::: + --- - +--- ## Latest Trades on Robinhood @@ -283,7 +303,7 @@ Fetch large trades by filtering on USD value. This example returns trades of at ## Real-Time Trades for a Specific Token -Using this GraphQL stream you can get real-time trades for a specific token with details such as trader address, token details, marketcap, FDV and transaction hash. +Using this GraphQL stream you can get real-time trades for a specific token (example: AssetHood, `ASSETH`) with details such as trader address, token details, marketcap, FDV and transaction hash. ▶️ [Run in IDE](https://ide.bitquery.io/Robinhood-Trades-for-a-token) @@ -411,7 +431,7 @@ Scope trades to a single liquidity pool using `Pool.Address` — useful when a t ## First Buyers of a Token on Robinhood -Get the earliest trades for a token, ordered oldest first, to find the first buyers after launch. Filtered to buys here; remove the `Side` filter for first trades of any side. +Get the earliest trades for a token (example: the SOLdiers meme token), ordered oldest first, to find the first buyers after launch. Filtered to buys here; remove the `Side` filter for first trades of any side. ```graphql { @@ -477,6 +497,8 @@ Using this GraphQL API endpoint you can get token trades by a trader with detail { Trading { Trades( + limit: { count: 50 } + orderBy: { descending: Block_Time } where: { Trader:{ Address:{ @@ -749,13 +771,14 @@ subscription { ### Supply of All Active Tokens -Fetch the latest total supply for every recently active token. `limitBy` returns one row — the newest supply — per token contract. +Fetch the latest total supply for every recently active token. `limitBy` returns one row — the newest supply — per token contract. Keep a `limit`: unbounded, this returns one row per active token, which can be very large. ```graphql { EVM(network: robinhood) { TransactionBalances( limitBy: {by: TokenBalance_Currency_SmartContract, count: 1} + limit: {count: 100} orderBy: {descending: Block_Time} where: {TokenBalance: {Currency: {SmartContract: {not: "0x"}}}} ) { @@ -921,6 +944,141 @@ Rank the most actively traded Robinhood tokens by USD volume over the last 24 ho --- +## Buy vs Sell Pressure for a Token + +Gauge demand in one call: buy and sell USD volume, trade counts, and unique traders for a token over a window. Compute net flow client-side as `bought_usd − sold_usd`. + +```graphql +{ + Trading { + Trades( + where: { + Pair: { + Token: { Address: { is: "0x9077841e155faaf4e4e89470822c2187eeef7777" } } + Market: { NetworkBid: { is: "bid:robinhood" } } + } + Block: { Time: { since_relative: { days_ago: 1 } } } + } + ) { + bought_usd: sum(of: AmountsInUsd_Base, if: { Side: { is: "Buy" } }) + sold_usd: sum(of: AmountsInUsd_Base, if: { Side: { is: "Sell" } }) + buys: count(if: { Side: { is: "Buy" } }) + sells: count(if: { Side: { is: "Sell" } }) + traders: uniq(of: Trader_Address) + } + } +} +``` + +--- + +## Most Active Pools on Robinhood + +Rank pools by trade count over the last day, with USD volume and unique traders per pool. Trade count is a more robust ranking key than USD volume, which can be inflated to absurd values on thin meme pools — treat extreme `volume_usd` readings as suspect. + +```graphql +{ + Trading { + Trades( + limit: { count: 20 } + orderBy: { descendingByField: "trades" } + where: { + Pair: { Market: { NetworkBid: { is: "bid:robinhood" } } } + Block: { Time: { since_relative: { days_ago: 1 } } } + } + ) { + Pair { + Pool { + Address + } + Market { + Protocol + } + Token { + Symbol + Address + } + QuoteToken { + Symbol + } + } + trades: count + volume_usd: sum(of: AmountsInUsd_Base) + traders: uniq(of: Trader_Address) + } + } +} +``` + +--- + +## Price Watchlist: Latest Price for Multiple Tokens + +One latest price per token in a single call — `limitBy` on `Token_Id` keeps the newest 1-second interval for each token in the list. `Interval.Time.End` doubles as a staleness indicator: it is the last time that token actually traded. + +```graphql +{ + Trading { + Tokens( + limit: { count: 10 } + limitBy: { by: Token_Id, count: 1 } + orderBy: { descending: Interval_Time_End } + where: { + Token: { + Address: { + in: [ + "0x9077841e155faaf4e4e89470822c2187eeef7777" + "0xaf81aa091665c60cfa172f86a5a8d6b437a79353" + ] + } + NetworkBid: { is: "bid:robinhood" } + } + Interval: { Time: { Duration: { eq: 1 } } } + } + ) { + Token { + Symbol + Address + } + Price { + Ohlc { + Close + } + } + Interval { + Time { + End + } + } + } + } +} +``` + +--- + +## Check the Trading Data Window + +Don't guess how far back Trading data reaches — ask for the earliest available trade. + +```graphql +{ + Trading { + Trades( + limit: { count: 1 } + orderBy: { ascending: Block_Time } + where: { Pair: { Market: { NetworkBid: { is: "bid:robinhood" } } } } + ) { + Block { + Time + } + } + } +} +``` + +--- + ## FAQ ### How do I stream Robinhood trades in real time? @@ -941,4 +1099,8 @@ Yes. Query `Trading.Tokens` or `Trading.Pairs` with an `Interval.Time.Duration` ### How far back does Robinhood trade data go? -The Trading APIs cover real-time data and roughly the last 30 days. For older history, use the chain-level `DEXTrades` / `DEXTradeByTokens` APIs. +The Trading APIs cover real-time data and roughly the last 30 days — for newer networks, data starts when Bitquery indexing began. Measure the exact coverage with the [window query](#check-the-trading-data-window). For older history, use the chain-level `DEXTrades` / `DEXTradeByTokens` APIs. + +### How do I measure buy vs sell pressure for a Robinhood token? + +Aggregate `Trading.Trades` with conditional sums — `sum(of: AmountsInUsd_Base, if: {Side: {is: "Buy"}})` versus the `Sell` side — over your window, and compare. See [Buy vs Sell Pressure](#buy-vs-sell-pressure-for-a-token). From d50718239c637239b7ff94d860eebb0e2594254e Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:56:14 +0530 Subject: [PATCH 6/9] Improve Robinhood Token Supply page Fixes description (EVM TransactionBalances, not Trading), adds limit to the all-active-tokens query, and adds tested tokenized-stock (NVDA) and multi-token supply watchlist sections with FAQ and internal links. Co-Authored-By: Claude Fable 5 --- .../robinhood/robinhood-token-supply.md | 71 ++++++++++++++++++- 1 file changed, 69 insertions(+), 2 deletions(-) diff --git a/docs/blockchain/robinhood/robinhood-token-supply.md b/docs/blockchain/robinhood/robinhood-token-supply.md index c8e0d42b..63b949c7 100644 --- a/docs/blockchain/robinhood/robinhood-token-supply.md +++ b/docs/blockchain/robinhood/robinhood-token-supply.md @@ -1,6 +1,6 @@ --- title: "Robinhood Token Supply API" -description: "Robinhood Token Supply API: stream Robinhood market cap, FDV, supply, and price using Bitquery Trading GraphQL APIs. See examples in the Bitquery IDE." +description: "Robinhood Token Supply API: query and stream token total supply with Bitquery's EVM TransactionBalances API — single tokens, watchlists, and all active tokens." sidebar_position: 5 keywords: - Robinhood token supply API @@ -12,6 +12,8 @@ keywords: - token total supply Robinhood - Bitquery Robinhood supply API - Robinhood token circulating supply + - Robinhood tokenized stock supply + - Robinhood NVDA token supply --- # Robinhood Token Supply API @@ -26,6 +28,7 @@ Follow the steps here: [How to generate Bitquery API token ➤](/docs/authorizat :::tip Related docs - [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) - [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers) +- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity/) - [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api) - [WebSocket subscriptions](/docs/subscriptions/websockets/) ::: @@ -120,13 +123,14 @@ subscription { ## Supply of All Active Tokens -Fetch the latest total supply for every recently active token in a single query. `limitBy` collapses results to the newest record per token contract, so each token appears once with its current supply. +Fetch the latest total supply for every recently active token in a single query. `limitBy` collapses results to the newest record per token contract, so each token appears once with its current supply. Keep a `limit` — unbounded, this returns one row per active token, which can be very large. ```graphql { EVM(network: robinhood) { TransactionBalances( limitBy: {by: TokenBalance_Currency_SmartContract, count: 1} + limit: {count: 100} orderBy: {descending: Block_Time} where: {TokenBalance: {Currency: {SmartContract: {not: "0x"}}}} ) { @@ -177,6 +181,65 @@ Fetch the latest total supply for every recently active token in a single query. --- +## Tokenized Stock Supply (NVDA) + +Robinhood's tokenized equities are ordinary ERC-20s, so the same query returns the on-chain supply of a stock token — `TotalSupply` reads as the tokenized share count. Example: NVIDIA (`NVDA`); swap in AAPL (`0xaf3d76f1834a1d425780943c99ea8a608f8a93f9`) or any other stock token. + +```graphql +{ + EVM(network: robinhood) { + TransactionBalances( + limit: {count: 1} + orderBy: {descending: Block_Time} + where: {TokenBalance: {Currency: {SmartContract: {is: "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec"}}}} + ) { + TokenBalance { + Currency { + Symbol + Name + SmartContract + } + TotalSupply + } + } + } +} +``` + +--- + +## Supply Watchlist: Multiple Tokens at Once + +One latest supply row per token for a fixed list — `SmartContract.in` plus `limitBy` per contract. Example list: WETH, USDG, AAPL, NVDA. + +```graphql +{ + EVM(network: robinhood) { + TransactionBalances( + limitBy: {by: TokenBalance_Currency_SmartContract, count: 1} + limit: {count: 10} + orderBy: {descending: Block_Time} + where: {TokenBalance: {Currency: {SmartContract: {in: [ + "0x0bd7d308f8e1639fab988df18a8011f41eacad73", + "0x5fc5360d0400a0fd4f2af552add042d716f1d168", + "0xaf3d76f1834a1d425780943c99ea8a608f8a93f9", + "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" + ]}}}} + ) { + TokenBalance { + Currency { + Symbol + SmartContract + } + TotalSupply + } + } + } +} +``` + +--- + ## FAQ ### How do I get the current total supply of a Robinhood token? @@ -191,6 +254,10 @@ Run the `subscription` on `TransactionBalances` with `Currency.SmartContract: {n Use `limitBy: {by: TokenBalance_Currency_SmartContract, count: 1}` with `orderBy: {descending: Block_Time}`. This returns one row — the latest supply — per token contract. +### Can I get supply for several tokens in one query? + +Yes — filter `Currency.SmartContract` with `in: [...]` and add `limitBy: {by: TokenBalance_Currency_SmartContract, count: 1}` so each token returns its newest supply once. See [the watchlist example](#supply-watchlist-multiple-tokens-at-once). + ### Is `TotalSupply` raw or decimal-adjusted? It is decimal-normalized (whole tokens), already divided by the token's decimals. Use it directly for market-cap math without further scaling. From c6ef699c8034b6648374d565b688641d5a5fd226 Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 20:57:34 +0530 Subject: [PATCH 7/9] Improve Robinhood Meme Coin Launches page Adds dataset-window guidance (realtime rolling window vs combined/archive for older launches) and tested cross-launchpad activity comparison and launches-per-day queries with FAQ entry. Co-Authored-By: Claude Fable 5 --- .../robinhood/robinhood-meme-coin-launches.md | 79 ++++++++++++++++++- 1 file changed, 78 insertions(+), 1 deletion(-) diff --git a/docs/blockchain/robinhood/robinhood-meme-coin-launches.md b/docs/blockchain/robinhood/robinhood-meme-coin-launches.md index 4fad8ad9..02f26ef9 100644 --- a/docs/blockchain/robinhood/robinhood-meme-coin-launches.md +++ b/docs/blockchain/robinhood/robinhood-meme-coin-launches.md @@ -21,6 +21,8 @@ keywords: - Bags.fm Robinhood token launches - Clanker Robinhood launches API - Robinhood launchpad API + - Robinhood launchpad comparison + - Robinhood token launches per day - meme coin token creation Robinhood - Bitquery Robinhood Events API - Bitquery Robinhood Transfers API @@ -66,6 +68,10 @@ Bitquery's `Transfer.Amount` is already adjusted for the token's `Decimals`, so Flap.sh emits a decoded `TokenCreated` event, so it can be tracked via **Events** (richer, with decoded arguments) as well as transfers. The other launchpads and bots on this page are tracked via the **mint-transfer** pattern. +:::tip Reaching older launches +These queries default to the **realtime** dataset — a rolling window of recent blocks whose depth varies. Launchpads with sparse recent activity can return few or no rows. To reach further back, add `dataset: combined` (or `archive`) on the `EVM` root plus a time filter — e.g. `EVM(network: robinhood, dataset: combined)` with `Block: {Time: {since_relative: {days_ago: 7}}}`. +::: + --- ## Launchpad and bot contract map @@ -88,12 +94,79 @@ _WS = WebSocket subscription (real-time stream of the same query)._ --- +## Compare launchpad activity + +One query across every launchpad: count zero-address mints per launch contract over a window (`Transaction.To` in the contract-map list) and group by contract. `tokens` counts distinct minted token contracts. This matches mints of **any** amount — Clanker's different launch supply included — so treat it as an activity overview rather than an exact per-protocol launch count. + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + limit: { count: 10 } + orderBy: { descendingByField: "launches" } + where: { + Block: { Time: { since_relative: { days_ago: 7 } } } + Transfer: { Sender: { is: "0x0000000000000000000000000000000000000000" } } + Transaction: { + To: { + in: [ + "0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c" + "0x62b33a039d289cbda50ebeb72fe4261449e61bcf" + "0xd4ccbfa37e2f35611b3042e4096ad7a3459bd007" + "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" + "0x16cf6788b762ee8969744586ed16fc5705140dd7" + "0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862" + "0x6e4910ea5a04376032f6564da9a9e4e88b7a87c1" + "0xe8cc4431adf8b5a847c113ef0c6af9043219cb37" + "0xd3f2cc1731b7fd17f28798835c2e02f0a1839a94" + ] + } + } + } + ) { + Transaction { + To + } + launches: count + tokens: uniq(of: Transfer_Currency_SmartContract) + } + } +} +``` + +### Launches per day for one launchpad + +Bucket a launchpad's mints into daily counts — a launch-rate series (example: Flap.sh). + +```graphql +{ + EVM(network: robinhood, dataset: combined) { + Transfers( + limit: { count: 7 } + orderBy: { descendingByField: "Block_Time" } + where: { + Block: { Time: { since_relative: { days_ago: 7 } } } + Transfer: { Sender: { is: "0x0000000000000000000000000000000000000000" } } + Transaction: { To: { is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09" } } + } + ) { + Block { + Time(interval: { in: days, count: 1 }) + } + launches: count + } + } +} +``` + +--- + ## hood.fun **[hood.fun](https://hood.fun/)** is the premier fair-launch memecoin launchpad on the Robinhood network. Every token launches with a fixed **1 billion** supply on a bonding curve, so newly created tokens can be detected as mint transfers from the zero address where `Transaction.To` is the hood.fun contract. :::note Contract generations -The current hood.fun launch contract is `0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c`. The previous generation, `0x6a63d96ef77ae569fcb85934cf1bd1ec7fe9b33d`, still has tokens trading — swap the address in `Transaction.To` to query it. +The current hood.fun launch contract is `0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c`. The previous generation, `0x6a63d96ef77ae569fcb85934cf1bd1ec7fe9b33d`, still has tokens trading — swap the address in `Transaction.To` to query it. Older generations' launch history sits outside the realtime window, so query them with `dataset: combined` or `archive`. ::: ### hood.fun Newly created tokens @@ -733,6 +806,10 @@ Copy any transfer query on this page and replace the address in `Transaction.To` The `Amount` is the full initial token supply minted at launch (`1000000000` for most launchpads, `100000000000` for Clanker). Combined with the zero-address sender, it isolates the launch mint from ordinary transfers. `Transfer.Amount` is already decimal-normalized, so compare against the whole-token value, not the raw on-chain integer. +### How do I compare launch activity across launchpads? + +Use the [cross-launchpad query](#compare-launchpad-activity): filter zero-address mints where `Transaction.To` is in the contract-map list, group by `Transaction.To`, and `count`. Add `dataset: combined` and a `Block.Time` window for full coverage. + ### Should I use the Events or Transfers method? Use **Events** when a launchpad emits a decoded creation event (like Flap.sh's `TokenCreated`) and you want the decoded arguments. Use **Transfers** — the mint-transfer pattern — for launchpads that don't expose a convenient event, which covers every protocol on this page. From 8c5b99dbee40f23329159e8e128fcd4f3dfd64c2 Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 21:10:55 +0530 Subject: [PATCH 8/9] Add raw TokenBought/TokenSold trade events to Flap.sh page Documents the bonding-curve engine's own decoded trade events (tested: args ts, token, buyer, amount, eth, fee, postPrice) alongside the existing lifecycle events, with matching keywords. Co-Authored-By: Claude Fable 5 --- docs/blockchain/robinhood/flap-sh-api.md | 44 ++++++++++++++++++++++++ 1 file changed, 44 insertions(+) diff --git a/docs/blockchain/robinhood/flap-sh-api.md b/docs/blockchain/robinhood/flap-sh-api.md index 98b7b6a3..f5cba5c9 100644 --- a/docs/blockchain/robinhood/flap-sh-api.md +++ b/docs/blockchain/robinhood/flap-sh-api.md @@ -21,6 +21,9 @@ keywords: - Flap.sh tax paid event - Flap.sh VanityTokenCreated - Flap.sh MsgSent social event + - Flap.sh TokenBought event + - Flap.sh TokenSold event + - Flap.sh raw bonding curve trades --- # Flap.sh API on Robinhood @@ -251,6 +254,47 @@ Beyond buy/sell trades, Flap.sh emits lifecycle events across several contracts Every query below can be run as a real-time stream — change the operation type to `subscription` in the Bitquery IDE. ::: +### Raw bonding-curve trades (`TokenBought` / `TokenSold`) + +The bonding-curve engine emits its own decoded trade events on the Flap.sh contract with on-chain-exact values. `TokenBought` arguments: `ts`, `token`, `buyer`, `amount`, `eth`, `fee`, `postPrice` — swap the signature name to `TokenSold` for sells. Use these when you need the exact fee and post-trade curve price; use `Trading.Trades` (above) for decimal-normalized, USD-priced trades. + +```graphql +{ + EVM(network: robinhood) { + Events( + limit: {count: 20} + orderBy: {descending: Block_Time} + where: { + Log: {Signature: {Name: {is: "TokenBought"}}} + LogHeader: {Address: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}} + } + ) { + Block { + Time + } + Transaction { + Hash + From + } + Arguments { + Name + Value { + ... on EVM_ABI_Address_Value_Arg { + address + } + ... on EVM_ABI_BigInt_Value_Arg { + bigInteger + } + ... on EVM_ABI_Integer_Value_Arg { + integer + } + } + } + } + } +} +``` + ### Token graduations (`LaunchedToDEX`) The most important lifecycle signal: a token completed its bonding curve and was **launched to a DEX**. The event returns the new `pool` address (use it with the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) to follow post-graduation trading), the migrated token `amount`, and the `eth` seeded into the pool. From b4bad315c5d9fbfa367abc138037d2aa3d60838a Mon Sep 17 00:00:00 2001 From: Gaurav agarwal Date: Thu, 23 Jul 2026 21:11:17 +0530 Subject: [PATCH 9/9] Refresh Bags.fm page example trader and WebSocket guidance Swaps the stale example trader for a currently active Bags trader and adds graphql-transport-ws connection details to the stream tip. Co-Authored-By: Claude Fable 5 --- docs/blockchain/robinhood/bags-fm-api.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/blockchain/robinhood/bags-fm-api.md b/docs/blockchain/robinhood/bags-fm-api.md index 3b98acbd..76533e2f 100644 --- a/docs/blockchain/robinhood/bags-fm-api.md +++ b/docs/blockchain/robinhood/bags-fm-api.md @@ -287,7 +287,7 @@ The query counterpart to the stream above — the most recent Bags trades across ``` :::tip Query ⇄ Stream -Every query on this page can be turned into a live stream — switch the operation type from `query` to `subscription` in the Bitquery IDE (and drop `orderBy`/`limit`, which don't apply to subscriptions). +Every query on this page can be turned into a live stream — switch the operation type from `query` to `subscription` in the Bitquery IDE (and drop `orderBy`/`limit`, which don't apply to subscriptions). Over WebSocket, connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol — see [WebSocket authentication](/docs/authorization/websocket/). ::: --- @@ -349,7 +349,7 @@ Scope trades to a single Bags token with `Pair.Token.Address`. This example uses ## Trades by a Trader on Bags -Track all Bags trades made by a specific wallet by filtering on `Trader.Address`. +Track all Bags trades made by a specific wallet by filtering on `Trader.Address`. Replace the example with any wallet address. ```graphql { @@ -358,7 +358,7 @@ Track all Bags trades made by a specific wallet by filtering on `Trader.Address` limit: {count: 50} orderBy: {descending: Block_Time} where: { - Trader: {Address: {is: "0x00a60b9760a4aa1a2fd6388b5cb6295f4c90cee0"}} + Trader: {Address: {is: "0x80f173cff2e585d1156f9a96b6195939ac1ba643"}} Pair: {Market: {ProtocolFamily: {is: "Bags"}}} } ) {