# Bitquery Docs — full text: Robinhood Chain
> 19 pages. All parts and the curated entry points: https://docs.bitquery.io/llms.txt
## Bags.fm API on Robinhood
URL: https://docs.bitquery.io/docs/blockchain/robinhood/bags-fm-api/
Bags.fm API on Robinhood Chain: bags_v2 trades, prices, OHLCV, market cap, whale trades, top traders and bonding-curve events via Bitquery GraphQL.
# Bags.fm API on Robinhood
**[Bags.fm](https://bags.fm/)** is a token launchpad on the **Robinhood** network where tokens trade on a bonding-curve AMM. This guide focuses on **Bags.fm trading data** — live and historical trades, USD prices, OHLCV/K-line candles, market cap, whale trades, top traders, and the raw bonding-curve `TokensBought`/`TokensSold` events — using Bitquery's `Trading` and `EVM(network: robinhood)` APIs.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches)
- [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) — bonding-curve launchpad, graduations, Uniswap v4 pools
- [Pools.trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## Bags.fm identifiers
Bags trades are indexed in the `Trading` cube under the **Bags** protocol family. Filter with `ProtocolFamily` (or `Protocol`) — you do **not** need a per-token contract address, since every Bags token trades under the same family.
| Field | Value | Notes |
| --- | --- | --- |
| `Pair.Market.ProtocolFamily` | `Bags` | Selects all Bags markets across tokens |
| `Pair.Market.Protocol` | `bags_v2` | Current Bags protocol version |
| `Network` / `NetworkBid` | `Robinhood` / `bid:robinhood` | Robinhood network |
| **Per-token Bags AMM** (beacon proxy, one per token) | `0xfa925c0589e98f564cd7456a0e7cd80722724ac5` (example: the MERRY AMM) | Each launch gets its own AMM proxy; it is the `Pair.Market.Program` of that token's `bags_v2` trades and the `LogHeader.Address` of its `TokensBought` / `TokensSold` / `FeesSplit` events. An AMM goes quiet when its token does, so look the address up from a recent trade rather than hard-coding it |
| **Bags AMM logic contract** (beacon implementation) | `0x419890a21711c3d3af46b58548376420b9723275` | Shared implementation behind every per-token AMM; appears as `Log.SmartContract` |
| **Bags factory (launch)** | `0xe8cc4431adf8b5a847c113ef0c6af9043219cb37` | Mints new Bags tokens — see [launches](/docs/blockchain/robinhood/robinhood-meme-coin-launches#bagsfm) |
:::note Per-token `Market.Program`
Each Bags token exposes its own `Pair.Market.Program` (the token's bonding-curve/pool contract). To scope trades to a single token, filter by `Pair.Token.Address` rather than `Program`; to get **all** Bags trading activity, filter by `ProtocolFamily: {is: "Bags"}`.
:::
---
## New Bags Token Launches
To detect **newly created** Bags tokens (before or alongside their first trades), use the mint-transfer pattern on the Bags factory contract — covered in detail on the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches#bagsfm) page.
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0xe8cc4431adf8b5a847c113ef0c6af9043219cb37"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
}
Transaction {
Hash
From
}
Transfer {
Amount
Receiver
Currency {
Name
Symbol
SmartContract
}
}
}
}
}
```
---
## Real-Time Bags Trades
Stream every Bags trade as it is indexed via a GraphQL `subscription` on `Trading.Trades`, scoped to the Bags protocol family on Robinhood. Includes side (buy/sell), trader, base/quote amounts (native and USD), market cap, and full transaction header.
▶️ [Run in IDE](https://ide.bitquery.io/bags-amm-trade-websocket)
```graphql
subscription {
Trading {
Trades(
where: {Pair: {Market: {ProtocolFamily: {is: "Bags"}, Network: {is: "Robinhood"}}}}
) {
Side
Supply {
CirculatingSupply
MarketCap
}
Trader {
Address
}
TransactionHeader {
Fee
FeePayer
Sender
To
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
Quote
}
Block {
Date
Time
Timestamp
}
Pair {
Currency {
Id
Name
Symbol
}
Market {
Address
Program
Network
Protocol
ProtocolFamily
}
QuoteCurrency {
Id
Name
Symbol
}
Token {
Address
Id
IsNative
Symbol
TokenId
Network
}
QuoteToken {
Address
Id
IsNative
Symbol
TokenId
Network
}
}
}
}
}
```
Sample response
```json
{
"Side": "Sell",
"Amounts": { "Base": 73809640, "Quote": 0.1017578 },
"AmountsInUsd": { "Base": 190.31902, "Quote": 190.31883 },
"Block": { "Date": "2026-07-16", "Time": "2026-07-16T17:25:21Z", "Timestamp": "1784222721000000000" },
"Supply": { "CirculatingSupply": 0, "MarketCap": 2578.51 },
"Trader": { "Address": "0x00a60b9760a4aa1a2fd6388b5cb6295f4c90cee0" },
"Pair": {
"Currency": { "Name": "Stud", "Symbol": "Stud", "Id": "bid:robinhood:0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a" },
"Market": { "Program": "0xfa925c0589e98f564cd7456a0e7cd80722724ac5", "Protocol": "bags_v2", "ProtocolFamily": "Bags", "Network": "Robinhood" },
"QuoteCurrency": { "Name": "Ethereum", "Symbol": "ETH", "Id": "bid:eth" },
"Token": { "Address": "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a", "Symbol": "Stud", "IsNative": false },
"QuoteToken": { "Symbol": "ETH", "IsNative": true, "Id": "bid:robinhood" }
}
}
```
---
## Latest Bags Trades
The query counterpart to the stream above — the most recent Bags trades across all tokens, newest first.
▶️ [Run in IDE](https://ide.bitquery.io/bags-trade)
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {Pair: {Market: {ProtocolFamily: {is: "Bags"}, Network: {is: "Robinhood"}}}}
) {
Side
Supply {
CirculatingSupply
MarketCap
}
Trader {
Address
}
TransactionHeader {
Fee
FeePayer
Sender
To
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
Quote
}
Block {
Date
Time
Timestamp
}
Pair {
Currency {
Id
Name
Symbol
}
Market {
Address
Program
Network
Protocol
ProtocolFamily
}
QuoteCurrency {
Id
Name
Symbol
}
Token {
Address
Id
IsNative
Symbol
TokenId
Network
}
QuoteToken {
Address
Id
IsNative
Symbol
TokenId
Network
}
}
}
}
}
```
:::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). Over WebSocket, connect to `wss://streaming.bitquery.io/graphql?token=YOUR_TOKEN` with the `graphql-transport-ws` subprotocol — see [WebSocket authentication](/docs/authorization/websocket/).
:::
---
## Trades for a Specific Bags Token
Scope trades to a single Bags token with `Pair.Token.Address`. This example uses the `MERRY` token (`0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a`).
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Pair: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}}
Market: {ProtocolFamily: {is: "Bags"}}
}
}
) {
Side
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Supply {
MarketCap
}
Pair {
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
}
}
TransactionHeader {
Hash
}
}
}
}
```
---
## Trades by a Trader on Bags
Track all Bags trades made by a specific wallet by filtering on `Trader.Address`. Replace the example with any wallet address.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Trader: {Address: {is: "0x7906d5e4a10fbb07f5491018ab29df072a76eb3d"}}
Pair: {Market: {ProtocolFamily: {is: "Bags"}}}
}
) {
Side
Block {
Time
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Pair {
Token {
Name
Symbol
Address
}
QuoteToken {
Symbol
}
}
TransactionHeader {
Hash
}
}
}
}
```
---
## Whale Trades on Bags
Surface large Bags trades by filtering on USD value. This example returns trades of at least `$500` — raise or lower the `AmountsInUsd.Base` threshold to match current Bags liquidity.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: AmountsInUsd_Base}
where: {
Pair: {Market: {ProtocolFamily: {is: "Bags"}}}
AmountsInUsd: {Base: {ge: 500}}
}
) {
Side
Block {
Time
}
Trader {
Address
}
AmountsInUsd {
Base
}
Amounts {
Base
Quote
}
Supply {
MarketCap
}
Pair {
Token {
Name
Symbol
Address
}
}
TransactionHeader {
Hash
}
}
}
}
```
---
## First Buyers of a Bags Token
Get the earliest trades for a token, ordered oldest first, to find the first buyers after launch. Filtered to `Buy` here; remove the `Side` filter for the first trades of any side.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {ascending: [Block_Time, TransactionHeader_Index]}
where: {
Pair: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}}
Market: {ProtocolFamily: {is: "Bags"}}
}
Side: {is: "Buy"}
}
) {
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Side
TransactionHeader {
Hash
}
}
}
}
```
---
## Top Traders of a Bags Token
Rank the biggest traders of a specific Bags token by total USD volume, with a buy/sell split and trade count. Aggregates `Trading.Trades` grouped by trader.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descendingByField: "volume_usd"}
where: {
Pair: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}}
Market: {ProtocolFamily: {is: "Bags"}}
}
}
) {
Trader {
Address
}
volume_usd: sum(of: AmountsInUsd_Base)
bought_usd: sum(of: AmountsInUsd_Base, if: {Side: {is: "Buy"}})
sold_usd: sum(of: AmountsInUsd_Base, if: {Side: {is: "Sell"}})
trades: count
}
}
}
```
---
## Latest Price of a Bags Token
Get the latest USD-normalised price of a Bags token using `Trading.Tokens` with the `bid:robinhood` network filter. The price is the pool-weighted average across the token's markets.
```graphql
{
Trading {
Tokens(
limit: {count: 1}
orderBy: {descending: Interval_Time_End}
where: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}, NetworkBid: {is: "bid:robinhood"}}
Interval: {Time: {Duration: {eq: 1}}}
}
) {
latest_price: Price {
Ohlc {
Close
}
}
}
}
}
```
---
## Market Cap, FDV and Supply of a Bags Token
Get the latest market cap, fully-diluted valuation, supply, price, and USD volume for a single Bags token in one row.
```graphql
{
Trading {
Tokens(
limit: {count: 1}
orderBy: {descending: Interval_Time_Start}
where: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}, NetworkBid: {is: "bid:robinhood"}}
Interval: {Time: {Duration: {eq: 1}}}
}
) {
Token {
Name
Symbol
Address
}
Price {
Ohlc {
Close
}
}
Supply {
MarketCap
FullyDilutedValuationUsd
CirculatingSupply
TotalSupply
}
Volume {
Usd
}
}
}
}
```
Sample response
```json
{
"Token": { "Name": "Stud", "Symbol": "Stud", "Address": "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a" },
"Price": { "Ohlc": { "Close": 2.3498699e-06 } },
"Supply": {
"MarketCap": 2451.49,
"FullyDilutedValuationUsd": 2451.49,
"CirculatingSupply": 0,
"TotalSupply": 1000000000
},
"Volume": { "Usd": 44.038837 }
}
```
---
## OHLCV / K-Line Candles for a Bags Token
Token-level OHLCV candles (USD-normalised, weighted across all pools) for charting. This example uses 1-minute candles (`Duration: 60`); use `1` (1s), `300` (5m), or `3600` (1h — the maximum) as needed.
```graphql
{
Trading {
Tokens(
limit: {count: 100}
orderBy: {descending: Interval_Time_Start}
where: {
Token: {Address: {is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"}, NetworkBid: {is: "bid:robinhood"}}
Interval: {Time: {Duration: {eq: 60}}}
}
) {
Interval {
Time {
Start
End
}
}
Price {
Ohlc {
Open
High
Low
Close
}
}
Volume {
Base
Quote
Usd
}
Supply {
MarketCap
}
}
}
}
```
---
## Top Bags Tokens by Volume
Rank the most actively traded Bags tokens by USD volume over the last 24 hours. This aggregates `Trading.Trades` grouped by token — the `Trading.Tokens` cube doesn't expose a protocol-family filter, so scope by `ProtocolFamily` on the trades and group by `Pair.Token`.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descendingByField: "volume_usd"}
where: {
Pair: {Market: {ProtocolFamily: {is: "Bags"}}}
Block: {Time: {since_relative: {days_ago: 1}}}
}
) {
Pair {
Token {
Name
Symbol
Address
}
}
volume_usd: sum(of: AmountsInUsd_Base)
trades: count
}
}
}
```
Sample response
```json
{
"Pair": { "Token": { "Name": "Crypto Cats", "Symbol": "CRYPTOCATS", "Address": "0x366c07ef29f06c7e9e6d0078eb7e31186f87605c" } },
"trades": "238",
"volume_usd": "17691.63"
}
```
:::note Getting per-token market cap
This aggregation gives volume and trade counts per token. To add the latest market cap / FDV for any token in the results, pass its `Token.Address` to the [Market Cap, FDV and Supply](#market-cap-fdv-and-supply-of-a-bags-token) query above.
:::
---
## Raw Bonding-Curve Trades (`TokensBought` / `TokensSold`)
For the lowest-level view, read Bags trades directly from the AMM's decoded logs. The Bags bonding-curve logic contract (`0x419890a21711c3d3af46b58548376420b9723275`, proxied by `0xfa925c0589e98f564cd7456a0e7cd80722724ac5`) emits **`TokensBought`** and **`TokensSold`** with full fee breakdown and virtual reserves — data that isn't exposed by the higher-level `Trading.Trades` cube.
### Bags buys (`TokensBought`)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "TokensBought"}}, SmartContract: {is: "0x419890a21711c3d3af46b58548376420b9723275"}}}
) {
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
}
}
}
}
}
}
```
`TokensBought` arguments: `buyer`, `recipient`, `grossQuoteIn`, `netQuoteIn`, `tokensOut`, `feeQuote`, `vaultFeeQuote`, `creatorFeeWETH`, `refundQuote`, `price`, `virtualTokenReserves`, `virtualQuoteReserves`.
### Bags sells (`TokensSold`)
Swap the signature name to stream sells. Arguments: `seller`, `recipient`, `tokensIn`, `grossQuoteOut`, `netQuoteToRecipient`, `feeQuote`, `vaultFeeQuote`, `creatorFeeWETH`, `price`, `virtualTokenReserves`, `virtualQuoteReserves`.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "TokensSold"}}, SmartContract: {is: "0x419890a21711c3d3af46b58548376420b9723275"}}}
) {
Block {
Time
}
Transaction {
Hash
From
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
:::note Raw integers vs normalized amounts
`TokensBought` / `TokensSold` arguments are **raw on-chain integers** (WETH-style quote amounts are `1e18`-scaled; `tokensOut`/`tokensIn` use the token's own decimals). Use `Trading.Trades` (above) when you want decimal-normalized and USD-priced amounts; use these events when you need the exact fee split, `price`, and `virtualTokenReserves`/`virtualQuoteReserves` from the bonding curve.
:::
---
## All Bags AMM Events
Enumerate the event signatures emitted through one token's Bags AMM proxy (the MERRY AMM here; swap in the `Pair.Market.Program` of any live Bags token) to discover what else you can index (fee splits, initialization, role/ownership changes).
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 100}
where: {LogHeader: {Address: {is: "0xfa925c0589e98f564cd7456a0e7cd80722724ac5"}}}
) {
count
Log {
Signature {
Name
}
SmartContract
}
}
}
}
```
Observed signatures include `TokensBought`, `TokensSold`, `FeesSplit`, `Initialized`, `RoleGranted`, `OwnershipTransferred`, and `BeaconUpgraded` (most emitted by the logic contract `0x419890a21711c3d3af46b58548376420b9723275`).
---
## FAQ
### How do I get all Bags.fm trades?
Query `Trading.Trades` filtered by `Pair.Market.ProtocolFamily: {is: "Bags"}` (optionally with `Network: {is: "Robinhood"}`). This returns trades across every Bags token — no per-token address needed.
### How do I stream Bags trades in real time?
Run a GraphQL `subscription` on `Trading.Trades` with the same `ProtocolFamily: "Bags"` filter, or open the [WebSocket IDE link](https://ide.bitquery.io/bags-amm-trade-websocket). Any query on this page can be converted to a stream by switching the operation to `subscription`.
### What's the difference between `Trading.Trades` and the `TokensBought`/`TokensSold` events?
`Trading.Trades` gives decimal-normalized, USD-priced trades with market cap and a unified buy/sell `Side` — best for analytics and charts. The `TokensBought`/`TokensSold` events are the raw bonding-curve logs with the exact fee breakdown (`feeQuote`, `vaultFeeQuote`, `creatorFeeWETH`), execution `price`, and virtual reserves — best when you need on-chain-exact values.
### How do I get the price, market cap, or OHLCV of a Bags token?
Use `Trading.Tokens` with `Token.Address` and `NetworkBid: {is: "bid:robinhood"}`. Set `Interval.Time.Duration` (seconds) for OHLCV candles, or read `Supply.MarketCap` / `Supply.FullyDilutedValuationUsd` for valuations.
### Which protocol value does Bags use?
Bags markets report `Protocol: "bags_v2"` under `ProtocolFamily: "Bags"`. Filter on `ProtocolFamily` so your queries keep working across protocol versions.
### How do I detect a newly launched Bags token?
Use the mint-transfer pattern on the Bags factory (`0xe8cc4431adf8b5a847c113ef0c6af9043219cb37`) — a transfer from the zero address with `Amount` `1000000000`. See the [launches page](/docs/blockchain/robinhood/robinhood-meme-coin-launches#bagsfm).
---
## Next steps
- Stream Bags trades live with the [WebSocket query](https://ide.bitquery.io/bags-amm-trade-websocket) for real-time dashboards and alerts.
- Detect new Bags tokens the moment they launch with the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches#bagsfm).
- Compare against other Robinhood launchpads with the [Flap.sh API](/docs/blockchain/robinhood/flap-sh-api).
- Explore network-wide prices, OHLCV, and top traders in the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
---
## Flap.sh API on Robinhood
URL: https://docs.bitquery.io/docs/blockchain/robinhood/flap-sh-api/
Flap.sh API on Robinhood Chain: TokenCreated launches, bonding-curve buys and sells, DEX graduations and flap_v5 trades via Bitquery GraphQL and WebSocket.
# Flap.sh API on Robinhood
**Flap.sh** is a token launchpad on the **Robinhood** network. This guide shows how to track **newly launched Flap.sh tokens**, **Flap.sh trades**, and **lifecycle events** — token graduations, bonding-curve progress, supply changes, tax paid, vanity tokens, and social messages — with Bitquery GraphQL APIs, using the `EVM(network: robinhood)` and `Trading` cubes.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) — bonding-curve launchpad, graduations, Uniswap v4 pools
- [Pools.trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## Flap.sh contracts
Flap.sh is **not a single contract**. A router takes the user's transaction, a factory mints the token, and a separate bonding-curve engine handles every buy and sell. Each role emits a different set of events from a different address, and more than one address is live in each role.
| Role | Address | Emits |
| --- | --- | --- |
| **Router proxy** (entry point and log emitter) | `0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09` | **Every Flap.sh event.** `LogHeader.Address` is this proxy on `TokenCreated`, `TokenBought`, `TokenSold`, progress, supply and tax events; it is also `Transaction.To` on launch and trade transactions. |
| **Token factory implementations** (`Log.SmartContract`, more exist) | `0x78eb178d94739b8adf199543924e47e9547c4924`
`0x549574ddf0d72928f2041c17daab2097dd46d815` | `TokenCreated`, `TokenCurveSetV2`, `FlapTokenTaxSet`, `TokenQuoteSet`, `TokenVersionSet`, `TokenDexPreferenceSet`, `TokenDexSupplyThreshSet`, `TokenMigratorSet` |
| **Vanity token factory implementations** (`Log.SmartContract`) | `0xa2fb48fefb15f777ec6ac3857164550ee93c1f25`
`0x52e3eb4f18dfb8215e17d27dee5718075f6c2639` | `VanityTokenCreated`, plus the same `TokenCreated` / `TokenCurveSetV2` pair |
| **Bonding-curve engine implementations** (`Log.SmartContract`, more exist) | `0x87a697bf7fbe28dc1eccc4d9b4bd1cfa76885f93`
`0x2a50c45b5cbb9e5c735f094c6386c39f8ffbc655` | `TokenBought`, `TokenSold`, `TaxV2OnBondingCurvePaid`, `FlapTokenProgressChanged`, `FlapTokenCirculatingSupplyChanged` |
| Field | Value |
| --- | --- |
| **Launch mint `Amount`** | `1000000000` (1 billion, decimal-normalized) |
:::info The router proxy is the emitter; the implementations rotate
`0x26605f32…` is the `LogHeader.Address` of every Flap.sh event and the `Transaction.To` of every launch and trade, so it is the right address to pin queries to. The factory and curve-engine contracts are implementations behind that proxy: they show up as `Log.SmartContract`, more than one is live per role, and new ones appear when Flap.sh upgrades. Match events by `Log.Signature.Name` with `LogHeader.Address` pinned to the proxy, and read `Log.SmartContract` only when you need to know which implementation handled a row. Launches also arrive through vanity routers; pin `Transaction.To` to the router only for mint-transfer queries.
:::
:::note Datasets
Transfers, Events and Calls queries default to the realtime dataset, which holds only the most recent days on Robinhood; add `dataset: combined` or `dataset: archive` for history. Flap.sh trades also appear in the `Trading` cube as `Protocol: flap_v5`, which holds a rolling window of roughly the last 30 days.
:::
---
## Newly launched tokens
Flap.sh launches can be detected via decoded **`TokenCreated`** events or via **mint transfers** from the zero address.
### Flap.sh newly created tokens using logs (`TokenCreated`)
Filter Flap.sh `TokenCreated` events and decode argument values (token address, metadata fields, and related parameters).
▶️ [Run in IDE](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-logs-TokenCreated) · [WebSocket stream](https://ide.bitquery.io/Flap-sh-Newly-created-tokens-using-logs-TokenCreated---Websocket)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
where: {
Log: {Signature: {Name: {is: "TokenCreated"}}}
LogHeader: {Address: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}
}
) {
Transaction {
Hash
From
To
}
Log {
Signature {
Name
}
SmartContract
}
Arguments {
Name
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
### Flap.sh newly created tokens using transfer data
Track Flap.sh mints as transfers from the zero address with amount `1000000000` in transactions sent to the Flap.sh contract.
▶️ [Run in IDE](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-transfer-data) · [WebSocket stream](https://ide.bitquery.io/Flap-Sh-Newly-created-tokens-using-transfer-data---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
:::note Amounts are decimal-normalized
Bitquery's `Transfer.Amount` is already adjusted for the token's `Decimals`, so `1000000000` means 1 billion whole tokens — not the raw on-chain integer. Compare against the normalized value, not the raw one.
:::
---
## Flap.sh trades
Query trades on Flap.sh markets using the `Trading.Trades` cube, scoped by the Flap.sh contract as `Pair.Market.Program`. This example returns trades from the last hour.
```graphql
{
Trading {
Trades(
limit: {count: 10}
where: {Pair: {Market: {Program: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}}, Block: {Time: {since_relative: {hours_ago: 1}}}}
) {
Side
Supply {
CirculatingSupply
MarketCap
}
Trader {
Address
}
TransactionHeader {
Fee
FeePayer
Sender
To
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
Quote
}
Block {
Date
Time
Timestamp
}
Pair {
Market {
Protocol
ProtocolFamily
Address
Program
Network
}
Token {
Address
Id
IsNative
Symbol
TokenId
Network
}
QuoteToken {
Address
Id
IsNative
Symbol
TokenId
Network
}
}
}
}
}
```
:::tip Stream the same query
Change the operation type from a query to a `subscription` in the Bitquery IDE to receive Flap.sh trades in real time over WebSocket.
:::
---
## Event-specific APIs
Beyond buy/sell trades, Flap.sh emits lifecycle events across several contracts (bonding-curve engine, factories, and the router). Because a given event is emitted by more than one contract, filter these queries by `Log.Signature.Name` rather than a single address. Each event includes a `token` argument identifying the affected token, so you can add `Arguments: {includes: {Name: {is: "token"}, Value: {Address: {is: "0x..."}}}}` to scope any query to one token.
:::tip Stream any event
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.
:::caution `LaunchedToDEX` is not exclusive to Flap.sh
Other Robinhood Chain launchpads emit an event with this same name. The query below returns graduations across all of them. To keep the feed Flap.sh-only, add a `LogHeader.Address` filter for the curve engines listed in [Flap.sh contracts](#flapsh-contracts), or check the graduated `token` against a Flap.sh `TokenCreated` / `TokenCurveSetV2` pair before acting on it.
:::
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "LaunchedToDEX"}}}}
) {
Block {
Time
}
Transaction {
Hash
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Arguments: `token` (graduated token), `pool` (new DEX pool address), `amount` (tokens moved to the pool), `eth` (native seeded into the pool).
### Bonding-curve progress (`FlapTokenProgressChanged`)
Track how close a token is to graduation. `newProgress` is scaled to `1e18`, so `562290208719467141` ≈ **56.2%**. Great for progress bars and "about to graduate" alerts.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "FlapTokenProgressChanged"}}}}
) {
Block {
Time
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Arguments: `token`, `newProgress` (fraction of the curve completed, scaled by `1e18` → divide by `1e18` for a `0–1` ratio, or `×100` for a percentage).
### Circulating supply changes (`FlapTokenCirculatingSupplyChanged`)
Live circulating-supply updates for a token — useful for accurate off-chain market-cap math. `newSupply` is the raw on-chain integer (divide by the token's `1e18` decimals).
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "FlapTokenCirculatingSupplyChanged"}}}}
) {
Block {
Time
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Arguments: `token`, `newSupply` (new circulating supply, raw integer).
### Bonding-curve tax paid (`TaxV2OnBondingCurvePaid`)
Tax/fee revenue paid on the bonding curve, per token. Aggregate `amount` over time (or per token) for fee analytics.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "TaxV2OnBondingCurvePaid"}}}}
) {
Block {
Time
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Arguments: `token`, `amount` (tax paid in native units, raw integer).
### Vanity tokens created (`VanityTokenCreated`)
A separate creation channel for **vanity tokens** — those with custom address suffixes (`8888`, `7777`). Complements the standard `TokenCreated` event on the [launches page](/docs/blockchain/robinhood/robinhood-meme-coin-launches).
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "VanityTokenCreated"}}}}
) {
Block {
Time
}
Transaction {
Hash
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
}
}
}
}
}
```
Arguments: `token` (new vanity token), `creator`, `beneficiary`.
### Social messages (`MsgSent`)
Flap.sh links social content to tokens through `MsgSent`. The `message` string carries structured commands such as `ADD_TWEET::`, tying a token to a tweet or other social metadata.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "MsgSent"}}}}
) {
Block {
Time
}
Transaction {
Hash
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_String_Value_Arg {
string
}
}
}
}
}
}
```
Arguments: `sender`, `token`, `message` (e.g. `ADD_TWEET::2077406373457871178`).
---
## FAQ
### How do I detect a newly launched Flap.sh token?
Use the **`TokenCreated`** event on the Flap.sh contract (`0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09`) for decoded arguments, or the **mint-transfer** pattern — a transfer from the zero address with `Amount` `1000000000` where `Transaction.To` is the Flap.sh contract.
### How do I get Flap.sh trades?
Query `Trading.Trades` filtered by `Pair.Market.Program: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"`. Add a `Block.Time` filter to scope to a time window, or switch the operation to `subscription` to stream trades live.
### How do I know when a Flap.sh token graduates to a DEX?
Filter events by `Log.Signature.Name: "LaunchedToDEX"`. Each event gives the graduated `token`, the new `pool` address, and the token/native `amount` seeded into the pool. Run it as a `subscription` for real-time graduation alerts.
### How do I track a token's bonding-curve progress?
Use the `FlapTokenProgressChanged` event. `newProgress` is scaled by `1e18`, so divide by `1e18` for a `0–1` ratio (or `×100` for a percentage). Scope to a single token by matching the `token` argument.
### Why do the event queries filter by `Log.Signature.Name` instead of a contract address?
Flap.sh emits its events from several contracts — separate factories, vanity factories, and bonding-curve engines, each with more than one live address (see [Flap.sh contracts](#flapsh-contracts)). Filtering by the signature name captures the event across all of them. Add an `Arguments.includes` filter on the `token` argument to scope to one token.
### Can a signature-name filter pick up other protocols?
Yes, for generic names. `TokenCreated` in particular is emitted by several unrelated launchpads on Robinhood Chain, and `LaunchedToDEX` is emitted by protocols other than Flap.sh. Names carrying the `Flap` prefix — `FlapTokenProgressChanged`, `FlapTokenCirculatingSupplyChanged`, `FlapTokenTaxSet` — are unambiguous; the generic ones are not.
If a feed must be Flap.sh-only, add a `LogHeader.Address` filter pinned to the factory and curve addresses in [Flap.sh contracts](#flapsh-contracts), or cross-check the token against a `TokenCurveSetV2` event, which the Flap.sh factories always emit alongside `TokenCreated`.
---
## Next steps
- Stream **`LaunchedToDEX`** for real-time graduation alerts, then follow the new pool with the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
- Track other Robinhood launchpads and bots with the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches).
- Explore prices, OHLCV, whale trades, and top traders in the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
- Inspect holder and wallet flows with [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers).
---
## Lighter Perp DEX on Robinhood Chain API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/lighter-perp-dex-api/
Lighter perp DEX on Robinhood Chain: USDG margin deposits and withdrawals, ZkLighter rollup contract and batch commits via Bitquery GraphQL and WebSocket.
# Lighter Perp DEX on Robinhood Chain API
[Lighter](https://lighter.xyz) is the perpetual-futures DEX integrated into Robinhood Wallet. When Robinhood Chain mainnet went live on July 1, 2026, Lighter launched alongside it as the venue behind in-app perps: eligible users post **USDG** margin from their wallet, and the funds are locked in Lighter's smart contract on Robinhood Chain while positions are managed by Lighter's zk engine.
What actually lives on Robinhood Chain is a full **ZkLighter rollup contract** — not just a token vault. It receives every margin deposit, queues and pays withdrawals, and records the rollup's batch lifecycle (`commit → verify → execute`) at roughly **one batch per minute**. This page shows how to query and stream all of it with Bitquery's `EVM` cubes on `network: robinhood`.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/)
- [Robinhood Calls API](/docs/blockchain/robinhood/robinhood-calls-api/)
- [Robinhood Balances API](/docs/blockchain/robinhood/robinhood-balances-api/)
- [EVM Events schema](/docs/schema/evm/events/)
:::
**On this page:** [What is on-chain](#what-is-on-chain-and-what-is-not) · [Contracts](#contract-map) · [Event reference](#event-reference-topic0-map) · [Deposits](#track-margin-deposits) · [Withdrawals](#track-withdrawals) · [Margin flow & history](#usdg-margin-flow-full-history) · [Rollup heartbeat](#monitor-the-rollup-heartbeat) · [Deposit calls](#deposit-calls-by-selector) · [Decoding notes](#decoding-notes)
---
## What is on-chain (and what is not)
Lighter's matching engine, order book, positions, funding, and liquidations run inside its zk rollup — they are **not** individual Robinhood Chain transactions. What settles on Robinhood Chain, and what Bitquery therefore indexes, is:
| On Robinhood Chain (queryable here) | Inside the Lighter engine (not on-chain) |
| --- | --- |
| USDG margin **deposits** into the ZkLighter contract | Individual trades and fills |
| **Withdrawal** queue events and USDG payouts back to users | Open positions and PnL |
| Rollup **batch lifecycle**: commit, verification, execution, state roots | Funding payments (hourly, peer-to-peer) |
| Priority requests (forced operations, key changes, escape hatches) | Order placement and cancellation (except the on-chain `cancelAllOrders` escape hatch) |
| Market/asset registry events | Liquidation events themselves (only the margin effects appear) |
This makes the on-chain data ideal for **money-flow questions** — who is depositing margin, how much, net flows, contract TVL, whether the rollup operator is alive — rather than trade-level analytics.
---
## Contract map
| Role | Address |
| --- | --- |
| **ZkLighter proxy** — receives margin, pays withdrawals, emits every Lighter event | `0x94bab9693ba2f6358507effcbd372b0660afff9d` |
| Current verified implementation (`ZkLighter`) | `0x82DE5B1161C93afDFE21bA0D5343f01Cd7401d90` |
| USDG (Global Dollar, 6 decimals) — canonical currency address in Bitquery cubes | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` |
| Robinhood deposit router (sweeps in-app deposits into `deposit()`) | `0x8062df5b3220ad1f528365650a3eb3e8c7b0dad1` |
:::info Filter by LogHeader.Address, not Log.SmartContract
The ZkLighter proxy delegates to implementation modules, so `Log.SmartContract` shows the **implementation** address — and implementations rotate on upgrades (implementations rotate over time; older module addresses you may see in results include `0x1be72833…`, `0xe470e41c…`, and `0xda2b59ff…`). The stable anchor is `LogHeader.Address` = the proxy `0x94bab969…`, combined with the event's `SignatureHash` (topic0). Every query below follows that pattern.
:::
---
## Event reference (topic0 map)
All events are emitted with the proxy as `LogHeader.Address`. Hash fields in Bitquery are hex strings **without** a `0x` prefix.
| Event | topic0 (`Log.Signature.SignatureHash`) |
| --- | --- |
| `Deposit(uint48 toAccountIndex, address toAddress, uint16 assetIndex, uint8 routeType, uint128 baseAmount)` | `493c3b8240368e8343bcd42cac5f4b8b161c06d061710e542a72f06a40ddd9d1` |
| `WithdrawPending(address indexed owner, uint16 assetIndex, uint128 baseAmount)` | `ef80235b5f4cf1822ad6a8621af41ac64372ff672c402874f507fc63dbe5e06f` |
| `NewPriorityRequest(address sender, uint64 serialId, uint8 pubdataType, bytes pubData, uint64 expirationTimestamp)` | `efdd379e3e15772fcc7d2a67fa5bbb0790b932724153aded4648307094733b2f` |
| `BatchCommit(uint64 batchNumber, uint32 batchSize, uint64 endBlockNumber)` | `181b25ea9d4d730f30d779f3d2099c03b26b653c889d33eef253d54baaacbd0d` |
| `BatchVerification(uint64 batchNumber, uint32 batchSize, uint64 endBlockNumber)` | `5c836e1ff20ea85c52b6e3d2ef0124d3304bf3b37cc8fb0e2c84ae7d44c0593e` |
| `BatchesExecuted(uint64 batchNumber, uint64 endBlockNumber)` | `5d490d991d08230b7690c7511bb854b7b8a05fb7c87e2348e1909384cb325511` |
| `StateRootUpdate(uint64 batchNumber, bytes32 oldStateRoot, bytes32 newStateRoot)` | `645e0b8f839353842bdac87abd27fc8bdda536e0731cdb7cc75e4f0740b575ac` |
| `CreateMarket((uint16,uint8,bytes), uint8 sizeDecimals, uint8 priceDecimals, bytes32 symbol)` | `134f63a6bbe3b3ef885ce4067eb2753fe1c912c51c4b8e0cc7966f21773c047e` |
| `RegisterAssetConfig(uint16 assetIndex, address tokenAddress, …)` | `f1b24e81016b9f39e2290cf2a9303264a07534a569df7e6200a39573d7f26b0c` |
The remaining admin events (`UpdateMarket`, `UpdateAssetConfig`, `BatchesRevert`, `DesertMode`, `TreasuryUpdate`, `InsuranceFundOperatorUpdate`, `Initialized`) exist in the ABI but fire rarely; the full verified ABI is on the [Robinhood Chain explorer](https://robinhoodchain.blockscout.com/address/0x82DE5B1161C93afDFE21bA0D5343f01Cd7401d90?tab=contract).
---
## Track margin deposits
Every deposit into Lighter emits one `Deposit` event. This query returns the latest ones; turn it into a live stream by replacing `query` with `subscription` and dropping `dataset`/`limit`/`orderBy`.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Events(
limit: { count: 10 }
orderBy: { descending: Block_Number }
where: {
LogHeader: { Address: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" } }
Log: { Signature: { SignatureHash: { is: "493c3b8240368e8343bcd42cac5f4b8b161c06d061710e542a72f06a40ddd9d1" } } }
}
) {
Block { Number Time }
Transaction { Hash From }
Log { SmartContract Signature { SignatureHash } }
LogHeader { Address Data }
}
}
}
```
`Deposit` has no indexed parameters, so all five fields sit in `LogHeader.Data` as 32-byte words, in ABI order:
| Word | Field | Notes |
| --- | --- | --- |
| 0 | `toAccountIndex` | The user's Lighter account index |
| 1 | `toAddress` | The wallet credited — for Robinhood-app deposits this is the user's deposit address, while the ERC-20 transfer arrives via the router `0x8062df5b…` |
| 2 | `assetIndex` | `3` = USDG on this deployment |
| 3 | `routeType` | `0` for ~98% of deposits |
| 4 | `baseAmount` | Raw token units — divide by 10⁶ for USDG (verified to match the ERC-20 transfer in the same transaction) |
---
## Track withdrawals
Withdrawals are two-step: the rollup queues the amount (`WithdrawPending`, with the receiving wallet **indexed** as `Topics[1]`), then operator transactions push the USDG payout to the user via `withdrawPendingBalance`. To watch the queue:
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Events(
limit: { count: 10 }
orderBy: { descending: Block_Number }
where: {
LogHeader: { Address: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" } }
Log: { Signature: { SignatureHash: { is: "ef80235b5f4cf1822ad6a8621af41ac64372ff672c402874f507fc63dbe5e06f" } } }
}
) {
Block { Number Time }
Transaction { Hash }
Topics { Hash } # Topics[1] = padded owner address
LogHeader { Data } # [assetIndex, baseAmount(6dp)]
}
}
}
```
The actual payout is a plain USDG transfer **from** the proxy, so the Transfers query below covers the money leg of withdrawals too.
---
## USDG margin flow (full history)
The simplest lens on Lighter needs no event decoding at all: USDG transfers to the proxy are margin in, transfers from it are margin out. The `combined` dataset holds Robinhood Chain history back to the chain's start, so this works from Lighter's first deposit (June 26, 2026 — a soft start a few days before the public July 1 launch).
Monthly deposit and withdrawal totals since launch:
```graphql
{
EVM(network: robinhood, dataset: combined) {
deposits: Transfers(
where: {
Transfer: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Receiver: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" }
}
}
) {
Block { Date(interval: { count: 1, in: months }) }
count
sum(of: Transfer_Amount)
}
withdrawals: Transfers(
where: {
Transfer: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Sender: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" }
}
}
) {
Block { Date(interval: { count: 1, in: months }) }
count
sum(of: Transfer_Amount)
}
}
}
```
Swap the monthly interval for a `days` interval for daily flow charts, or drop the aggregation and add `limit`/`orderBy` to list individual transfers with sender and receiver. The difference between lifetime deposits and withdrawals is the contract's standing USDG balance — Lighter-on-Robinhood's margin TVL.
To size total activity, an aggregate probe over full history:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
where: {
LogHeader: { Address: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" } }
Log: { Signature: { SignatureHash: { is: "493c3b8240368e8343bcd42cac5f4b8b161c06d061710e542a72f06a40ddd9d1" } } }
}
) {
count
earliest: Block { Time(minimum: Block_Time) }
latest: Block { Time(maximum: Block_Time) }
}
}
}
```
---
## Monitor the rollup heartbeat
Lighter posts its zk batch lifecycle to Robinhood Chain about once a minute. Streaming the three lifecycle events is a ready-made **liveness monitor** for the venue — if commits stop, the engine or its operator has a problem:
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: { Address: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" } }
Log: {
Signature: {
SignatureHash: {
in: [
"181b25ea9d4d730f30d779f3d2099c03b26b653c889d33eef253d54baaacbd0d"
"5c836e1ff20ea85c52b6e3d2ef0124d3304bf3b37cc8fb0e2c84ae7d44c0593e"
"5d490d991d08230b7690c7511bb854b7b8a05fb7c87e2348e1909384cb325511"
]
}
}
}
}
) {
Block { Number Time }
Transaction { Hash From }
Log { Signature { SignatureHash } }
LogHeader { Data } # batchNumber, batchSize, endBlockNumber
}
}
}
```
Each of `commitBatch`, `verifyBatch`, and `executeBatches` is sent by a single operator EOA, so `Transaction.From` also identifies the Lighter operator.
---
## deposit() calls by selector
The Calls cube gives the function-call view of the same activity — useful for catching deposits, forced withdrawals (`withdraw`, selector `d20191bd`), key registrations (`changePubKey`, `17010c68`), and escape-hatch cancels (`cancelAllOrders`, `a4b6f756`):
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Calls(
limit: { count: 10 }
orderBy: { descending: Block_Number }
where: {
Call: {
To: { is: "0x94bab9693ba2f6358507effcbd372b0660afff9d" }
Signature: { SignatureHash: { is: "8a857083" } } # deposit(address,uint16,uint8,uint256)
}
}
) {
Block { Number Time }
Call { From Value Signature { SignatureHash } }
Transaction { Hash From }
}
}
}
```
---
## Decoding notes
- **Signatures currently arrive unparsed** — `Log.Signature.Name` is empty for ZkLighter events until the ABI is registered in the decoding pipeline, so filter by `SignatureHash` (as every query on this page does) and decode `LogHeader.Data` client-side with the word layouts above. Once the ABI lands, the same queries also return decoded `Arguments`.
- `LogHeader.Address` is the address a node's `eth_getLogs` would report; `Log.SmartContract` is the implementation behind the proxy and changes on upgrades. Pin queries to `LogHeader.Address`.
- Amounts (`baseAmount` and USDG `Transfer.Amount`) are 6-decimal USDG units; `Transfer.Amount` in the API is already decimal-adjusted.
- Robinhood in-app deposits are swept from per-user deposit addresses through the router `0x8062df5b…`, so the ERC-20 `Transfer.Sender` into the proxy is often the router while the credited wallet is `Deposit.toAddress`. Count depositors from the `Deposit` event, not from transfer senders.
- For trade-level perps data (fills, positions, funding), use Lighter's own venue APIs — that activity never touches Robinhood Chain. On-chain data here answers flow, TVL, user-count, and liveness questions.
Every query on this page was executed against the production `streaming.bitquery.io/graphql` endpoint before publishing.
---
## ONDO Tokenized Stocks API on Robinhood Chain
URL: https://docs.bitquery.io/docs/blockchain/robinhood/ondo-stocks-api/
Query and stream Ondo Finance tokenized stocks on Robinhood Chain: catalog of ONDO stocks, holders, OHLCV, latest price, live price streams, and cross-pool arbitrage via Bitquery GraphQL.
# ONDO Tokenized Stocks API on Robinhood Chain
[Ondo Finance](https://ondo.finance/) issues **tokenized stocks and ETFs** as ERC-20s on Robinhood Chain (`network: robinhood`, chain ID **4663**). Each ticker is a 1:1 on-chain claim on the underlying equity (for example `NVDAon`, `AAPLon`). Bitquery indexes those tokens as ordinary ERC-20s, so you can catalog every ONDO stock, list holders, and pull prices, candles, and live streams through the same `EVM` and `Trading` cubes used for any Robinhood token.
:::tip These examples use the Trading API
Price, OHLCV, live quotes, and cross-pool prices on this page use the [**Trading cube**](/docs/trading/trading-data-overview) — [`Trading.Tokens`](/docs/trading/crypto-price-api/tokens) and [`Trading.Pairs`](/docs/trading/crypto-price-api/pairs). Scope Robinhood with `NetworkBid: { is: "bid:robinhood" }`. `Trading` covers **real-time plus roughly the last 30 days**. Holder rankings use `EVM.Holders` on `dataset: archive`.
:::
:::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 API](/docs/blockchain/robinhood/robinhood-trades/)
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/)
- [xStocks API (Solana)](/docs/blockchain/Solana/xstocks-api/)
- [Trading data overview](/docs/trading/trading-data-overview/)
:::
---
## How ONDO stocks appear on-chain
ONDO tickers on Robinhood Chain use a symbol that **ends with `on`**. New supply is minted from the zero address into Ondo's issuance / custody contract. The catalog query below uses that mint pattern:
| Filter | Value | Meaning |
| --- | --- | --- |
| `Transfer.Sender` | `0x0000000000000000000000000000000000000000` | Mint (issuance) |
| `Transfer.Receiver` | `0xf2dc25b8a5231667d8cf0ecd476fb46805186572` | Ondo issuance / custody wallet |
| `Currency.Symbol.endsWith` | `"on"` | ONDO ticker suffix |
Copy a `SmartContract` from the catalog into the holder, OHLCV, price, and arbitrage queries. Token IDs in the Trading cubes look like `bid:robinhood:`.
---
## All ONDO tokenized stocks (address, name, symbol, minted amount)
Lists every ONDO stock mint on Robinhood Chain: token name, symbol, contract address, and amount minted in that transfer.
▶️ [Run in IDE](https://ide.bitquery.io/All-tokenised-ONDO-stocks-on-Robinhood)
```graphql
{
EVM(network: robinhood, dataset: combined) {
Transfers(
where: {Transfer: {Sender: {is: "0x0000000000000000000000000000000000000000"}, Receiver: {is: "0xf2dc25b8a5231667d8cf0ecd476fb46805186572"}, Currency: {Symbol: {endsWith: "on"}}}}
orderBy: {descending: Block_Time}
) {
Block {
Time
}
Transaction {
Hash
}
Transfer {
Currency {
Name
Symbol
SmartContract
}
Amount
}
}
}
}
```
---
## Streaming Real time trades for Amazon ONDO stock
Subscribe on `Trading.Trades` to subscribe to the latest trades for Amazon ONDO tokenised stocks on Robinhood. This stream message includes info such as trade time, trader address, trade transaction hash, trade amount and price in both base and USD evaluation, along with currency and quote currency details. The token address for Amazon ONDO tokenised stock is `0x6c0b8c7071899bf9e7fc2d6d8cc2accd23ce6135`.
▶️ [Run in IDE](https://ide.bitquery.io/real-time-trades-for-amazon-ondo-stocks)
```graphql
subscription {
Trading {
Trades(
where: {
Pair: {
Token: {
Address: {is: "0x6c0b8c7071899bf9e7fc2d6d8cc2accd23ce6135"}
NetworkBid: { is: "bid:robinhood" }
}
}
}
) {
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Block {
Time
}
Price
PriceInUsd
Pair {
Market {
Address
}
Pool {
Address
}
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
Address
}
}
Side
Trader {
Address
}
Supply {
MarketCap
}
TransactionHeader{
Hash
}
}
}
}
```
To stream **one pool** instead of the blended token price, subscribe to `Trading.Pairs` and filter `Pool.Address` — same pattern as [Real-Time OHLCV for a pair](/docs/blockchain/robinhood/robinhood-trades/#real-time-ohlcv-stream-for-a-pair-on-robinhood).
## Token holders of Nvidia ONDO stock
Using `EVM.Holders`, we can get top holders for Nvidia ONDO stock, with wallets ranked by balance. `Amount` is the tokenized share count. Use `dataset: combined` and add `Balance: { Amount: { gt: "0" } }` for **current** holders. The token address for `Nvidia ONDO stock` is `0x6026fd22df0ba04c1c176e1beb79cda8748ff8d7`.
▶️ [Run in IDE](https://ide.bitquery.io/token-holders-of-Nvidia-ONDO-stock)
```graphql
{
EVM(dataset: combined, network: robinhood) {
Holders(
where: {
Currency: {
SmartContract: { is: "0x6026fd22df0ba04c1c176e1beb79cda8748ff8d7"}
}
Balance: { Amount: { gt: "0" } }
}
limit: { count: 20 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
FirstChangeTime
LastChangeTime
UpdateCount
}
Currency {
Name
Symbol
SmartContract
}
}
}
}
```
---
## OHLCV of Google ONDO stock
Using `Trading.Tokens`, we can get normalised OHLC candle values without the need of data normalisation from raw trades data. `Duration: { eq: 60 }` is 1-minute candles (`300` = 5 minutes, `3600` = 1 hour). For a **single pool**, use `Trading.Pairs` and add `Pool.Address`.
The token address for Google ONDO tokenised stock is `0x3381a810a40cea0b7f145e341aa53a296ed4093b`.
▶️ [Run in IDE](https://ide.bitquery.io/OHLCV-of-Google-ONDO-stocks)
```graphql
{
Trading {
Tokens(
where: {
Token: {
Address: { is: "0x3381a810a40cea0b7f145e341aa53a296ed4093b" }
NetworkBid: { is: "bid:robinhood" }
}
Interval: { Time: { Duration: { eq: 60 } } }
Price: { IsQuotedInUsd: true }
}
orderBy: { descending: Interval_Time_End }
) {
Token {
Name
Symbol
Address
}
Interval {
Time {
Start
Duration
End
}
}
Price {
IsQuotedInUsd
Ohlc {
Open
High
Low
Close
}
}
Volume {
Base
Quote
Usd
}
Block {
Time
}
}
}
}
```
---
## Latest price of Amazon ONDO stock
`Trading.Tokens` returns Bitquery's **volume-weighted price across pools**. `Interval.Time.Duration: 1` is the latest 1-second bar; `limit: 1` plus `orderBy: descending Interval_Time_End` is the current snapshot.
▶️ [Run in IDE](https://ide.bitquery.io/latest-price-of-Amazon-ONDO-stock)
```graphql
{
Trading {
Tokens(
where: {
Token: {
Address: { is: "0x6c0b8c7071899bf9e7fc2d6d8cc2accd23ce6135" }
NetworkBid: { is: "bid:robinhood" }
}
Interval: { Time: { Duration: { eq: 1 } } }
}
orderBy: { descending: Interval_Time_End }
limit: { count: 1 }
) {
Interval{
Time{
End
}
}
Token {
Name
Symbol
Address
}
latest_price: Price {
Ohlc {
Close
}
}
Supply {
MarketCap
FullyDilutedValuationUsd
}
}
}
}
```
---
## Pons Launchpad API on Robinhood Chain: Launches and Trades
URL: https://docs.bitquery.io/docs/blockchain/robinhood/pons-api/
Pons launchpad API on Robinhood Chain. Track Pons V2 launches, curve trades, graduations, the launch factory and locked liquidity with Bitquery GraphQL.
# Pons Launchpad API on Robinhood Chain: Launches and Trades
**[Pons](https://www.ponsfamily.com/launchpad)** (Pons Family) is a **token launchpad on Robinhood Chain**. Its **V2 launch factory** gives every token a real **bonding curve** that graduates into a **Uniswap v4 pool behind a Pons-owned hook** with **permanently locked liquidity**, and it lets a creator quote a launch in **native ETH, USDG, cbBTC, or a tokenized stock or ETF** such as TSLA, NVDA or SPY. This guide shows how to track **new Pons launches**, **bonding-curve trades**, **snipe tax**, **graduations**, the **liquidity lock**, and **post-graduation prices and liquidity** with Bitquery GraphQL APIs, using the `EVM(network: robinhood)` and `Trading` cubes.
Pons publishes protocol and integration docs at [docs.ponsfamily.com](https://docs.ponsfamily.com/docs/v2) and states that there is no Pons API: integrators are told to index the factory and the curves themselves. That is what this page does through Bitquery, so nothing here depends on Pons infrastructure. Every query runs as written in the [Bitquery IDE](https://ide.bitquery.io). Live data and the last month of `Trading` cube history are on every paid plan; history back to the first V2 launch sits on the `archive` dataset, which paid plans add through the Robinhood archive add-on and the trial does not include (see [Historical Pons data](#historical-data)).
## Video Tutorial | Pons Launchpad API on Robinhood Chain - Track Launches, Trades & Graduations
## Pons contract addresses at a glance {#pons-contract-addresses-quick}
Every Pons V2 contract, in one place. Full event lists, the quote-asset table and
the caveats are in [Pons contract addresses](#contract-addresses) further down.
| Contract | Address |
| --- | --- |
| Pons V2 launch factory (`PonsV2LaunchFactory`) | `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` |
| Pons V2 launch locker (`PonsV2LaunchLocker`) | `0x267444d099b10fb5ed7c3cc7b7c767adca574952` |
| Pons V2 meme hook (`PonsV2MemeHook`) | `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` |
| Pons V2 launch router (`PonsV2LaunchAndBuy`) | `0xe33e9e479df8802cb0866d5d05258bec4cf62948` |
| Pons V2 graduation executor | `0xc7819b64a1daecd7ec19856d026cb14efbd89046` |
| Pons V2 launch deployer | `0x3711cea4feade896c913c68f01eda97cb06d1a42` |
| Pons V2 fee escrow | `0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e` |
| Pons V2 buyback vault | `0x42df2a798f82289e177311362e8f5ccc45c1219c` |
| Pons V2 graduation guard | `0xf5695117b99b6f6401e67d4195bd653628176c6c` |
| Pons V1 factory (superseded, no longer launching) | `0xa5aab3f0c6eeadf30ef1d3eb997108e976351feb` |
| Uniswap v4 PoolManager (chain-wide, **not** Pons-only) | `0x8366a39cc670b4001a1121b8f6a443a643e40951` |
Each launched token also gets **its own bonding-curve contract**, so there is no
single curve address — curve trades are matched by event signature instead. The
address that receives the launch mint is that token's curve; see
[Newly launched tokens](#newly-launched-tokens).
:::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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches)
- [Pools.trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api)
- [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api)
- [Robinhood Calls API](/docs/blockchain/robinhood/robinhood-calls-api)
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api)
- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## How a Pons V2 launch works
Every launch mints a **fixed 1,000,000,000 supply** straight into its own **bonding curve contract**. Traders buy and sell against that curve — not against any DEX — until the curve has taken in its **graduation threshold** of the quote asset. At that point the curve is **swept**, and the proceeds seed a **Uniswap v4 pool** whose liquidity position is **permanently locked**.
| Property | Value |
| --- | --- |
| Network | Robinhood Chain (`network: robinhood`, chain ID **4663**) |
| Launch supply | `1000000000` (1 billion, decimal-normalized), 18 decimals |
| Pre-graduation venue | **Pons bonding curve**, one contract per token |
| Post-graduation venue | **Uniswap v4** (`Protocol: uniswap_v4`) |
| Graduation threshold | **4.2 ETH** for native-quoted launches; a per-asset amount for ERC-20 quotes — read it from `graduationThreshold` in `TokenLaunched`, set per asset by `PairTokenEconomicsUpdated` |
| Curve trade fee | **100 bps** (1%) of the quote side, set by the launch config rather than a protocol constant |
| Creator tax | set per launch, capped by the factory (`maxCreatorTaxBps`) |
| Launch fee | **0.0005 ETH** |
| Graduated pool `fee` | `0` — **all fees are taken by the hook**, not by the pool |
| Graduated pool `tickSpacing` | `200` |
| Graduated pool `hooks` | `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` (**PonsV2MemeHook**) |
### The supply split
The curve's shape fixes exactly how much supply reaches the pool, and it is the same for every launch regardless of quote asset:
| Slice | Share of supply | Where it ends up |
| --- | --- | --- |
| Sold on the curve | **5/7** (≈714,285,714) | Buyers |
| Swept at graduation | **2/7** (≈285,714,286) | Split below |
| ↳ seeds the v4 pool | **10/49** (≈204,081,633) | Locked full-range position |
| ↳ permanently locked | **4/49** (≈81,632,653) | `PonsV2LaunchLocker` |
### How Pons differs from pools.trade {#pons-vs-poolstrade}
Pons and [pools.trade](/docs/blockchain/robinhood/pools-trade-api) are structurally opposite, and queries do not transfer between them:
| | Pons V2 | pools.trade |
| --- | --- | --- |
| Pre-graduation venue | Real bonding-curve contract | Uniswap v4 pool from block one |
| Graduation event | **Yes** — `LaunchSwept` + `PoolGraduated` | None |
| Pool `hooks` | PonsV2MemeHook | `0x000…000` |
| Pool `fee` / `tickSpacing` | `0` / `200` | `2500` / `25` or `60` |
| Quote assets | ETH, USDG, cbBTC, tokenized stocks and ETFs | Mostly native ETH |
| Curve trades in trade cubes | **Yes**, as `pons_v2` (`Trading`, rolling ~30-day window; EVM `DEXTrades` from 2026-08-14) | N/A — all trades are pool trades |
:::caution Pons V1 is a different protocol with different event signatures
`PonsLaunchFactory` at `0xa5aab3f0c6eeadf30ef1d3eb997108e976351feb` is the **V1** launchpad. It has **no bonding curve** — each token gets a Uniswap V3 pool at launch — and its events carry **different signatures and different topic0 values** from V2:
```text
db51ea9ad51ab453a65a4cb7e60c3cb378c9501bb002609f8f97778fb6c4235a TokenLaunched(address,address,address,address,address,uint256,uint256,uint256,uint256,uint256)
1461370115e1c2be79cb529f8cfcbd11316e789d9c6099fc83417b0b4c48c62a TokenDeployed(address,address,address,address,uint256,uint256)
```
Every query on this page targets **V2 only**. A "Pons launches" feed built from V2 alone will not include V1 launches — add the V1 factory address and its topic0s if you need both.
V1 has stopped producing launches — its factory now emits only ownership-admin events. Treat it as history — query `EVM(network: robinhood, dataset: archive)` for logs from `0xa5aab3f0c6eeadf30ef1d3eb997108e976351feb` when you need V1 launches, and re-check the realtime dataset before assuming it is dead for good. V1 pools are created by Robinhood Chain's **chain-wide Uniswap V3 pool factory**, which serves every V3 protocol on the network — a `PoolCreated` event from it is **not** on its own a Pons signal.
:::
---
## Datasets {#datasets}
:::danger Omitting `dataset` gives you realtime — a rolling window, not history
`EVM(network: robinhood)` with no `dataset` argument queries the **realtime** dataset, which holds only a rolling window of recent blocks. This is the single most common reason a Pons query "works" but returns nothing older than a few days, and nothing in the response says which dataset served it.
If you want history, say so explicitly:
| Dataset | What it covers | When to use it |
| --- | --- | --- |
| *(omitted)* → `realtime` | Rolling recent window | Live streams, dashboards of the last few hours |
| `dataset: archive` | Full history from the chain's indexing start | Backfills, per-day counts, anything dated |
| `dataset: combined` | Archive merged with the realtime tail | A continuous view from launch day to now; slower |
```graphql
EVM(network: robinhood, dataset: archive) { ... }
EVM(network: robinhood, dataset: combined) { ... }
```
See [Dataset options](/docs/graphql/dataset/options), [archive](/docs/graphql/dataset/archive), [realtime](/docs/graphql/dataset/realtime), [combined](/docs/graphql/dataset/combined), and [data coverage and retention](/docs/graphql/data-coverage-retention).
:::
**Every query on this page runs on `archive` and `combined`** — Pons V2 history reaches back to the first V2 launch — with one exception, verified:
| Construct | realtime | archive | combined |
| --- | --- | --- | --- |
| `Topics: {includes: […]}` filter (incl. topic0) | ✅ | ✅ | ✅ |
| `Call.Input` / `Call.Output`, incl. `Input: {startsWith: […]}` | ✅ | ✅ | ✅ |
| `LogHeader.Address` / `LogHeader.Data`, `Log.Signature.Name` | ✅ | ✅ | ✅ |
| `Transfers`, `Holders`, `DEXTrades` | ✅ | ✅ | ✅ |
| `Log.Signature.SignatureHash` / `Call.Signature.SignatureHash`, filtered or selected | ✅ | ✅ | ✅ |
| **`DEXPoolEvents`, `DEXPoolSlippages`, `TransactionBalances`** | ✅ | ❌ | ❌ |
The `Trading` cube is a separate root that takes no `dataset` argument; it holds a rolling window of roughly the last 30 days, so the `pons_v2` rows it serves are always the most recent month, not a fixed history.
:::note `SignatureHash` works on every dataset
`Log.Signature.SignatureHash` and `Call.Signature.SignatureHash` work on `realtime`, `archive` and `combined`, both as a filter and in the selection set, and a `SignatureHash` filter matches the same rows as a topic0 `Topics` filter. The queries on this page use `Topics: {includes: [{Hash: {is: ""}}]}` because it is the same filter on every dataset **and** it is the only way to match an indexed argument of an undecoded event — `Signature: {SignatureHash: …}` is an equally valid choice for topic0 alone.
:::
---
## Historical Pons data and the archive add-on {#historical-data}
Three windows apply to Pons data, and your plan decides which you can reach.
- **Realtime** (`EVM(network: robinhood)` with no `dataset` argument): a rolling window of recent blocks. Every plan.
- **`Trading` cube**: roughly the last 30 days of curve and pool trades with USD prices. Every plan.
- **`archive` and `combined`**: every launch, curve trade, graduation and lock back to the first Pons V2 launch. The free trial and paid self-service plans are real-time only, and history is a per-chain add-on, listed as the Robinhood archive on the [pricing page](https://bitquery.io/pricing) and switched on from your [account](https://account.bitquery.io/). It unlocks `DEXTrades`, `DEXTradeByTokens`, `Calls` and `Events` on Robinhood Chain, which is everything on this page except the realtime-only pool cubes; a second add-on covers historical `Transfers`, `Balances` and `Holders`.
If `dataset: archive` fails or returns nothing on a paid plan, check the add-on first. How plans and add-ons are billed is on [how billing works](/docs/plans/how-billing-works/).
---
## Pons contract addresses: launch factory, router, hook, locker {#contract-addresses}
Pons V2 runs from a fixed set of contracts. The launch factory `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` emits every `TokenLaunched`, `LaunchSwept`, and `PoolGraduated`; the launch router `0xe33e9e479df8802cb0866d5d05258bec4cf62948` wraps launch-and-first-buy into one transaction; and the meme hook `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` sits on every graduated Uniswap v4 pool and is the field that tells a Pons pool apart from any other v4 pool on the network. Each launched token also gets **its own bonding-curve contract**, so curve trades are matched by event signature rather than by a single address.
| Role | Address | Notes |
| --- | --- | --- |
| **Launch factory** (`PonsV2LaunchFactory`) | `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` | Emits `TokenLaunched`, `LaunchSwept`, `PoolGraduated` |
| **Launch router** (`PonsV2LaunchAndBuy`) | `0xe33e9e479df8802cb0866d5d05258bec4cf62948` | `launchAndBuy()` — creates the token and executes the creator's first buy in one transaction |
| **Meme hook** (`PonsV2MemeHook`) | `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` | The v4 hook on every graduated pool; emits `PoolRegistered` and `HookFeeCollected` |
| **Launch locker** (`PonsV2LaunchLocker`) | `0x267444d099b10fb5ed7c3cc7b7c767adca574952` | Holds the locked position NFT and the locked supply |
| **Graduation executor** | `0xc7819b64a1daecd7ec19856d026cb14efbd89046` | Emits `GraduationDustSwept` |
| **Launch deployer** | `0x3711cea4feade896c913c68f01eda97cb06d1a42` | Listed in the Pons V2 docs contracts table |
| **Fee escrow** | `0xd3afeb2a57f70ef218aa82451c51b2fb0416ac9e` | Listed in the Pons V2 docs contracts table |
| **Buyback vault** | `0x42df2a798f82289e177311362e8f5ccc45c1219c` | Emits `Locked` |
| **Graduation guard** | `0xf5695117b99b6f6401e67d4195bd653628176c6c` | Listed in the Pons V2 docs contracts table |
| **Bonding curve** | one per token | Address is the **receiver of the launch mint** — see [Newly launched tokens](#newly-launched-tokens) |
| **Uniswap v4 PoolManager** | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Shared chain singleton — **not** Pons-only |
| **Pons V1 factory** | `0xa5aab3f0c6eeadf30ef1d3eb997108e976351feb` | Separate protocol, no longer launching — see the caution above |
:::caution The v4 PoolManager is not a Pons filter
`0x8366a39c…` is the **Uniswap v4 singleton** for all of Robinhood Chain. Every v4 trade on the network routes through it, [pools.trade](/docs/blockchain/robinhood/pools-trade-api) included. What isolates a **graduated Pons pool** is the `hooks` field being `0xe5e70264…` — see [The graduated Uniswap v4 pool](#the-graduated-uniswap-v4-pool).
:::
### Quote (pair) assets
Native ETH is the default quote asset, but the factory also approves **USDG, cbBTC, and a growing set of tokenized stocks and ETFs**, each with its own graduation threshold denominated in that asset's own decimals. The set is **owner-mutable and grows in batches** — the factory emits `PairTokenApprovalUpdated` (approve or revoke) and `PairTokenEconomicsUpdated` (threshold and decimals) whenever it changes — so treat the table as a snapshot and use the query below it for the live list:
| Symbol | Address | Decimals |
| --- | --- | --- |
| ETH (native) | `0x0000000000000000000000000000000000000000` | 18 |
| USDG | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` | 6 |
| cbBTC | `0xcec185eb182c47d1ba1efc84e6959e18cd620be4` | 8 |
| AAPL | `0xaf3d76f1834a1d425780943c99ea8a608f8a93f9` | 18 |
| AMD | `0x86923f96303d656e4aa86d9d42d1e57ad2023fdc` | 18 |
| AMZN | `0x12f190a9f9d7d37a250758b26824b97ce941bf54` | 18 |
| BB | `0x48e39e56acdba37b09020c0b734a613c9a2f100a` | 18 |
| COIN | `0x6330d8c3178a418788df01a47479c0ce7ccf450b` | 18 |
| COST | `0x4ea005168d7f09a7a0ba9d1def21a479950e44c2` | 18 |
| CRCL | `0xdf0992e440dd0be65bd8439b609d6d4366bf1cb5` | 18 |
| DELL | `0x941ae714ec6d8130c7b75d67160ca08f1e7d11dd` | 18 |
| DJT | `0x1d11f0496982706c5e14a514d4e79f2e6bde4516` | 18 |
| GLD | `0xc9a981fee1f9dec688bb123ccdecc63d0debfc4e` | 18 |
| GME | `0x1b0e319c6a659f002271b69db8a7df2f911c153e` | 18 |
| GOOGL | `0x2e0847e8910a9732eb3fb1bb4b70a580adad4fe3` | 18 |
| HIMS | `0xccee82fe024c36fa15e1005ede3e9e4787e23d09` | 18 |
| LLY | `0x8005d266423c7ea827372c9c864491e5786600ea` | 18 |
| META | `0xc0d6457c16cc70d6790dd43521c899c87ce02f35` | 18 |
| MSFT | `0xe93237c50d904957cf27e7b1133b510c669c2e74` | 18 |
| MSTR | `0xec262a75e413fafd0df80480274532c79d42da09` | 18 |
| MU | `0xff080c8ce2e5feadaca0da81314ae59d232d4afd` | 18 |
| NVDA | `0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec` | 18 |
| PLTR | `0x894e1ec2d74ffe5aef8dc8a9e84686accb964f2a` | 18 |
| QQQ | `0xd5f3879160bc7c32ebb4dc785f8a4f505888de68` | 18 |
| RBLX | `0xf0c4bf4c582cb3836e98394b1d4e7b7281101be8` | 18 |
| RDDT | `0x05b37fb53a299a1b874a619e1c4c404d52c36f4c` | 18 |
| SKHY | `0x84cab63bc87912e71ad199ff14a0ba45de68fef8` | 18 |
| SNDK | `0xb90a19ff0af67f7779aff50a882a9cff42446400` | 18 |
| SPCX | `0x4a0e65a3eccec6dbe60ae065f2e7bb85fae35eea` | 18 |
| SPY | `0x117cc2133c37b721f49de2a7a74833232b3b4c0c` | 18 |
| TSLA | `0x322f0929c4625ed5bad873c95208d54e1c003b2d` | 18 |
| TSM | `0x58ffe4a942d3885baa22d7520691f611ef09e7aa` | 18 |
| TTWO | `0x5e81213613b6b86eab4c6c50d718d34359459786` | 18 |
| USO | `0xa30fa36db767ad9ed3f7a60fc79526fb4d56d344` | 18 |
| WYFI | `0x9e7abd3c9139d14e4c86dce0e455aab7a0c2fb3e` | 18 |
The quote asset of any launch is `pairToken`, the first word of the `TokenLaunched` payload (or the `pairToken` argument once decoded).
### Read the current approved quote assets
Both admin events are decoded, so the live set is one query on the factory. Keep the latest row per `pairToken`: an `approved: false` row revokes the asset, and `graduationThreshold` is in the asset's own `decimals`.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 200}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
Log: {Signature: {Name: {in: ["PairTokenApprovalUpdated", "PairTokenEconomicsUpdated"]}}}
}
) {
Block { Time }
Log { Signature { Name } }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Integer_Value_Arg { integer }
... on EVM_ABI_Boolean_Value_Arg { bool }
}
}
}
}
}
```
This query only sees changes made from 2026-08-14 onward: earlier approval rows predate event decoding, carry no `Signature.Name`, and are not matched by the name filter at all (see the [decoding caveat](#event-reference)). The table above already folds in that initial set, so union the two.
---
## Event reference
**Most Pons V2 events are now ABI-decoded.** The factory, the router, every bonding curve, and the locker's `PositionLocked` all come back with `Log.Signature.Name` populated and `Arguments` fully readable — **including the indexed arguments**, which decoding lifts out of the topics for you. Filter and read them by name:
```graphql
where: { Log: { Signature: { Name: {is: "CurveBuy"} } } }
```
Three contracts are still undecoded, and for those the topic0 + `LogHeader.Data` patterns later on this page remain the only route:
| Contract | Decoded? |
| --- | --- |
| Factory `0x7ed598bc…` | ✅ all events |
| Router `0xe33e9e47…` | ✅ `Launched` |
| Bonding curves (one per token) | ✅ all events (`CurveBuy`, `CurveSell`, `SnipeTaxCharged`, …) |
| Locker `0x267444d0…` | ⚠️ `PositionLocked` ✅, `TokenSupplyLocked` ❌ |
| **Meme hook `0xe5e70264…`** | ❌ `PoolRegistered`, `HookFeeCollected`, `PoolFeesSwept` |
| **Graduation executor `0xc7819b64…`** | ❌ `GraduationDustSwept` |
:::caution Decoded names only reach back to 2026-08-14 on `archive`
Decoding was applied from **2026-08-14** onward and older archive rows have not been reprocessed: on `archive`/`combined`, rows before that date carry an **empty `Signature.Name` and no `Arguments`**, so a `Signature: {Name: …}` filter silently drops all earlier history — on a window that straddles that date, the name filter on `TokenLaunched` returns fewer rows than the topic0 filter, and the gap is exactly the pre-2026-08-14 launches. For anything historical, keep filtering with `Topics: {includes: [{Hash: {is: ""}}]}` (which matches decoded and undecoded rows alike) and treat `Signature.Name` / `Arguments` as fields that may be empty on old rows. If Bitquery backfills the archive later, this caveat disappears — re-run the count comparison to check.
:::
### Factory events {#factory-events}
Emitter: `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e`
| Event | Indexed | topic0 (`SignatureHash`) |
| --- | --- | --- |
| `TokenLaunched(address,address,address,address,uint256,uint256)` | 3 | `8d4aad4953d0ca700d468f3753aa14432d1b35b43ec6409f051fb6aa43a89607` |
| `LaunchSwept(address,uint256,uint256)` | 1 | `cdb72f157fd3666758a6ce201387ffb52038c7562e4fff352828da1096c4b6b4` |
| `PoolGraduated(address,uint256,uint256,uint256)` | 1 | `0a44ef75df69c534f43cd6c1aa3ef8983065fe5fe79ef9e79f6494e6f258c259` |
| `GraduationTokensPermanentlyLocked(address,uint256)` | 1 | `a0a18f5bf205becee8b268d7cf69addab8548ae8ef361791464cf0e0e17c1361` |
| `CreatorFeeRecipientUpdated(address,address,address)` | 3 | `308c390ed1ab5873392818e036cabdf408bc8ad042fbaead3108954ff75ba980` |
| `CreatorFeeRecipientChangeProposed(address,address,address,uint256,uint256)` | 3 | `7f119e44c84a715429bee60d30ad2e14afdef6c60bb1a7eaa01290ecf6d1b2e5` |
| `BuybackEnabledUpdated(address,bool,address)` | 2 | `bd886f85b7731f66269f57707414d435bf8df930d3357a10becc48a69377f6d5` |
| `LaunchForceSwept(address)` *(rare)* | 1 | `52c1a28345695afc7f6b7629133124dec5d61ee745affd65e4fd2a776bc05840` |
| `LaunchGraduationRescued(address,address,uint256,uint256)` *(rare)* | 2 | `7017304fdd491394686dce984eac721f0be1a22228346210f16694772bde44ca` |
### Bonding curve events {#curve-events}
Emitter: one contract per token — see [Newly launched tokens](#newly-launched-tokens).
| Event | Indexed | topic0 (`SignatureHash`) |
| --- | --- | --- |
| `CurveBuy(address,address,uint256,uint256,uint256,uint256)` | 2 | `ec36bf571f136799e8dc0b0b8bea4b04d8bd3d43de838aab0d5fc21d4cbfc455` |
| `CurveSell(address,address,uint256,uint256,uint256,uint256)` | 2 | `8113d738abdcb6b38357e9d53a54a7157861a09031b453651f0fe7fe151f59df` |
| `SnipeTaxCharged(address,uint256)` | 1 | `3bc39a5562b28f5fe8f36cecabfbaa12bb969acf05717994709225fc412a9934` |
| `SnipeTaxExempted(address)` | 1 | `e4b7e48fbd47c2f602bacadee76ad33b16542ddb4997cfc0de04c311adcfa8c7` |
| `FeesSwept(uint256,uint256,uint256)` | 0 | `9f4cd7c4ed99d08a797804560c9c5d71d2cf7e101f2e3b5e7d1ca8a24c370e4f` |
| `CurveBuyRefunded(address,uint256)` | 1 | `a69e8258ccc7b9bbb70ab953fc2d1062b4ee28b8ca827534097e1732e87b0262` |
| `CurveCompleted(address,uint256,uint256)` | 0 | `f8d37a90738ae063b8b8058b66f5880cf3cf7ab0c5d4fa78219696591dfbfb67` |
| `Initialized(address)` | 0 | `908408e307fc569b417f6cbec5d5a06f44a0a505ac0479b47d421a4b2fd6a1e6` |
| `BuybackLocked(uint256,uint256)` *(rare)* | 0 | `5feba9b0d52c92ada4b9c571c2bee52390c54f2947208ab250221e6ee32f12ff` |
| `AutoGraduationFailed(address,uint256)` *(rare)* | 1 | `e2cd2f31ebc05ec28640102987f4c8fc5f20e269e1b3aa82577f3f2f0e35c7c6` |
### Meme hook events {#hook-events}
Emitter: `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044`
| Event | Indexed | topic0 (`SignatureHash`) |
| --- | --- | --- |
| `PoolRegistered(bytes32,address,address,address)` | 1 | `01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573` |
| `HookFeeCollected(bytes32,address,uint256,uint256)` | 1 | `c532c43b3423e14ef72748f1c8291238829ca0af8ba9b67975ad1483485a4b4d` |
| `PoolFeesSwept(bytes32,uint256,uint256,uint256,uint256)` | 1 | `2f3c43579b9064b6f28edcf41608f3815792d274a56afe024359703cb4ea9b30` |
### Router, locker, vault, executor
| Event | Emitter | Indexed | topic0 (`SignatureHash`) |
| --- | --- | --- | --- |
| `Launched(address,address,address,address,uint256,uint256)` | router | 3 | `dcacba5e347ae7abd91cb519eb877af8fa7774e347b85dd3ddcd24a2ba8cdf37` |
| `TokenSupplyLocked(address,uint256)` | locker | 1 | `af33c4aba92959b3e7ddc83ab728938262da159a6c05ca836f6c46f9bcb2c740` |
| `PositionLocked(address,uint256)` | locker | 2 | `2cabb2a2973327d5863ceb4707e9441851243897e86d587ee35943599752eb54` |
| `Locked(address,address,uint256,uint256)` | buyback vault | 2 | `967ad762aa9070ada8db64577288e214771e89667066ae38e8750cb8a86c5429` |
| `GraduationDustSwept(address,address,uint256)` | executor | 2 | `80a5a2ff8b8c5533e5862e4e161bbcade9af6fd9d67bef56a590b062107f027f` |
Every topic0 above was verified two ways: keccak-256 preimage match against the signature from the verified contract source, and live occurrence on Robinhood Chain. Rows marked *(rare)* are admin or failure paths that exist in the ABI but fire infrequently.
### Querying a decoded event by name
For any decoded event, filter on `Log.Signature.Name` and read `Arguments` directly — no `LogHeader.Data` decoding, and the indexed addresses are right there:
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
Log: {Signature: {Name: {is: "TokenLaunched"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Block { Time Number }
Transaction { Hash From }
Log { Signature { Name } }
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Integer_Value_Arg { integer }
... on EVM_ABI_Bytes_Value_Arg { hex }
}
}
}
}
}
```
The 24-hour window keeps the scan small; without it the request can time out. Widen the window, or add `dataset: archive` for launch history.
Each row returns `token`, `curve`, `deployer`, `pairToken`, `launchConfigId` and `graduationThreshold` as named arguments — including the three indexed addresses that used to be locked away in the topics. `graduationThreshold` is a raw integer in the quote asset's own decimals: `4200000000000000000` is 4.2 ETH, `8090000000` is 8,090 USDG. This works on `realtime`, and on `archive`/`combined` for blocks from 2026-08-14 onward — see the [caution above](#event-reference).
### Querying a raw event by topic0
For the undecoded hook, executor, and locker `TokenSupplyLocked` events — and for **any** event on archive rows older than 2026-08-14 — match the topic0 with `Topics: {includes: […]}`, scope with `LogHeader.Address` where the emitter is a fixed contract, and read `LogHeader.Data`:
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
Topics: {includes: [{Hash: {is: "8d4aad4953d0ca700d468f3753aa14432d1b35b43ec6409f051fb6aa43a89607"}}]}
}
) {
Block { Time Number }
Transaction { Hash From To }
LogHeader { Data }
}
}
}
```
Topic0 values work with or without the `0x` prefix. `Log: {Signature: {SignatureHash: {is: "…"}}}` is an equivalent filter and, like `Topics`, works on every dataset — see [Datasets](#datasets).
:::caution Scope curve and hook events to an emitter where you can
Bonding curves are one contract per token, so a topic0-only filter on `CurveBuy` is the right scope — it captures every curve on the network at once, and `LogHeader.Address` tells you which one.
For fixed-emitter events, **always add `LogHeader.Address`**. A signature such as `PoolRegistered(bytes32,address,address,address)` is generic enough that unrelated contracts on the chain emit the same topic0 with a *different* indexing layout — same hash, incompatible payload. Filtering topic0 alone will mix them into your results.
:::
### Filtering by an indexed argument
On decoded events, indexed arguments are ordinary named arguments — filter them with `Arguments: {includes: …}`:
```graphql
Arguments: {includes: {
Name: {is: "token"}
Value: {Address: {is: "0x11ff6356504e85e792c385b3381f273a4b764cfe"}}
}}
```
On undecoded events (the hook and executor) and on pre-2026-08-14 archive rows, the `Topics` filter is the fallback: `Topics: {includes: [{Hash: {is: "…"}}]}` matches any topic in the log, including topic0 and any indexed address padded to 32 bytes:
```graphql
Topics: {includes: [{Hash: {is: "0x000000000000000000000000"}}]}
```
The `0x` prefix is optional here. `includes`, `excludes`, `startsWith`, `endsWith` and `length` are all available.
`Topics` is also a perfectly good topic0 filter on every dataset, which is why the queries on this page use it throughout; `Log.Signature.SignatureHash` works equally well. See [Datasets](#datasets).
### Full signatures for client-side decoding
```text
# factory — 0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e
8d4aad4953d0ca700d468f3753aa14432d1b35b43ec6409f051fb6aa43a89607 TokenLaunched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)
cdb72f157fd3666758a6ce201387ffb52038c7562e4fff352828da1096c4b6b4 LaunchSwept(address indexed token, uint256 quoteOut, uint256 tokenOut)
0a44ef75df69c534f43cd6c1aa3ef8983065fe5fe79ef9e79f6494e6f258c259 PoolGraduated(address indexed token, uint256 positionId, uint256 tokenAmount, uint256 pairTokenAmount)
a0a18f5bf205becee8b268d7cf69addab8548ae8ef361791464cf0e0e17c1361 GraduationTokensPermanentlyLocked(address indexed token, uint256 amount)
# bonding curve — one per token
ec36bf571f136799e8dc0b0b8bea4b04d8bd3d43de838aab0d5fc21d4cbfc455 CurveBuy(address indexed buyer, address indexed recipient, uint256 quoteIn, uint256 tokensOut, uint256 fee, uint256 tax)
8113d738abdcb6b38357e9d53a54a7157861a09031b453651f0fe7fe151f59df CurveSell(address indexed seller, address indexed recipient, uint256 tokensIn, uint256 quoteOut, uint256 fee, uint256 tax)
3bc39a5562b28f5fe8f36cecabfbaa12bb969acf05717994709225fc412a9934 SnipeTaxCharged(address indexed recipient, uint256 amount)
f8d37a90738ae063b8b8058b66f5880cf3cf7ab0c5d4fa78219696591dfbfb67 CurveCompleted(address recipient, uint256 quoteOut, uint256 tokenOut)
# meme hook — 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044
01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573 PoolRegistered(PoolId indexed poolId, address memecoin, address quoteToken, address creator)
c532c43b3423e14ef72748f1c8291238829ca0af8ba9b67975ad1483485a4b4d HookFeeCollected(PoolId indexed poolId, address currency, uint256 feeAmount, uint256 taxAmount)
# router — 0xe33e9e479df8802cb0866d5d05258bec4cf62948
dcacba5e347ae7abd91cb519eb877af8fa7774e347b85dd3ddcd24a2ba8cdf37 Launched(address indexed token, address indexed curve, address indexed deployer, address pairToken, uint256 launchConfigId, uint256 graduationThreshold)
```
---
## Newly launched tokens
The simplest launch feed is now the decoded `TokenLaunched` event itself — the [name-filtered query above](#querying-a-decoded-event-by-name) returns `token`, `curve`, `deployer`, `pairToken` and `graduationThreshold` as named arguments on every launch. Stream it as a subscription and you have a live launch tape with zero decoding.
The **`Calls` cube is still worth knowing**, for two reasons: it is the only on-chain source of the launch **metadata** (name, symbol, image, socials — see [Token metadata](#token-metadata)), and its archive reaches back further than decoded event names (Calls archive retention is planned to cap at roughly the last 3 months), whereas decoded event names only reach back to 2026-08-14. `Call.Output` holds the function's return data, and every Pons launch entry point returns the addresses you need:
| Selector (`Call.Input` prefix) | Function | `Call.Output` |
| --- | --- | --- |
| `f85f8e41` | `launchAndBuy(...)` on the router | `(address token, address curve, uint256 tokensOut)` |
| `f35abbcf` | `launchToken(params, launchConfigId, pairToken)` | `(address token, address curve)` |
| `a72101af` | `launchToken(params, launchConfigId, pairToken, snipeTaxExemptions)` | `(address token, address curve)` |
| `d6a0eef5` | `launchTokenFor(...)` — what the router calls internally | `(address token, address curve)` |
`Input: {startsWith: […]}` accepts a list, and the `0x` prefix on each selector is optional. `Call: {Signature: {SignatureHash: {is: "a72101af"}}}` is an equivalent single-selector filter and also runs on `archive`.
### The complete launch feed
```graphql
{
EVM(network: robinhood, dataset: combined) {
Calls(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
Call: {
To: {in: [
"0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
"0xe33e9e479df8802cb0866d5d05258bec4cf62948"
]}
Input: {startsWith: ["0xf35abbcf", "0xa72101af", "0xf85f8e41"]}
Success: true
}
}
) {
Block { Time Number }
Transaction { Hash From }
Call { To Value Input Output }
}
}
}
```
`Transaction.From` is the creator. `Call.Value` is the ETH attached (launch fee plus, on `launchAndBuy`, the creator's first buy). Take the first two 32-byte words of `Call.Output` for the token and the curve:
```js
const o = call.Output.replace(/^0x/, '');
const token = '0x' + o.slice(24, 64);
const curve = '0x' + o.slice(88, 128);
```
:::caution Bound this query, or it times out on realtime
The `Input: {startsWith: […]}` scan is the expensive part. Run unbounded against the default realtime dataset, this exact query hits the gateway timeout (`context deadline exceeded`) rather than returning slowly. Either keep `dataset: combined` (or `archive`) as above, which returns promptly and covers full history, or stay on realtime and add a time bound such as `Block: {Time: {since_relative: {hours_ago: 1}}}`. The subscription form below is unaffected — it only sees new blocks.
:::
:::caution Never match `launchTokenFor` and `launchAndBuy` together
`launchAndBuy` on the router calls `launchTokenFor` on the factory internally, so a filter matching both selectors returns **two rows for the same launch** — one for the router's outer call, one for the factory's inner call. Including `d6a0eef5` alongside `f85f8e41` double-counts every router launch; the three-selector filter above counts each launch once.
That is why `d6a0eef5` is absent from the query. Router launches are attributed to the router call, which is also where `Transaction.From` is the real creator. If you do need `launchTokenFor` — to catch a launch routed through some other contract — add it and deduplicate on `Transaction.Hash`.
:::
### Stream new launches in real time
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: {
Call: {
To: {in: [
"0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
"0xe33e9e479df8802cb0866d5d05258bec4cf62948"
]}
Input: {startsWith: ["0xf35abbcf", "0xa72101af", "0xf85f8e41"]}
Success: true
}
}
) {
Block { Time }
Transaction { Hash From }
Call { To Value Input Output }
}
}
}
```
### Token metadata: name, symbol, image, description, socials {#token-metadata}
Pons puts **all** launch metadata in the call arguments rather than in an event, so `Call.Input` is the only on-chain source for the description, the IPFS image and the social links. The struct is:
```solidity
struct LaunchParams {
string name;
string symbol;
string logo; // ipfs:// URI
string description;
Socials socials; // (twitter, telegram, discord, website, farcaster)
address creatorFeeRecipient;
uint16 creatorTaxBps;
bool buybackEnabled;
bytes32 expectedEconomics;
bytes32 salt;
}
```
ABI-decoding `Call.Input` from the launch feed above yields, for example:
```text
token 0x6a3b0c271d335450365297cdd10a24dc8364bf63
curve 0x9314af455ff11d02b5f87317fed8ddc9d6b17bb9
name TickerYard
symbol YARD
logo ipfs://bafkreifqznqij7bgl7glhavtsg44ra2lf2axifmoc6r7sgwacssmlkmdzm
description Route markets. Open verifiable protocol work.
twitter https://x.com/TickerYardHQ
creatorFeeRecipient 0x84adad3ed94495c978e834bcef1e5a7f533cf981
creatorTaxBps 100
```
For `launchAndBuy` the outer arguments after the struct are `launchConfigId`, `pairToken`, `quoteIn`, `minTokensOut`, `recipient` and `snipeTaxExemptions[]` — `quoteIn` is the size of the creator's own first buy, which is a useful signal on its own.
### Full history: the launch mint on `archive` {#launch-mint-archive}
The `Calls` feed above already runs on `combined`, and `archive` works the same way. But the **launch mint transfer** is a second, independent route to the same list, and it is often the more convenient one: it carries name, symbol and decimals directly from `Currency`, and the mint's `Receiver` **is the bonding curve**. Use it when you want token metadata without decoding calldata, or as a cross-check on the call feed.
```graphql
{
EVM(network: robinhood, dataset: archive) {
Transfers(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
Transfer: {
Sender: {is: "0x0000000000000000000000000000000000000000"}
Amount: {eq: "1000000000"}
}
Transaction: {To: {in: [
"0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
"0xe33e9e479df8802cb0866d5d05258bec4cf62948"
]}}
}
) {
Block { Time Number }
Transaction { Hash From To }
Transfer {
Amount
Receiver
Currency { Name Symbol Decimals SmartContract }
}
}
}
}
```
`Transfer.Currency.SmartContract` is the token, `Transfer.Receiver` is its curve, `Transaction.From` is the creator, and `Block.Time` is the launch time.
:::caution `Transaction.To` misses indirect launches
This pattern only catches launches where the factory or router is the transaction target. A small share of launches route through third-party contracts or arrive inside contract-creation transactions and carry a different `Transaction.To`. The [`Calls` feed](#the-complete-launch-feed) matches on `Call.To`, so it catches those too — and it runs on `archive` as well. Treat the call feed as the source of truth, and this one as the convenient metadata-carrying view.
:::
### Most active token creators
```graphql
{
EVM(network: robinhood, dataset: archive) {
Transfers(
limit: {count: 25}
orderBy: {descendingByField: "launches"}
where: {
Transfer: {
Sender: {is: "0x0000000000000000000000000000000000000000"}
Amount: {eq: "1000000000"}
}
Transaction: {To: {in: [
"0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
"0xe33e9e479df8802cb0866d5d05258bec4cf62948"
]}}
Block: {Time: {since_relative: {days_ago: 7}}}
}
) {
Transaction { From }
launches: count
}
}
}
```
---
## Bonding-curve trades
**Curve trades are now indexed as trades** under their own protocol label — `Protocol: "pons_v2"`, `ProtocolFamily: "Pons"` — and the best place to read them is the **`Trading` cube (Crypto Price API)**: one row per trade with `Side`, `Trader`, and **fully populated `PriceInUsd` / `AmountsInUsd`**, plus [OHLCV candles](#ohlcv-price-candles) that work from the token's very first curve trade. `Trading` coverage starts **2026-08-12** (the EVM `DEXTrades` / `DEXTradeByTokens` cubes start 2026-08-14); for anything earlier, the curve's `CurveBuy` / `CurveSell` events remain the only source.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Pair: {Market: {Protocol: {is: "pons_v2"} Network: {is: "Robinhood"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Block { Time }
Side
Price
PriceInUsd
Amounts { Base Quote }
AmountsInUsd { Base Quote }
Trader { Address }
TransactionHeader { Hash }
Pair {
Token { Address Symbol }
QuoteToken { Symbol }
}
}
}
}
```
The 24-hour window keeps the request inside the cube's limits; without it the request can time out. Widen it up to the cube's rolling month as needed.
Add `Pair: {Token: {Address: {is: ""}}}` to scope to one token — and because the same cube also carries the token's post-graduation `uniswap_v4` trades, dropping the protocol filter gives a token's **entire curve-to-pool trade history in one query**. On `pons_v2` rows `Pair.Pool.Address` is the token's **bonding-curve contract** (it matches `curve` in `TokenLaunched`), so every curve trade hands you the curve address for free. The same trades also appear in the EVM `DEXTrades` / `DEXTradeByTokens` cubes (`ProtocolFamily: "Pons"`, curve contract as `Trade.Dex.SmartContract`), but there `PriceInUSD` / `AmountInUSD` are populated only on the realtime dataset and read `0` on `archive` and `combined` — prefer `Trading`.
The event route below is still what you want for the **fee and tax parts** (`fee`, `tax`, snipe-tax attribution), which the trade cubes do not carry, and for curve trades older than the trade-cube coverage (the `Trading` cube's rolling ~30-day window, 2026-08-14 in the EVM `DEXTrades` cubes).
### Every trade on one token's curve
`CurveBuy` and `CurveSell` are decoded, so filter by name and read the arguments — buyer, seller and recipient included, which used to be unreadable indexed topics. Get the curve address from the [launch feed](#newly-launched-tokens), then filter on it as the emitter. The example curve `0x639a7cd2…` belongs to DECK (token `0x2861f208…`), which launched and graduated after 2026-08-14 so every row is decoded; `dataset: combined` keeps the query working once the curve's trades leave the realtime window:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x639a7cd26c373db065ad009c60abd623a1983c62"}}
Log: {Signature: {Name: {in: ["CurveBuy", "CurveSell"]}}}
}
) {
Block { Time }
Transaction { Hash From }
LogHeader { Address }
Log { Signature { Name } }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
Drop the `LogHeader.Address` filter to get **every curve trade on the network** in one feed — that is the shape you want for a launch-wide tape, and `LogHeader.Address` identifies the curve on each row.
### Reading the arguments
| Argument | `CurveBuy` | `CurveSell` |
| --- | --- | --- |
| `buyer` / `seller` | wallet that traded | wallet that traded |
| `recipient` | receiver of the tokens | receiver of the quote |
| `quoteIn` / `tokensIn` | quote asset spent | tokens sold |
| `tokensOut` / `quoteOut` | tokens received | quote asset received |
| `fee` | base fee **plus snipe tax** | base fee |
| `tax` | creator tax, paid to the creator in full | creator tax |
Price is `quoteIn / tokensOut` (or `quoteOut / tokensIn` on a sell). All amounts are raw integers in their asset's own decimals: 18 for the token, and the quote asset's own for the quote side (6 for USDG). The base fee rate comes from the launch's config (`curveFeeBps`) rather than a protocol constant, so derive it from the events rather than assuming 100 bps.
For pre-2026-08-14 archive rows, `Arguments` comes back empty — fall back to the topic0 filter (`ec36bf57…` / `8113d738…` from the [event reference](#curve-events)) and decode `LogHeader.Data` yourself; it carries the four non-indexed words in the order above:
```js
const w = i => BigInt('0x' + data.slice(i * 64, (i + 1) * 64));
const [quoteIn, tokensOut, fee, tax] = [w(0), w(1), w(2), w(3)];
```
### Snipe tax
Pons charges a punishing, fast-decaying tax on buys inside the launch window. The curve snapshots the factory's settings when it initializes, so a launch keeps the terms it launched under:
```text
snipeTaxBps(elapsed) = snipeTaxStartBps >> ((elapsed * 14) / snipeTaxSeconds)
```
with integer division, `elapsed` in seconds since the launch transaction, and zero once `elapsed >= snipeTaxSeconds`. At the factory's current settings — `snipeTaxStartBps = 9900`, `snipeTaxSeconds = 3` — that resolves to **9900 bps in the launch second, 618 bps in the next, 19 bps in the next, then zero**. Both settings are owner-mutable; read the current values with `snipeTaxStartBps()` (`0x50e25ac2`) and `snipeTaxSeconds()` (`0x6783774b`) through the `Calls` cube, taking `Call.Output`.
Because `CurveBuy.fee` bundles the base fee and the snipe tax, the snipe portion is what makes an early buy's effective rate jump far above the launch's base rate. `SnipeTaxCharged` isolates it:
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
Log: {Signature: {Name: {is: "SnipeTaxCharged"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Block { Time }
Transaction { Hash From }
LogHeader { Address }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
The 24-hour window keeps the scan small; without it the request can time out. Widen it, or add `dataset: archive` for history.
`recipient` and `amount` come back as named arguments, `LogHeader.Address` is the curve, and `Transaction.From` is the wallet that paid it — which is to say, **the sniper**. Creators can pre-declare exempt wallets at launch; those emit `SnipeTaxExempted` in the launch transaction, so the exemption list for a launch is recoverable from its own transaction hash.
### Graduation progress
There is no on-chain progress event. Sum the net quote taken in by the curve — `CurveBuy.quoteIn` minus `CurveSell.quoteOut` — and compare it against the launch's `graduationThreshold` (the third word of its `TokenLaunched` payload; **4.2 ETH** for native-quoted launches). The curve's live quote balance is the same figure, so a balance read against the curve address works as a cross-check.
---
## Token lifecycle in one query
Factory events are decoded and they all name the token in a `token` argument, so one `Arguments` filter returns a per-token timeline with each event's name attached. Use `dataset: combined` so the launch is still in range after it leaves the realtime window:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {ascending: Block_Time}
where: {
LogHeader: {Address: {is: "0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e"}}
Arguments: {includes: {
Name: {is: "token"}
Value: {Address: {is: "0x2861f208e71ced7beab010457bf10f0c1ccc0e2d"}}
}}
}
) {
Block { Time Number }
Transaction { Hash From To }
Log { Signature { Name } }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
The `Arguments` filter only matches rows that were decoded, so **a token launched before 2026-08-14 returns zero rows here** even though its events exist. For those, the topic-padding form still earns its keep — pad the token address to 32 bytes and filter it as a topic (indexed args live in the topics whether decoded or not):
```graphql
Topics: {includes: [{Hash: {is: "0x0000000000000000000000002861f208e71ced7beab010457bf10f0c1ccc0e2d"}}]}
```
Add the event's topic0 as a second `includes` entry to narrow to one event type — multiple hashes are combined with **AND**. Either way you get the full arc:
```text
TokenLaunched → launch
LaunchSwept → threshold hit, curve drained
GraduationTokensPermanentlyLocked → 4/49 of supply locked forever
PoolGraduated → v4 pool created and seeded
```
:::caution This works on the factory, not on the curve
The trick only works where the token address is actually one of the log's topics. Factory events index the token, so they match. The **curve's** events do not — `CreatorFeeRecipientUpdated` indexes the two recipient addresses and `SnipeTaxExempted` indexes the exempted account, so filtering a curve address by the token topic returns **zero rows**. Query curve history by the curve's own address plus the event topic0 instead.
:::
---
## Graduation
Graduation is **permissionless and two-phase**. Anyone can trigger it once the threshold is crossed, and in practice keeper bots race for it, so `Transaction.To` on the sweep is usually a third-party contract rather than Pons itself:
1. **`graduate(address)`** (`0xff6d8d05`) — sweeps curve fees, halts trading, pulls the quote and remaining supply into the factory. Emits `CurveCompleted` on the curve and `LaunchSwept` on the factory.
2. **`createGraduatedPool(address)`** (`0x2f53ef2f`) — creates the v4 pool, mints and locks the full-range position, registers the hook. Emits `GraduationTokensPermanentlyLocked`, `PoolGraduated`, `Initialize` and `ModifyLiquidity` on the PoolManager, `PoolRegistered` on the hook, and `TokenSupplyLocked` + `PositionLocked` on the locker.
The two phases land in **separate transactions**, seconds to minutes apart. A token in between is `Swept` — drained but not yet tradeable anywhere.
### Enumerating graduated tokens
`PoolGraduated` is decoded, so `Log: {Signature: {Name: {is: "PoolGraduated"}}}` on the factory now returns the token, position id and seeded amounts as named arguments — the quickest graduation feed for recent blocks. Two reasons to still use the hook's **`PoolRegistered`** instead: it also carries `quoteToken` and `creator`, and it works across the full archive (the hook is undecoded, so it never depended on decode coverage in the first place):
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}
Topics: {includes: [{Hash: {is: "01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573"}}]}
}
) {
Block { Time Number }
Transaction { Hash }
LogHeader { Data }
}
}
}
```
```js
const d = log.Data;
const memecoin = '0x' + d.slice(24, 64);
const quoteToken = '0x' + d.slice(88, 128); // 0x000…000 for native ETH
const creator = '0x' + d.slice(152, 192);
```
This is the query to run first when you want a **token set** to feed into the `Trading` cube — see [Top graduated tokens](#top-graduated-pons-tokens-by-volume). Keep the `LogHeader.Address` filter on the hook; without it this topic0 also matches an unrelated contract on the chain.
### The graduated Uniswap v4 pool
The PoolManager's `Initialize` **is** decoded, so the `PoolKey` reads without manual decoding. Scope it by the **`hooks` argument** — the Pons hook is what makes a pool a Pons pool:
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Block: {Time: {since_relative: {hours_ago: 24}}}
Log: {Signature: {Name: {is: "Initialize"}}}
Arguments: {includes: {
Name: {is: "hooks"}
Value: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}
}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_Integer_Value_Arg { integer }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Bytes_Value_Arg { hex }
}
}
}
}
}
```
The 24-hour window keeps the scan small; without it the request can time out. Widen it, or add `dataset: archive` for history.
Returns `id` (the **PoolId** you need for [liquidity and slippage](#pool-liquidity-slippage-and-balance-changes)), `currency0`, `currency1`, `fee`, `tickSpacing`, `hooks`, `sqrtPriceX96` and `tick`. Every Pons pool comes back with `fee: 0`, `tickSpacing: 200` and `hooks: 0xe5e702641ea86f4ae6cc3cdaed2b886f976be044`.
### The Pons pool of one token
Anyone can initialize a Uniswap v4 pool for any token, and popular Pons tokens attract extra pools with `hooks: 0x000…000` and arbitrary `fee` / `tickSpacing`. To land on the **Pons** pool of a specific token, pass two `Arguments` conditions — the list form is combined with **AND**:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 1}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
Arguments: {includes: [
{Name: {is: "hooks"}, Value: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}},
{Name: {is: "currency1"}, Value: {Address: {is: "0x2861f208e71ced7beab010457bf10f0c1ccc0e2d"}}}
]}
}
) {
Block { Time }
Transaction { Hash To }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Bytes_Value_Arg { hex }
}
}
}
}
}
```
The launched token is `currency1` when the quote is native ETH (`currency0` is `0x000…000`); for an ERC-20 quote the two currencies sort by address, so check both slots.
:::note Filter on the hook, not on `Transaction.To`
Scoping this query with `Transaction: {To: {is: ""}}` looks equivalent and is not: graduation is [permissionless](#graduation), so a keeper contract can call `createGraduatedPool` and carry its own address in `Transaction.To`, and those graduations silently drop out of a `Transaction.To` filter. The hook is on every Pons pool regardless of who triggered it.
:::
:::note Why `fee` is zero
Trading fees on a graduated Pons pool are charged by the **hook**, not by the pool. The pool's own LP fee is `0`, and `HookFeeCollected` on `0xe5e70264…` is where the fee and the creator tax actually show up. Reading `fee` from the `PoolKey` and calling it the trading cost will understate it to zero.
:::
---
## Locked liquidity: verifying the Pons liquidity lock {#liquidity-lock}
A graduated Pons token has **two locks**, and both are visible on-chain:
| Lock | What is locked | Where | Event |
| --- | --- | --- | --- |
| Liquidity position | The full-range Uniswap v4 position seeded with 10/49 of supply plus the graduation quote | `PonsV2LaunchLocker` `0x267444d099b10fb5ed7c3cc7b7c767adca574952` holds the position NFT | `PositionLocked(address indexed owner, uint256 indexed tokenId)` on the locker — **decoded** |
| Supply | 4/49 of supply (≈81,632,653 tokens) | The same locker, as a plain token balance | `TokenSupplyLocked(address indexed token, uint256 amount)` on the locker — **undecoded**, topic0 `af33c4ab…`; `GraduationTokensPermanentlyLocked(token, amount)` on the factory is the decoded twin |
Bitquery sees the effect of the locks, not the contract code: the position NFT and the 4/49 balance sit in the locker and, across every graduated token, never leave it. If you need a code-level guarantee, verify the locker source on the explorer. To verify a specific token's lock on-chain, read `PositionLocked` by the `owner` argument — which is the **launched token address**, not a wallet — and check that `tokenId` matches `positionId` in the token's `PoolGraduated`:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 5}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x267444d099b10fb5ed7c3cc7b7c767adca574952"}}
Log: {Signature: {Name: {is: "PositionLocked"}}}
Arguments: {includes: {
Name: {is: "owner"}
Value: {Address: {is: "0x2861f208e71ced7beab010457bf10f0c1ccc0e2d"}}
}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
The supply lock is a balance, so the cheapest check is the locker's holding of the token — it should read 4/49 of 1,000,000,000:
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
limit: {count: 1}
where: {
Currency: {SmartContract: {is: "0x2861f208e71ced7beab010457bf10f0c1ccc0e2d"}}
Holder: {Address: {is: "0x267444d099b10fb5ed7c3cc7b7c767adca574952"}}
}
) {
Holder { Address }
Balance { Amount }
}
}
}
```
To stream every new lock as it happens, subscribe to `PositionLocked` on the locker without the `Arguments` filter — one row per graduation, `owner` is the token.
---
## Trading data in the Trading cube (Crypto Price API)
The `Trading` cube covers a Pons token across both venues: curve trades carry `Protocol: "pons_v2"` (see [Bonding-curve trades](#bonding-curve-trades)), and once graduated the token is an ordinary Uniswap v4 market:
| Field | Value |
| --- | --- |
| `Pair.Market.ProtocolFamily` | `Uniswap` |
| `Pair.Market.Protocol` | `uniswap_v4` |
| `Pair.Market.Network` | `Robinhood` |
:::caution The `pons_v2` protocol label covers curve trades, not graduated pools
The `Trading` cube does have a Pons label — `Protocol: "pons_v2"` — but it marks **bonding-curve trades only**. Once a token graduates, its pool trades are plain `uniswap_v4`, which on Robinhood also covers pools created elsewhere, so **graduated Pons tokens cannot be isolated by protocol filter**. Scope by token address: harvest the set from `PoolRegistered`, then filter `Trading` by `Token.Address: {in: [...]}`. A protocol filter on `pons_v2` plus a token filter together give you a token's full curve + pool trade history in one cube.
On `uniswap_v4` rows `Pair.Pool.Address` is the v4 PoolManager singleton, not a per-pool address (on `pons_v2` rows it is the bonding curve). Use the `PoolId` from `Initialize` when you need to identify one pool.
:::
### Latest trades for a graduated token
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Pair: {
Token: {Address: {is: "0x95d3bc5d467d448ac83c5b33ff90f4dcfaf4c1e4"}}
Market: {Network: {is: "Robinhood"}}
}
}
) {
Block { Time }
Side
Price
PriceInUsd
Amounts { Base Quote }
AmountsInUsd { Base Quote }
Trader { Address }
TransactionHeader { Hash }
Pair {
Token { Address Symbol Name }
QuoteToken { Address Symbol }
Market { Protocol ProtocolFamily Network }
}
}
}
}
```
:::note Trades are not duplicated on Pons pools
Unlike [pools.trade](/docs/blockchain/robinhood/pools-trade-api#latest-trades-for-a-poolstrade-token), Pons v4 pools return **one row per swap step**. No dedup pass is needed before summing volume.
One user swap can still fan out into several routed steps across different quote pairs in the same transaction, so summing every step overstates end-user volume. Graduated tokens commonly trade against both ETH and USDG.
:::
### OHLCV price candles
Candles are built from every `Trading` row, so they start from the token's **first bonding-curve trade** — no need to wait for graduation, and the series runs continuously across the curve-to-pool transition:
```graphql
{
Trading {
Tokens(
limit: {count: 24}
orderBy: {descending: Block_Time}
where: {
Token: {Address: {is: "0x95d3bc5d467d448ac83c5b33ff90f4dcfaf4c1e4"} Network: {is: "Robinhood"}}
Interval: {Time: {Duration: {eq: 3600}}}
}
) {
Block { Time }
Token { Address Symbol Name }
Volume { Usd }
Price { Ohlc { Open High Low Close } }
}
}
}
```
Change `Duration` to `60`, `300`, `900` or `86400` for other candle sizes. Add `Supply { MarketCap CirculatingSupply }` for FDV.
### Top graduated Pons tokens by trade count {#top-graduated-pons-tokens-by-volume}
Pass a token set harvested from [`PoolRegistered`](#enumerating-graduated-tokens):
```graphql
{
Trading {
Tokens(
limit: {count: 25}
orderBy: {descendingByField: "trades"}
where: {
Token: {
Address: {in: [
"0x95d3bc5d467d448ac83c5b33ff90f4dcfaf4c1e4",
"0xddec0170ceb4426ea05f2fbd485dffa4fafa6615",
"0xd928a068d2b90798373a470c9d9ba562322acdef"
]}
Network: {is: "Robinhood"}
}
Interval: {Time: {Duration: {eq: 3600}}}
Block: {Time: {since_relative: {days_ago: 1}}}
}
) {
Token { Address Symbol Name }
vol: sum(of: Volume_Usd)
trades: count
}
}
}
```
:::note Keep per-interval metrics out of aggregations
Selecting a per-row metric such as `Supply { MarketCap }` alongside `sum(of: Volume_Usd)` adds it as a grouping key, so you get one row **per interval** instead of one row per token. Time windows go in `Block: {Time: …}` — `Interval.Time.Since` is not a valid field.
:::
---
## Pool liquidity, slippage, and balance changes
These three cubes are **realtime-only** on Robinhood — `archive` and `combined` both error on them, unlike the rest of this page (see [Datasets](#datasets)) — so use them for live monitoring and persist what you need. All three key off the **`PoolId`** from `Initialize`.
### Live pool liquidity (depth)
```graphql
{
EVM(network: robinhood) {
DEXPoolEvents(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
PoolEvent: {Pool: {PoolId: {is: "0xPOOL_ID"}}}
}
) {
Block { Time }
Log { Signature { Name } }
PoolEvent {
Dex { ProtocolName ProtocolVersion }
Pool { PoolId CurrencyA { Symbol } CurrencyB { Symbol } }
Liquidity { AmountCurrencyA AmountCurrencyAInUSD AmountCurrencyB AmountCurrencyBInUSD }
}
}
}
}
```
`DEXPoolEvents` holds only the recent window, so pick a pool that has traded within it: take the `id` argument of the `Initialize` event from [The graduated Uniswap v4 pool](#the-graduated-uniswap-v4-pool) and put it in `PoolId`.
`AmountCurrencyA` is the quote side (ETH in the example) and `AmountCurrencyB` the token side. The token side's USD value reads `0` for unpriced launch tokens, so value the pool from the quote side.
### Per-swap slippage
```graphql
{
EVM(network: robinhood) {
DEXPoolSlippages(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
Price: {Pool: {PoolId: {is: "0xPOOL_ID"}}}
}
) {
Block { Time }
Price {
Dex { ProtocolName }
Pool { PoolId CurrencyA { Symbol } CurrencyB { Symbol } }
AtoB { Price MaxAmountIn MinAmountOut }
SlippageBasisPoints
}
}
}
}
```
Same rule as above: `DEXPoolSlippages` is realtime-only, so use a pool with recent swaps.
Streamed with `SlippageBasisPoints: {gt: 100}`, this is a ready-made toxic-fill alert.
### Per-transaction balance changes
```graphql
{
EVM(network: robinhood) {
TransactionBalances(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
TokenBalance: {Currency: {SmartContract: {is: "0x95d3bc5d467d448ac83c5b33ff90f4dcfaf4c1e4"}}}
}
) {
Block { Time }
Transaction { Hash From }
TokenBalance {
Address
PreBalance
PostBalance
HasPreBalance
TotalSupply
Currency { Symbol }
}
}
}
}
```
:::note Check `HasPreBalance`
When `HasPreBalance` is `false`, `PreBalance` reads `0` meaning "unknown", not "zero". Treat the delta as reliable only when it is `true`. `TotalSupply` reads `1000000000` for every Pons launch, which is a cheap sanity check that you are looking at the right contract.
:::
---
## Holders and supply
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
limit: {count: 100}
orderBy: {descending: Balance_Amount}
where: {
Currency: {SmartContract: {is: "0x95d3bc5d467d448ac83c5b33ff90f4dcfaf4c1e4"}}
Balance: {Amount: {gt: "0"}}
Holder: {Address: {notIn: [
"0x8366a39cc670b4001a1121b8f6a443a643e40951",
"0x267444d099b10fb5ed7c3cc7b7c767adca574952",
"0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"
]}}
}
) {
Holder { Address }
Balance { Amount FirstChangeTime LastChangeTime UpdateCount }
}
}
}
```
:::caution Exclude three protocol addresses, not one
On a graduated Pons token the top holders are all protocol contracts:
- **`0x8366a39c…`** — the v4 PoolManager, which custodies the pool's liquidity
- **`0x267444d0…`** — `PonsV2LaunchLocker`, holding the permanently locked 4/49 of supply
- **`0xe5e70264…`** — the meme hook, holding accrued fees in the token
Leave them in and the protocol itself dominates every holder count, concentration ratio and top-wallet leaderboard. The `notIn` filter above removes all three.
For a token **still on its curve**, the curve contract holds all unsold supply and should be excluded the same way.
:::
For circulating supply and market cap, see [Robinhood Token Supply](/docs/blockchain/robinhood/robinhood-token-supply).
---
## Streaming
Every query on this page runs as a subscription — switch `query` to `subscription` and drop `limit`/`orderBy`. 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/).
The three feeds worth running continuously:
```graphql
# 1. Every new launch, with token + curve + full metadata
subscription {
EVM(network: robinhood) {
Calls(where: {Call: {
To: {in: ["0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e", "0xe33e9e479df8802cb0866d5d05258bec4cf62948"]}
Input: {startsWith: ["0xf35abbcf", "0xa72101af", "0xf85f8e41"]}
Success: true
}}) {
Block { Time }
Transaction { Hash From }
Call { To Value Input Output }
}
}
}
```
```graphql
# 2. Every bonding-curve trade on the network, fully decoded
subscription {
EVM(network: robinhood) {
Events(where: {Log: {Signature: {Name: {in: ["CurveBuy", "CurveSell"]}}}}) {
Block { Time }
Transaction { Hash From }
LogHeader { Address }
Log { Signature { Name } }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
```graphql
# 3. Every graduation, with the token address readable in the payload
subscription {
EVM(network: robinhood) {
Events(where: {
LogHeader: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}
Topics: {includes: [{Hash: {is: "01bf263a1db1652580721573296e1a1fa70b3d4c87f61d02a69c4e1109d2d573"}}]}
}) {
Block { Time }
Transaction { Hash }
LogHeader { Data }
}
}
}
```
---
---
## Next steps
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) — full trade schema for the network
- [Robinhood Calls API](/docs/blockchain/robinhood/robinhood-calls-api) — more on `Call.Input` / `Call.Output` and internal calls
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) — compare launchpads side by side
- [Pools.trade API](/docs/blockchain/robinhood/pools-trade-api) — the other major Robinhood Chain launchpad
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api) — holder distribution queries
- [WebSocket subscriptions](/docs/subscriptions/websockets/) — turn any query above into a live stream
---
## Pools.trade API — Uniswap Launchpad on Robinhood Chain
URL: https://docs.bitquery.io/docs/blockchain/robinhood/pools-trade-api/
Pools.trade API: track the Uniswap launchpad on Robinhood Chain with Bitquery GraphQL. Query new token launches, Crowd Launch auctions, trades, OHLCV, and holders.
# Pools.trade API — Uniswap Launchpad on Robinhood Chain
**[Pools.trade](https://pools.trade/)** is the token launchpad **built by Uniswap for Robinhood Chain**, opened to the public on **5 August 2026** — its contracts had been live since **8 July 2026**, and flagship tokens like **FRONG** were minted on 30 July through the earlier entry contract. The contracts self-describe as the *Uniswap LiquidityLauncher*. This guide shows how to track **new pools.trade token launches**, **Crowd Launch auctions**, **trades**, **OHLCV prices**, and **holders** with Bitquery GraphQL APIs, using the `EVM(network: robinhood)` and `Trading` cubes. Searching for a **Pools Trade API** (the spaced spelling of pools.trade) lands you in the right place — this page covers the full data API for the launchpad.
:::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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) — bonding-curve launchpad, graduations, Uniswap v4 pools
- [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api)
- [Bags.fm API on Robinhood](/docs/blockchain/robinhood/bags-fm-api)
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## How pools.trade differs from other launchpads
Most launchpads (Flap.sh, Bags.fm, pump.fun-style venues) run trades through a **custom bonding-curve contract**, then emit a **graduation event** when the token migrates to a real DEX pool.
**Pools.trade does not work that way.** Every launch gets a **real Uniswap v4 pool** at launch — usually created in the same transaction as the token mint, occasionally in an immediate follow-up transaction on the original entry path. There is no separate bonding-curve AMM and no migration step.
| Property | Value |
| --- | --- |
| Network | Robinhood Chain (`network: robinhood`, chain ID **4663**) |
| AMM | **Uniswap v4** (`Protocol: uniswap_v4`) |
| Pool quote currency | **Native ETH** (`currency0` = `0x000…000`) |
| Pool fee | `2500` (0.25%) |
| Tick spacing | `25` (current path) or `60` (original path) |
| Hooks | **None** (`hooks` = `0x000…000`) |
| Launch supply | `1000000000` (1 billion, decimal-normalized) |
The practical consequences for anyone building on this data:
- **Trades are queryable from block one** in the `Trading` cube — you do not have to wait for graduation.
- The "bonding curve" you see in the UI is **single-sided concentrated liquidity** in a plain v4 pool, not a separate contract.
- There is **no `Graduated` / `LaunchedToDEX` event** to subscribe to for curve launches. See [Graduation](#graduation).
### The two launch modes
| Mode | UI label | Mechanism | Graduation target |
| --- | --- | --- | --- |
| **Curve launch** | *(default)* | Token + v4 pool created instantly; price discovered by trading | **$50,000 FDV** |
| **Crowd Launch** | `Crowd Launch` | A **continuous clearing auction (CCA)** runs first in its own per-token contract, then the pool opens | ≈$5,000-equivalent raise (platform-reported); auctions routinely oversubscribe far past it |
Crowd Launches run in a **fixed ~4-hour window** and can be *oversubscribed*. Each auction gets its **own contract address**. See [Crowd Launch auctions](#crowd-launch-cca-auctions).
---
## Contract addresses
| Role | Address | Notes |
| --- | --- | --- |
| **Launch entry (current)** | `0x0000ffffbe8efe702c8703ae3477ff5de3d319c0` | Live since the 5 Aug public launch |
| **Launch entry (original)** | `0x00004c4ccc709ef590f7c81102c0689f0263d4e9` | Live since 8 Jul; minted FRONG, POOLS — **still active** |
| **Token factory** | `0x000000e200088d55c39a11f609e5f667729ad49b` | Name, symbol, description, image |
| **Launchpad (current path)** | `0x23f8209572b4a1c2ad88a42749e830791fb027f1` | `TokenLaunched` + v4 `PoolKey`; tickSpacing 25 |
| **Launchpad (current path, alt)** | `0xad44d55e7f8337c3ce113fbb591486e85be104b2` | Same ABI, lower volume; tickSpacing 25 |
| **Launchpad (original path)** | `0xce57498d3474dcc244dfb6710ffbe6d4441cd2b2` | Same ABI; tickSpacing 60 |
| **Launchpad (original path, alt)** | `0x60d73b21cdf2ea846ab3d58699bbbb8f29d72491` | Same ABI; tickSpacing 60 |
| **CCA auction factory** | `0x000000001f26a0044baa66024e7b6599c61963f8` | Emits `AuctionCreated` per Crowd Launch |
| **Liquidity initializer registry** | `0x05d552391067389ee44fec3924157ed33f976000` | Emits `InitializerCreated` |
| **Uniswap v4 PoolManager** | `0x8366a39cc670b4001a1121b8f6a443a643e40951` | Shared singleton — **not** pools.trade-only |
| **CCA auction** | one per Crowd Launch | e.g. `0xD10dc5f79F95E953e710F1eDeBddE0baD2e8fed8` |
| **USDG** | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` | Secondary quote token |
| **WETH** | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` | Secondary quote token |
:::caution There are TWO entry contracts — filter on both
pools.trade ran on `0x00004c4c…` from 8 July before `0x0000ffff…` took over at the public launch, **and the original contract still processes launches**. Both emit byte-identical events (`TokenCreated`, `TokenDistributed`), so every launch filter in this guide uses `in:` with both addresses. Filtering only the new one dropped ~40% of 5 August's launches (the split varies day to day) — and misses FRONG and POOLS, the two largest tokens on the platform.
:::
:::caution The v4 PoolManager is not a pools.trade filter
`0x8366a39c…` is the **Uniswap v4 singleton** for all of Robinhood Chain. Every v4 trade on the network routes through it, including pools launched elsewhere. Filtering on it will **not** isolate pools.trade activity — use the token set from `TokenCreated` instead (see [Top tokens](#top-poolstrade-tokens-by-volume)).
:::
---
## Event reference
**Every pools.trade event is decoded.** `Log.Signature.Name` is populated and `Arguments` returns named, typed values — including the entire Crowd Launch auction, which earlier versions of this page documented as raw. Filtering by topic0 (`SignatureHash`) still works and is still the better choice in one specific case, covered below.
| Event | Emitter | Decoded? | topic0 (`SignatureHash`) |
| --- | --- | --- | --- |
| `TokenCreated(address)` | entry | ✅ Yes | `2e2b3f61b70d2d131b2a807371103cc98d51adcaa5e9a8f9c32658ad8426e74e` |
| `Initialize` / `ModifyLiquidity` / `Swap` | v4 PoolManager | ✅ Yes | — |
| `TokenDistributed` | entry | ✅ Yes | `67226bacccef969dab310a9e55dc1cf821363658e433fd330344f5cc00c79ac8` |
| `TokenCreated` *(metadata overload)* | factory | ✅ Yes | `4ef8284ecf42d4cd19686572ffd87f630858c82398911e776cb831de35eddbf4` |
| `TokenLaunched` | launchpad | ✅ Yes | `3b3d2bafdcae274a232217e1f80ee4305d3af6aa25c8b14b1681bd68d18042a4` |
| `DistributionInitialized` | launchpad | ✅ Yes | `0afd26d7f0833a451173acef122d058906aa7708ceb6f67ea7471a649d88b44b` |
| `BidSubmitted` | CCA auction | ✅ Yes | `650baad5cd8ca09b8f580be220fa04ce2ba905a041f764b6a3fe2c848eb70540` |
| `ClearingPriceUpdated` | CCA auction | ✅ Yes | `30adbe996d7a69a21fdebcc1f8a46270bf6c22d505a7d872c1ab4767aa707609` |
| `CheckpointUpdated` | CCA auction | ✅ Yes | `f1e4b6d7d0d7c5deb6393a39862d66a2f2ecb034f3283a8a597f9bf0c36f76fa` |
| `TickInitialized` | CCA auction | ✅ Yes | `7fdd20e2dbf90ff60a7d9be5ad62f1ec6d9d9cba8b36174a3839cafd059f0958` |
| `NextActiveTickUpdated` | CCA auction | ✅ Yes | `b9a86892440ed5515518351623ecfc523d283b21e92f1505e533ef26137be5b0` |
| `AuctionStepRecorded` | CCA auction | ✅ Yes | `6863f2b489f9186bf89231dc73aa0e9836f536b9ddb0f708f74260ed3160f297` |
| `TokensReceived` | CCA auction | ✅ Yes | `468160b6769cb8abc9324bc14fe70ee0ce87f1e92087186c6ae22a964a04c572` |
| `AuctionCreated` | CCA auction factory | ✅ Yes | `7ede475fad18ccf0039f2b956c4d43a8b4ed0853de4daaa8ae25299f331ae3b9` |
| `InitializerCreated` | initializer registry | ✅ Yes | `6d759545eb439f07e70f45431d6339af7a4f1ffef06d43e8ddf47fdb0799708c` |
Every event above returns decoded `Arguments` from the API, and every topic0 matches its signature by keccak-256 preimage.
### Reading decoded arguments
Two things about the `Arguments` shape are easy to trip over.
**Tuple components are flattened, and they all share the tuple's type name.** A struct argument does not arrive as one nested value — it arrives as one row per component, each carrying the *tuple's* name rather than the field's name, distinguished only by `Index`. For the factory's `TokenCreated(address,(string,string,string,bytes))`:
| `Name` | `Index` | `Type` | Meaning |
| --- | --- | --- | --- |
| `tokenAddress` | 0 | `address` | the new token |
| `UERC20Metadata` | 0 | `string` | description |
| `UERC20Metadata` | 1 | `string` | external / social URL (often empty) |
| `UERC20Metadata` | 2 | `string` | image URI — `ipfs://…` or `https://…` |
| `UERC20Metadata` | 3 | `bytes` | extra payload (usually empty) |
`TokenLaunched` behaves the same way: `poolId`, `token` and `finalPositionRecipient` are named normally, then five `PoolKey` rows follow — index 0 `currency0`, 1 `currency1`, 2 `fee`, 3 `tickSpacing`, 4 `hooks`. `InitializerCreated` flattens its nested struct into eleven `MigratorParameters` rows.
**`TokenCreated` is emitted by two different contracts with two different signatures.** The entry contract emits `TokenCreated(address)` and the factory emits the metadata overload `TokenCreated(address,(string,string,string,bytes))`. Filtering on `Name: {is: "TokenCreated"}` alone matches **both**. Disambiguate with `LogHeader.Address`, or filter by the topic0, which is unique per signature.
### Filtering by topic0
Topic0 filtering remains available and is the precise way to pin one exact signature — useful for the overloaded `TokenCreated` above. Supply the hash **without** a `0x` prefix; see the dataset note below for its one limitation.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
Log: {
Signature: {
SignatureHash: {is: "67226bacccef969dab310a9e55dc1cf821363658e433fd330344f5cc00c79ac8"}
}
}
LogHeader: {Address: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
}
) {
Block { Time Number }
Transaction { Hash From }
LogHeader { Address Data }
Log { Signature { SignatureHash } }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-raw-event-by-topic0)
Two things to know when reading the result:
- **You no longer need `LogHeader.Data` for this event.** `TokenDistributed` now decodes to `tokenAddress`, `strategy` and `amount`, so read `Arguments` instead of hand-parsing the payload. `Data` is still returned if you want the raw bytes.
- **Drop the `LogHeader.Address` filter for per-token contracts.** CCA auction events fire from a fresh contract per Crowd Launch (1,200+ live already), so filtering on the event alone is the right scope — it captures every auction at once, and `LogHeader.Address` tells you which auction each row came from.
### Full signatures
Now that every event is decoded you rarely need these, but the full signatures are the quickest way to see each event's argument types and tuple layout, grouped by emitter address.
```text
# entry contracts — 0x0000ffffbe8efe702c8703ae3477ff5de3d319c0 (current)
# 0x00004c4ccc709ef590f7c81102c0689f0263d4e9 (original, still active)
# both emit identical signatures
67226bacccef969dab310a9e55dc1cf821363658e433fd330344f5cc00c79ac8 TokenDistributed(address,address,uint256)
# factory — 0x000000e200088d55c39a11f609e5f667729ad49b
4ef8284ecf42d4cd19686572ffd87f630858c82398911e776cb831de35eddbf4 TokenCreated(address,(string,string,string,bytes))
# launchpads — current path 0x23f82095…27f1 / 0xad44d55e…04b2 (tickSpacing 25)
# original path 0xce57498d…d2b2 / 0x60d73b21…2491 (tickSpacing 60)
3b3d2bafdcae274a232217e1f80ee4305d3af6aa25c8b14b1681bd68d18042a4 TokenLaunched(bytes32,address,address,(address,address,uint24,int24,address))
0afd26d7f0833a451173acef122d058906aa7708ceb6f67ea7471a649d88b44b DistributionInitialized(address,address,uint256)
# CCA auction factory — 0x000000001f26a0044baa66024e7b6599c61963f8
7ede475fad18ccf0039f2b956c4d43a8b4ed0853de4daaa8ae25299f331ae3b9 AuctionCreated(address,address,uint256,bytes)
# liquidity initializer registry — 0x05d552391067389ee44fec3924157ed33f976000
6d759545eb439f07e70f45431d6339af7a4f1ffef06d43e8ddf47fdb0799708c InitializerCreated(address,(address,address,uint64,uint128,address,address,(uint24,int24,address),bytes,bytes))
# CCA auction — one contract per Crowd Launch
650baad5cd8ca09b8f580be220fa04ce2ba905a041f764b6a3fe2c848eb70540 BidSubmitted(uint256,address,uint256,uint128)
30adbe996d7a69a21fdebcc1f8a46270bf6c22d505a7d872c1ab4767aa707609 ClearingPriceUpdated(uint256,uint256)
f1e4b6d7d0d7c5deb6393a39862d66a2f2ecb034f3283a8a597f9bf0c36f76fa CheckpointUpdated(uint256,uint256,uint24)
7fdd20e2dbf90ff60a7d9be5ad62f1ec6d9d9cba8b36174a3839cafd059f0958 TickInitialized(uint256)
b9a86892440ed5515518351623ecfc523d283b21e92f1505e533ef26137be5b0 NextActiveTickUpdated(uint256)
6863f2b489f9186bf89231dc73aa0e9836f536b9ddb0f708f74260ed3160f297 AuctionStepRecorded(uint256,uint256,uint24)
468160b6769cb8abc9324bc14fe70ee0ce87f1e92087186c6ae22a964a04c572 TokensReceived(uint128)
```
:::note `SignatureHash` filters need the realtime dataset
Filtering by `Log: {Signature: {SignatureHash: …}}` is served **only** by the realtime dataset. `dataset: archive` returns `no archive or API tables found for cube Event`, and `dataset: combined` returns `no data available yet to query dataset combined`. Decoding the ABIs did not change this.
Filter by `Log.Signature.Name` instead when you need `archive` or `combined`; that path works on all three datasets. Be aware that **archive coverage of these events is still thin**: some events that are plentiful on realtime return little or nothing on archive. Treat realtime as the source of truth for launchpad and auction history until archive backfills.
Note also that `SignatureHash` values are supplied **without** a `0x` prefix.
:::
---
## Newly launched tokens
### Latest pools.trade launches
The decoded `TokenCreated` event on the two entry contracts is the cleanest launch feed — one row per launch.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
Log: {Signature: {Name: {is: "TokenCreated"}}}
}
) {
Block { Time Number }
Transaction { Hash From }
LogHeader { Address }
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Latest-launches)
The single argument `token` is the new token's contract address. `Transaction.From` is the creator wallet, and `LogHeader.Address` tells you which entry contract handled the launch.
:::note This event is intentionally thin
`TokenCreated(address)` carries **only** the token address — no name, symbol, or image. Those live in the factory's separate `TokenCreated` overload; see [Token metadata](#token-metadata-name-symbol-description-image).
:::
### Stream new launches in real time
Launches arrive continuously through both entry contracts, thousands per day at peak. Polling will always lag; subscribe instead.
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: {Address: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
Log: {Signature: {Name: {is: "TokenCreated"}}}
}
) {
Block { Time }
Transaction { Hash From }
LogHeader { Address }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Stream-new-launches)
### Stream launches with full token detail (mint transfers)
The transfer-based stream returns the token's **name, symbol, decimals, and contract** in the same payload — everything a sniping bot or listings feed needs, with no follow-up metadata call. It also carries the transaction's gas economics and success flag:
```graphql
subscription {
EVM(network: robinhood) {
Transfers(
where: {
Transfer: {Sender: {is: "0x0000000000000000000000000000000000000000"}}
Transaction: {To: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
}
) {
Block { Time Number Hash }
Transaction { Hash From To Value Type GasPrice Gas Cost Index }
TransactionStatus { Success }
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
Data
Id
Index
Success
Type
URI
}
Call { From To Value Index Signature { Name Signature } }
Log { SmartContract Index LogAfterCallIndex Signature { Name Signature } }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Stream-launches-with-token-detail)
:::caution `Transaction.To` misses indirect launches
The mint-transfer pattern only catches launches where the entry contract is the transaction target. Tokens launched **through third-party routers or inside contract-creation transactions** (a measurable share — including several top-volume tokens) have a different `Transaction.To`. The [event-based pattern above](#latest-poolstrade-launches) filters on the **emitter** (`LogHeader.Address`) and catches every launch regardless of how it was routed — treat it as the source of truth and the transfer stream as the convenient enriched feed.
:::
The same query works as a one-shot `query` with `limit` and `orderBy` for backfills — add `dataset: combined` there to reach past realtime retention.
:::note Amounts are decimal-normalized
`Transfer.Amount` is already adjusted for the token's `Decimals`, so the launch mint shows as `1000000000` — 1 billion whole tokens, not the raw on-chain integer. Add `Amount: {eq: "1000000000"}` to the filter if you want to exclude any non-launch mints.
:::
### Launches per day
Grouping by `LogHeader.Address` too shows the split between the two entry contracts. `dataset: combined` merges archive history with the realtime tail — plain `archive` lags the chain head, so counts for the current day come up short.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
where: {
LogHeader: {Address: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
Log: {Signature: {Name: {is: "TokenCreated"}}}
Block: {Time: {since: "2026-07-08T00:00:00Z"}}
}
) {
Block { Date }
launches: count
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Launches-per-day)
### Most active token creators
Useful for spotting spam-bot deployers — a single wallet can mint hundreds of tokens a day.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {descendingByField: "launches"}
where: {
LogHeader: {Address: {in: [
"0x0000ffffbe8efe702c8703ae3477ff5de3d319c0",
"0x00004c4ccc709ef590f7c81102c0689f0263d4e9"
]}}
Log: {Signature: {Name: {is: "TokenCreated"}}}
Block: {Time: {since: "2026-08-05T00:00:00Z"}}
}
) {
Transaction { From }
launches: count
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Most-active-token-creators)
---
## Token metadata (name, symbol, description, image)
Metadata splits across two sources. **Name, symbol, decimals, and contract** are indexed on every transfer's `Currency` object — one query against the launch mint gives you all four for any token:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Transfers(
limit: {count: 1}
where: {
Transfer: {
Currency: {SmartContract: {is: "0x6245e67affa44a23077f0ea7f981a8dc743a0c47"}}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block { Time }
Transaction { Hash From }
Transfer {
Amount
Currency { Name Symbol Decimals SmartContract }
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Token-name-symbol-decimals)
`Transaction.From` on the mint is the creator wallet and `Block.Time` is the exact launch time — this works for any pools.trade token regardless of which entry contract or router launched it.
The remaining fields — the **description**, the **external link**, and the **image URI** that the pools.trade UI renders — exist on-chain only in the factory's `TokenCreated(address,(string,string,string,bytes))` event. That event is now decoded, so you can read them straight out of `Arguments` with no client-side ABI work.
The filter below pins the factory by address because the entry contract emits a *different* `TokenCreated` under the same name (see [Reading decoded arguments](#reading-decoded-arguments)).
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
Log: {Signature: {Name: {is: "TokenCreated"}}}
LogHeader: {Address: {is: "0x000000e200088d55c39a11f609e5f667729ad49b"}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Index
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_String_Value_Arg { string }
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Token-description-and-image)
The tuple arrives flattened — `tokenAddress`, then four `UERC20Metadata` rows keyed by `Index`. A live result:
```text
tokenAddress 0x228513f0b584b38415438bd661d7cfab0dbb3077
UERC20Metadata[0] string "The Stock Impaler" # description
UERC20Metadata[1] string "https://stockimpaler.com/" # external link, often empty
UERC20Metadata[2] string "ipfs://bafkreibersrl3o5pi3vf57d3pk5flqq5bacn…" # image
UERC20Metadata[3] bytes "" # extra, usually empty
```
The image is not always IPFS — some launches point at an HTTPS CDN URL instead, so treat `UERC20Metadata[2]` as an opaque URI.
---
## The Uniswap v4 pool behind each launch
### PoolKey from `TokenLaunched`
`TokenLaunched` is the richest launch event: its indexed fields are the **v4 `poolId`**, and its data payload is the full **`PoolKey`**.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
Log: {
Signature: {
SignatureHash: {is: "3b3d2bafdcae274a232217e1f80ee4305d3af6aa25c8b14b1681bd68d18042a4"}
}
}
LogHeader: {Address: {in: [
"0x23f8209572b4a1c2ad88a42749e830791fb027f1",
"0xad44d55e7f8337c3ce113fbb591486e85be104b2",
"0xce57498d3474dcc244dfb6710ffbe6d4441cd2b2",
"0x60d73b21cdf2ea846ab3d58699bbbb8f29d72491"
]}}
}
) {
Block { Time }
Transaction { Hash }
LogHeader { Address Data }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-PoolKey-from-TokenLaunched)
`LogHeader.Data` decodes as five 32-byte words:
| Word | Field | Typical value |
| --- | --- | --- |
| 0 | `currency0` | `0x000…000` (native ETH) |
| 1 | `currency1` | the launched token |
| 2 | `fee` | `2500` |
| 3 | `tickSpacing` | `25` (current path) / `60` (original path) |
| 4 | `hooks` | `0x000…000` |
:::tip All four launchpad emitters are pools.trade's own
`TokenLaunched` fires from four contracts, and **all four are pools.trade infrastructure**: `0x23f82095…`/`0xad44d55e…` serve the current entry path (tickSpacing **25**), while `0xce57498d…`/`0x60d73b21…` serve the original path (tickSpacing **60** — verified: their tokens are listed live on pools.trade, and FRONG's own pool is a tickSpacing-60 pool). Constrain `LogHeader.Address` to these four; the `tickSpacing` value tells you which launch path a token used, not whether it is pools.trade.
:::
### Decoded pool creation (`Initialize`)
The v4 PoolManager's `Initialize` **is** decoded, so you can read the same `PoolKey` without manual decoding — at the cost of having to scope it to a token.
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 5}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Bytes_Value_Arg { hex }
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Pool-creation-Initialize)
Returns `id` (poolId), `currency0`, `currency1`, `fee`, `tickSpacing`, `hooks`, `sqrtPriceX96`, `tick`.
---
## Trading data
pools.trade tokens are indexed in the `Trading` cube under the **generic Uniswap protocol family**, because they *are* ordinary Uniswap v4 pools:
| Field | Value |
| --- | --- |
| `Pair.Market.ProtocolFamily` | `Uniswap` |
| `Pair.Market.Protocol` | `uniswap_v4` |
| `Pair.Market.Network` | `Robinhood` |
:::caution There is no `pools.trade` protocol label
Unlike Bags.fm (`ProtocolFamily: "Bags"`), pools.trade tokens **cannot be isolated by protocol filter** — `uniswap_v4` on Robinhood also covers pools created outside pools.trade. To scope a query to pools.trade, first collect the token set from `TokenCreated`, then filter `Trading` by `Token.Address: {in: [...]}`.
Tokens also migrate onto other venues once liquid — the same token can show `uniswap_v3` and `pancake_swap_v3` markets with `WETH` and `USDG` quotes.
:::
### Latest trades for a pools.trade token
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Pair: {
Token: {Address: {is: "0x6245e67affa44a23077f0ea7f981a8dc743a0c47"}}
Market: {Network: {is: "Robinhood"}}
}
}
) {
Block { Time }
Side
Price
PriceInUsd
Amounts { Base Quote }
AmountsInUsd { Base Quote }
Trader { Address }
TransactionHeader { Hash }
Pair {
Token { Address Symbol Name }
QuoteToken { Address Symbol }
Pool { Address }
Market { Protocol ProtocolFamily Network }
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Latest-trades-for-a-token)
:::caution Deduplicate before summing USD volume
On Robinhood v4, `Trading.Trades` returns **each trade leg roughly twice**, with the two copies differing only in the last decimals of `AmountsInUsd`. Most legs appear exactly twice, so naive sums run close to **2×**.
Deduplicate on `(TransactionHeader.Hash, Block.Time, Side, Amounts.Base, Pair.QuoteToken.Symbol, Trader.Address)` before aggregating. Naively summing a token's `Volume_Usd` over 24h roughly doubles the figure the pools.trade UI reports; after deduplication the two match.
Note also that one user swap can fan out into **several routed legs** across ETH, WETH, and USDG pairs in the same transaction. Summing every leg overstates end-user volume even after deduplication.
:::
### OHLCV price candles
```graphql
{
Trading {
Tokens(
limit: {count: 24}
orderBy: {descending: Block_Time}
where: {
Token: {Address: {is: "0x6245e67affa44a23077f0ea7f981a8dc743a0c47"}}
Interval: {Time: {Duration: {eq: 3600}}}
}
) {
Block { Time }
Token { Address Symbol Name Network }
Volume { Usd }
Price { Ohlc { Open High Low Close } }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-OHLCV-price-candles)
Change `Duration` to `60`, `300`, `900`, or `86400` for other candle sizes.
### Top pools.trade tokens by volume
The two-step pattern: pass a token set harvested from `TokenCreated` into the `Trading` cube.
```graphql
{
Trading {
Tokens(
limit: {count: 25}
orderBy: {descendingByField: "vol"}
where: {
Token: {
Address: {in: [
"0x6245e67affa44a23077f0ea7f981a8dc743a0c47",
"0x385b36ff682ab4c76e7c37a66b96aabc466471d5",
"0xd3d5be6558f84e628ee091b511df92b4e461a53b"
]}
Network: {is: "Robinhood"}
}
Interval: {Time: {Duration: {eq: 3600}}}
Block: {Time: {since: "2026-08-05T06:00:00Z"}}
}
) {
Token { Address Symbol Name }
vol: sum(of: Volume_Usd)
trades: count
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Top-tokens-by-volume)
:::note Keep per-interval metrics out of aggregations
Selecting a per-row metric such as `Supply { MarketCap }` alongside `sum(of: Volume_Usd)` adds it as a grouping key, so you get one row **per interval** instead of one row per token. Drop it to get a clean per-token total.
Time windows go in `Block: {Time: {since: …}}` — `Interval.Time.Since` is not a valid field.
:::
---
## Pool liquidity, slippage, and balance changes
Three realtime cubes carry data traders usually have to compute themselves. All three are **realtime-only** on Robinhood — `dataset: archive` and `dataset: combined` both error — so use them for live monitoring and persist what you need.
### Live pool liquidity (depth)
`DEXPoolEvents` snapshots the pool's reserves on every swap and liquidity event, keyed by the **v4 `PoolId`** — the same id `TokenLaunched` and `Initialize` emit at launch. This is the fastest way to read a pools.trade token's real depth (rug risk, exit capacity) without summing transfers:
```graphql
{
EVM(network: robinhood) {
DEXPoolEvents(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
PoolEvent: {
Pool: {PoolId: {is: "0xacea8920877840033f0275c37f9b61550b5326917e948bcf8339714d96f9521a"}}
}
}
) {
Block { Time }
Log { Signature { Name } }
PoolEvent {
Dex { ProtocolName ProtocolVersion }
Pool { PoolId CurrencyA { Symbol } CurrencyB { Symbol } }
Liquidity {
AmountCurrencyA
AmountCurrencyAInUSD
AmountCurrencyB
AmountCurrencyBInUSD
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Live-pool-liquidity)
`AmountCurrencyA` / `AmountCurrencyAInUSD` is the ETH side of the pool (e.g. `141.2` ETH ≈ `$269,852` for FRONG); `AmountCurrencyB` is the token side. The token side's USD value reads `0` for unpriced meme tokens — value the pool from the ETH leg (double it for total TVL in a balanced price range).
### Per-swap slippage
`DEXPoolSlippages` reports execution quality per swap — **`SlippageBasisPoints`** plus the trade's price and min-out/max-in bounds. Filter by `PoolId` the same way:
```graphql
{
EVM(network: robinhood) {
DEXPoolSlippages(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
Price: {
Pool: {PoolId: {is: "0xacea8920877840033f0275c37f9b61550b5326917e948bcf8339714d96f9521a"}}
}
}
) {
Block { Time }
Price {
Dex { ProtocolName }
Pool { PoolId CurrencyA { Symbol } CurrencyB { Symbol } }
AtoB { Price MaxAmountIn MinAmountOut }
SlippageBasisPoints
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Per-swap-slippage)
A stream of this filtered to `SlippageBasisPoints: {gt: 100}` is a ready-made "toxic fill" alert for a token's pool.
### Per-transaction balance changes
`TransactionBalances` gives each address's **pre- and post-transaction balance** — position tracking without replaying transfers. For a pools.trade token:
```graphql
{
EVM(network: robinhood) {
TransactionBalances(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
TokenBalance: {
Currency: {SmartContract: {is: "0x6245e67affa44a23077f0ea7f981a8dc743a0c47"}}
}
}
) {
Block { Time }
Transaction { Hash From }
TokenBalance {
Address
PreBalance
PostBalance
BalanceChangeReasonCode
HasPreBalance
TotalSupply
Currency { Symbol }
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Per-transaction-balance-changes)
:::note Check `HasPreBalance`
When `HasPreBalance` is `false`, `PreBalance` reads `0` — meaning "unknown", not "zero". Treat the delta as reliable only when `HasPreBalance` is `true`. `PostBalanceInUSD` is `0` for unpriced launch tokens.
:::
---
## Crowd Launch (CCA) auctions
A Crowd Launch runs a **continuous clearing auction** in its own contract for ~4 hours before the pool opens. Bidders submit into discrete **price ticks**; the clearing price ratchets up as the book fills, and the auction can end **oversubscribed**.
All auction events are **raw**, so query them by topic0. Because each auction has its own contract, filtering on `SignatureHash` alone gives you **every auction on the network at once** — which is usually what you want.
### Detect new Crowd Launch auctions
Every Crowd Launch deploys its auction through the **auction factory** `0x000000001f26a0044baa66024e7b6599c61963f8`, which emits `AuctionCreated(address,address,uint256,bytes)`. Stream it to learn each new auction's contract address the moment it exists — then point the bid and clearing-price queries below at that address:
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: {Address: {is: "0x000000001f26a0044baa66024e7b6599c61963f8"}}
Log: {
Signature: {
SignatureHash: {is: "7ede475fad18ccf0039f2b956c4d43a8b4ed0853de4daaa8ae25299f331ae3b9"}
}
}
}
) {
Block { Time }
Transaction { Hash From }
LogHeader { Address Data }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Stream-new-Crowd-Launch-auctions)
The launch transaction also contains the token's mint, the entry contract's `TokenCreated`, and the auction's first `TickInitialized` / `ClearingPriceUpdated` events, so one transaction hash links token, creator, and auction contract.
### Every bid across all live auctions
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {Log: {Signature: {Name: {is: "BidSubmitted"}}}}
) {
Block { Time Number }
Transaction { Hash From }
LogHeader { Address }
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Crowd-Launch-bids)
`BidSubmitted(uint256,address,uint256,uint128)` decodes to four named arguments — `id`, `owner`, `priceQ96` and `amount`. `owner` is the bidder (use it rather than `Transaction.From`, which is whatever contract or router relayed the bid), and `priceQ96` is a Q96 fixed-point price: divide by 2⁹⁶ for a human number. `LogHeader.Address` is the auction contract, which is how you tell the auctions apart — there is no filter needed to span them all.
### Clearing price updates
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
Log: {Signature: {Name: {is: "ClearingPriceUpdated"}}}
LogHeader: {Address: {is: "0xD10dc5f79F95E953e710F1eDeBddE0baD2e8fed8"}}
}
) {
Block { Time }
Transaction { Hash }
LogHeader { Address }
Arguments {
Name
Value { ... on EVM_ABI_BigInt_Value_Arg { bigInteger } }
}
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Crowd-Launch-clearing-price)
`ClearingPriceUpdated` decodes to `blockNumber` and `clearingPriceQ96`. Drop the `LogHeader.Address` filter to watch every auction at once, or swap the event name for any row in the [event reference](#event-reference) to follow tick initialization (`TickInitialized` → `priceQ96`), the moving book edge (`NextActiveTickUpdated` → `priceQ96`), or auction checkpoints (`CheckpointUpdated` → `blockNumber`, `clearingPriceQ96`, `cumulativeMps`; `AuctionStepRecorded` → `startBlock`, `endBlock`, `mps`).
:::note Prices are Q96 fixed-point
Clearing, floor, and tick-size prices are **Q96** values. Divide by `2**96` to get a human-readable ratio.
:::
---
## Holders and supply
```graphql
{
EVM(dataset: combined, network: robinhood) {
Holders(
limit: {count: 100}
orderBy: {descending: Balance_Amount}
where: {
Currency: {SmartContract: {is: "0x6245e67affa44a23077f0ea7f981a8dc743a0c47"}}
Balance: {Amount: {gt: "0"}}
}
) {
Holder { Address }
Balance { Amount FirstChangeTime LastChangeTime UpdateCount }
}
}
}
```
[▶ Run this query in the Bitquery IDE](https://ide.bitquery.io/Pools-trade-Token-holders-and-supply)
`dataset: combined` keeps balances current to the head block — on `archive` alone the top-holder balance can lag the chain head by minutes on an actively traded token.
:::caution Exclude the PoolManager from holder analytics
The **top holder of every pools.trade token is the Uniswap v4 PoolManager** `0x8366a39cc670b4001a1121b8f6a443a643e40951`, because the pool's liquidity is held there.
Filter it out before computing holder counts, concentration, or "top wallet" leaderboards, or the pool itself will dominate every result.
:::
For circulating supply and market cap, see [Robinhood Token Supply](/docs/blockchain/robinhood/robinhood-token-supply).
---
## Graduation
The pools.trade UI shows a **graduation progress** percentage and a *Near graduation* filter. It is computed off-chain as:
```text
graduationProgress = fdvUsd / graduationTargetUsd * 100
```
with a **$50,000 FDV** target for curve launches. Because the v4 pool already exists from block one, crossing 100% does **not** emit a migration event — tokens well past target still report a live-curve status.
To reproduce it, take FDV from the `Trading` cube (`Supply { MarketCap }`) and compare against the $50,000 threshold, rather than looking for an on-chain graduation event.
Crowd Launch auctions **do** have a discrete terminal state: the auction contract stops accepting bids at `endsAt` and the token transitions to graduated. Track that via the auction's final `CheckpointUpdated` / `ClearingPriceUpdated` events, or by watching for the first `Swap` on the token's v4 pool.
---
## Cross-checking against pools.trade's own API
pools.trade exposes an **unauthenticated tRPC API** at `https://pools.trade/api/trpc/` that serves its UI. It is useful for validating numbers you derive from Bitquery (graduation progress, holder counts) and for off-chain-only fields like linked X accounts. Discovered procedures:
| Procedure | Input | Returns |
| --- | --- | --- |
| `curve.listLaunches` | `{sortBy: "volume"}` | Curve launches: FDV, graduation %, holders, creator, X link, pool stats |
| `curve.getLaunchByAddress` | `{tokenAddress}` | One launch + price series + recent trades |
| `curve.listLaunchesByCreator` | `{creatorAddress}` | A creator's launches |
| `curve.searchLaunches` | `{query}` | Token search |
| `cca.listAuctions` | `{}` | Live + graduated Crowd Launch auctions with clearing/floor price (Q96), raise, bidders |
| `cca.getAuctionByAddress` / `cca.getAuction` | `{tokenAddress}` / `{auctionId}` | One auction's full state |
| `cca.getBidsHistoryPage` | `{tokenAddress}` | Paginated bids: bidder, USD amount, tx hash, status |
| `cca.getTradesHistoryPage` | `{tokenAddress}` | Paginated post-graduation trades |
| `prices.getOhlc` | `{chainId: 4663, address}` | OHLC candles |
| `prices.getHistories` / `prices.getTokens` | token list | Price series / spot prices |
Calls are GET requests with `?batch=1&input=` in tRPC batch format, e.g. `input={"0":{"tokenAddress":"0x…"}}`.
:::caution Treat it as a reference, not a data source
This API is undocumented, unversioned, and can change or gain authentication without notice — it exists to serve the pools.trade frontend, and heavy polling will likely get rate-limited or blocked. For production trading systems, index from the chain via the queries in this guide and use the tRPC API only to spot-check.
:::
---
## FAQ
### How do I detect a newly launched pools.trade token?
Subscribe to the decoded `TokenCreated` event on **both** entry contracts — `0x0000ffff…19c0` and the still-active original `0x00004c4c…d4e9` — or use the mint-transfer stream for name/symbol/decimals in the same payload. See [Newly launched tokens](#newly-launched-tokens).
### Why can't I filter pools.trade trades by protocol?
Because pools.trade tokens trade in **plain Uniswap v4 pools**, they are indexed as `ProtocolFamily: "Uniswap"` / `Protocol: "uniswap_v4"` alongside every other v4 pool on Robinhood. Scope queries by token address instead — see [Top pools.trade tokens](#top-poolstrade-tokens-by-volume).
### Why is my USD volume roughly double what pools.trade shows?
`Trading.Trades` returns each leg about twice on Robinhood v4. Deduplicate before summing — see the [caution above](#latest-trades-for-a-poolstrade-token).
### How do I track Crowd Launch bids?
Filter `Log.Signature.Name` on `BidSubmitted` and read `Arguments` — `id`, `owner`, `priceQ96` and `amount` all decode. Each Crowd Launch deploys its own auction contract, so filtering on the event alone spans every live auction at once, with `LogHeader.Address` identifying which one. Stay on realtime: archive currently holds no `BidSubmitted` rows.
### Where do I get a token's name, symbol, and image?
The entry contract's `TokenCreated(address)` carries only the address. Use the mint-transfer query for name/symbol/decimals, and the **factory's** `TokenCreated` — now decoded — for description, external link and image; both are in [Token metadata](#token-metadata-name-symbol-description-image).
### Is there a bonding-curve contract to query?
No. Unlike Flap.sh or Bags.fm, pools.trade has no separate bonding-curve AMM and no `LaunchedToDEX`-style graduation event. Trades hit a real Uniswap v4 pool from the first block.
---
## Next steps
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) — full trade schema for the network
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) — compare launchpads side by side
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api) — holder distribution queries
- [WebSocket subscriptions](/docs/subscriptions/websockets/) — turn any query above into a live stream
---
## Robinhood Balances API — Wallet Portfolios & History
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-balances-api/
Query Robinhood wallet balances with Bitquery GraphQL: full portfolios, multi-address batches, wallet profiling, and balance history as of any date.
# Robinhood Balances API — Wallet Portfolios & History
Query **wallet balances on Robinhood** with Bitquery GraphQL. The `EVM.Balances` cube returns **computed balances with built-in aggregates** — amount, USD value, first/last change time, and update count — grouped by whatever dimensions you select: one wallet's full portfolio, a batch of wallets, or network-wide per-currency totals, all in single calls that would take thousands of `eth_getBalance` / `balanceOf` RPCs. For token-centric holder rankings and counts, use the dedicated [Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/).
Every query on this page was executed against the production endpoint before publishing.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/)
- [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/)
- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/) (for prices to value non-ETH holdings)
- [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api/)
:::
**On this page:** [Concepts](#datasets-grouping-and-selectwhere) · [Portfolio](#all-token-balances-of-an-address-portfolio) · [As-of-date](#balance-as-of-a-date-time-travel) · [Single token](#native-eth-and-single-token-balances) · [Multi-address](#balances-for-multiple-addresses) · [Wallet profile](#wallet-profile-first-seen-last-active-update-count) · [Currency totals](#network-wide-per-currency-totals) · [FAQ](#faq)
---
## Why query balances here instead of an RPC loop
| | Node RPC (`eth_getBalance` / `balanceOf` calls) | Bitquery Balances |
| --- | --- | --- |
| Whole portfolio | One call **per token** you already know about | One call returns every token the wallet holds |
| Token holders | Impossible without indexing all transfers yourself | One sortable query on the [Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/) |
| History | Archive node + block-pinned calls | `Block.Date.till` gives the balance as of any date |
| Extras | — | USD value, first/last change time, update count |
---
## Datasets, grouping, and selectWhere
- Use **`dataset: combined`** — balances are computed from history, and combined guarantees the full picture.
- **Grouping follows your selection.** Filter/select `Balance.Address` to get per-wallet rows; select only `Currency` to get network-wide per-currency totals; select both for wallet × token rows.
- **`selectWhere` filters aggregated results** (like SQL `HAVING`): `Amount(selectWhere: { gt: "0" })` drops zero/dust rows after the balance is computed. Amount thresholds are strings.
- **`AmountInUSD` is populated for native ETH; token rows generally return `0`.** USDG is a dollar stablecoin, so its `Amount` is effectively USD; value other tokens by joining prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/).
---
## All token balances of an address (portfolio)
▶️ [Run in IDE](https://ide.bitquery.io/wallet-token-balances-robinhood-chain)
Everything a wallet holds in one call. The `selectWhere` keeps only non-zero rows.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: { Balance: { Address: { is: "0x9c0489b89ae473de6edcb159f21c3019ba730282" } } }
) {
Currency {
Symbol
SmartContract
}
Balance {
Amount(selectWhere: { gt: "0" })
AmountInUSD
}
}
}
}
```
---
## Balance as of a date (time travel)
Add `Block.Date.till` to compute the same portfolio **as of any date** — audits, tax snapshots, "what did this whale hold before the launch". A date before the wallet's first activity returns no rows.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: {
Block: { Date: { till: "2026-07-20" } }
Balance: { Address: { is: "0x9c0489b89ae473de6edcb159f21c3019ba730282" } }
}
) {
Currency {
Symbol
SmartContract
}
Balance {
Amount(selectWhere: { gt: "0" })
AmountInUSD
}
}
}
}
```
---
## Native ETH and single-token balances
Filter `Currency.Native: true` for the ETH balance, or pin one contract for a single token — with the change-history aggregates included.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: {
Balance: { Address: { is: "0x9c0489b89ae473de6edcb159f21c3019ba730282" } }
Currency: { Native: true }
}
) {
Currency {
Symbol
Native
}
Balance {
Amount
AmountInUSD
}
}
}
}
```
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: {
Balance: { Address: { is: "0x9c0489b89ae473de6edcb159f21c3019ba730282" } }
Currency: { SmartContract: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } }
}
) {
Currency {
Symbol
SmartContract
}
Balance {
Amount
AmountInUSD
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
## Balances for multiple addresses
Batch a watchlist with `Address.in` — one row per address (per selected currency).
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: {
Balance: {
Address: {
in: [
"0x9c0489b89ae473de6edcb159f21c3019ba730282"
"0xcaf681a66d020601342297493863e78c959e5cb2"
]
}
}
Currency: { Native: true }
}
) {
Balance {
Address
Amount
AmountInUSD
}
}
}
}
```
---
## Token holders
Holder rankings, counts, whale floors, distribution stats, and dormancy screens have a dedicated cube and page — see the **[Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/)**.
---
## Wallet profile: first seen, last active, update count
The built-in aggregates turn balances into a wallet profiler: `FirstChangeTime` (when the wallet first touched each asset), `LastChangeTime` (most recent activity), and `UpdateCount` (how many balance changes) — age, dormancy, and activity signals with no extra indexing.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(
where: { Balance: { Address: { is: "0x9c0489b89ae473de6edcb159f21c3019ba730282" } } }
) {
Currency {
Symbol
SmartContract
}
Balance {
Amount(selectWhere: { gt: "0" })
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
## Network-wide per-currency totals
With no address dimension, rows group per currency: `Amount` becomes the **total held across all addresses**, with network-level change stats — the full field set of the cube on display.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Balances(limit: { count: 10 }) {
Currency {
Decimals
Symbol
SmartContract
DelegatedTo
Fungible
HasURI
Name
Native
ProtocolName
}
Balance {
Amount(selectWhere: { gt: "0" })
AmountInUSD
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
:::tip Continuous balance data via Kafka
Need balance changes as a continuous feed? Bitquery delivers Robinhood token data as **Kafka streams** (protobuf topic `robinhood.tokens.proto`) with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## Use-case patterns
| Goal | Approach |
| --- | --- |
| Wallet / portfolio page | [Portfolio query](#all-token-balances-of-an-address-portfolio); poll on an interval for live UX |
| Tax / audit snapshots | [Balance as of a date](#balance-as-of-a-date-time-travel) with `Block.Date.till` |
| Token distribution, rich lists & whales | [Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/) rankings, counts, and balance floors |
| Wallet profiling (age, dormancy) | [First/last change + update count](#wallet-profile-first-seen-last-active-update-count) |
| Exchange / custody monitoring | [Multi-address batch](#balances-for-multiple-addresses) on a polling schedule |
| Supply-side view | [Per-currency totals](#network-wide-per-currency-totals), or the [Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply/) |
---
## Tips
1. Always use **`dataset: combined`** for balance queries — balances are computed from full history.
2. Remember grouping follows selection: add or drop `Balance.Address` / `Currency` fields to pivot between wallet, token, and network views.
3. Use `selectWhere` (post-aggregation) for balance thresholds; regular `where` filters raw rows before aggregation.
4. `AmountInUSD` is native-ETH-only in practice — USDG's `Amount` ≈ dollars; price other tokens via the [Trades API](/docs/blockchain/robinhood/robinhood-trades/).
5. For holder rankings and counts, use the dedicated [Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/) — its `Holders` cube is built for the token-centric view.
6. An as-of-date query before a wallet's first activity returns no rows — that's the correct answer, not an error.
---
## FAQ
### How do I get all token balances of a Robinhood address?
Query `EVM.Balances` on `dataset: combined` filtered by `Balance.Address`, selecting `Currency` and `Balance.Amount` — one call returns the full portfolio. Add `Amount(selectWhere: {gt: "0"})` to hide dust and emptied positions.
### How do I get the balance at a past date?
Add `Block: { Date: { till: "YYYY-MM-DD" } }` to any balance query — the cube recomputes balances as of that date. See [time travel](#balance-as-of-a-date-time-travel).
### How do I list the top holders of a token?
Use the dedicated [Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api/) — its `Holders` cube returns sortable holder rankings, holder counts, distribution stats, and dormancy screens.
### Why is AmountInUSD 0 for my token balances?
USD enrichment covers native ETH; token rows generally return `0`. USDG is a dollar stablecoin (read `Amount` as USD), and other tokens can be valued by joining prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/).
### Can I stream balances in real time?
`Balances` is a query cube — poll it on your interval for live UX. For continuous balance-change feeds at firehose scale, Bitquery delivers Robinhood token data over [Kafka streams](/docs/streams/kafka-streaming-concepts/).
### Is this a replacement for eth_getBalance?
For anything beyond a single known token it's strictly stronger: whole portfolios, holder lists, holder counts, historical as-of-date balances, and change aggregates come from single queries instead of RPC loops over an archive node.
---
## Robinhood Calls & Traces API — WebSocket Streams
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-calls-api/
Stream Robinhood contract calls and internal traces over GraphQL WebSockets: decoded inputs, call trees, deployments and reverts. No node required.
# Robinhood Calls & Traces API — WebSocket Streams
Stream **every contract call and internal trace on Robinhood** with Bitquery GraphQL — top-level calls and nested internal calls, with **decoded input arguments**, gas accounting, revert errors, and the surrounding transaction and receipt joined into one record. The `EVM.Calls` cube on `network: robinhood` replaces a tracing node: no `debug_traceTransaction` loops, no 4-byte databases, no trace decoding pipeline.
Open **one WebSocket that carries every call on the chain**, or narrowly filtered sockets — per contract, per function, per selector, deployments-only, reverts-only. Every subscription on this page was verified live over WebSocket, and every query was executed against the production endpoint before publishing.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api/)
- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/)
- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/)
- [WebSocket authentication](/docs/authorization/websocket/)
:::
**On this page:** [Why not a tracing node](#why-stream-calls-instead-of-tracing-a-node) · [Datasets & history](#datasets-and-history) · [Call anatomy](#what-one-call-row-contains) · [Firehose](#stream-all-calls-firehose) · [By contract](#stream-calls-to-one-contract) · [By function](#stream-by-function-name-or-selector) · [Deployments](#stream-contract-deployments) · [Reverts](#stream-reverted-calls) · [Value traces](#internal-eth-value-transfers) · [By wallet](#calls-from-a-wallet) · [Call tree](#full-call-tree-of-a-transaction) · [Analytics](#top-called-contracts) · [FAQ](#faq)
---
## Why stream calls instead of tracing a node
| | Tracing node (`debug_traceTransaction` / `trace_filter`) | Bitquery Calls stream |
| --- | --- | --- |
| Infrastructure | Archive node with tracing enabled — heavy to run and sync | One WebSocket to `streaming.bitquery.io` |
| Decoding | Raw calldata; you maintain ABIs and 4-byte lookups | `Arguments` arrive **decoded and typed** for known signatures |
| Scope | Per-transaction or per-block tracing loops | Server-side filters: contract, function name, selector, caller, `Create`, `Reverted`, value, time |
| Context | Trace only — separate calls for tx and receipt | Transaction and `Receipt` joined onto every call |
| Deployments | Diff traces for `CREATE` frames yourself | `Call: { Create: true }` is a filter |
| Backfill | Re-trace history block by block | Same query with `dataset: archive` / `combined` |
---
## Datasets and history
- **`realtime`** (the default) — a rolling window of recent blocks whose depth varies; measure it with the probe below rather than assuming it.
- **`archive`** — deep call history, retained up to roughly the **last 3 months** (Robinhood is a newer chain, so today the archive holds its complete history; older data ages out as the cap applies); its head lags the chain by minutes.
- **`combined`** — archive + realtime union; the safe choice for fixed windows (24h, 7d).
For older or bulk history, Bitquery can provide **data exports** — [contact support](https://bitquery.io/forms/api).
### Check the calls window
```graphql
{
EVM(network: robinhood) {
Calls {
count
earliest: Block { Time(minimum: Block_Time) }
latest: Block { Time(maximum: Block_Time) }
}
}
}
```
---
## What one call row contains
| Group | What it gives you |
| --- | --- |
| **`Call`** | `From`/`To`, `Value` (+USD), gas fields, `Signature` (function `Name`, full `Signature`, 4-byte `SignatureHash`), flags: `Create`, `Delegated`, `Reverted`, `Success`, `SelfDestruct`, `Error`, plus tree position (`Index`, `CallerIndex`, `CallPath`, `InternalCalls`) |
| **`Arguments`** | Decoded, typed **function input values** (`address`, `bigInteger`, `string`, `hex`, `bool`, `integer`) with parameter names |
| **`Transaction`** | Hash, `From`/`To`, value, full gas and fee fields (incl. USD) |
| **`Receipt`** | `GasUsed`, `CumulativeGasUsed`, `ContractAddress`, receipt `Type` |
| **`Block`** | `Number`, `Time`, `Nonce` |
Tree semantics: `Index` numbers each call within the transaction, `CallerIndex` points to the parent call's index, and `CallPath` is the position path from the top-level call (e.g. `[2, 0]` = first sub-call of call 2) — enough to rebuild the entire trace tree client-side.
For calls, `Signature.SignatureHash` is the **4-byte selector** as uppercase hex **without** a `0x` prefix (e.g. `A9059CBB` for `transfer(address,uint256)`). Calls with an empty `Name` are undecoded selectors — still streamed and filterable by hash. Note that on-chain `balanceOf`-style reads made by contracts also appear: this cube sees every call executed, not just state-changing ones.
---
## Stream all calls (firehose)
One socket, every call on the chain — top-level and internal — with decoded inputs and full context. Events arrive in per-block batches.
:::warning Very high volume
Calls are the highest-volume cube on a busy chain (every transaction fans out into many internal calls). Use the firehose for exploration and full indexers; filter in production.
:::
```graphql
subscription {
EVM(network: robinhood) {
Calls {
Block {
Number
Time
Nonce
}
Call {
CallPath
InternalCalls
From
To
Signature {
Name
Parsed
Signature
SignatureHash
SignatureType
}
CallerIndex
Create
Delegated
Error
Gas
GasUsed
Index
Reverted
SelfDestruct
Success
Value
ValueInUSD
}
Receipt {
CumulativeGasUsed
ContractAddress
Type
GasUsed
}
Transaction {
From
To
Type
Cost
CostInUSD
Gas
GasFeeCap
GasFeeCapInUSD
GasPriceInUSD
GasPrice
GasTipCapInUSD
GasTipCap
Hash
Value
ValueInUSD
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
:::tip WebSocket connection
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/). Any subscription on this page also runs as a query — add `limit` and `orderBy` and drop the `subscription` keyword.
:::
:::tip Prefer Kafka for the firehose
Consuming the full call feed continuously? Bitquery also delivers Robinhood data as **Kafka streams** — decoded transactions, calls, and events on the protobuf topic `robinhood.transactions.proto` — with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## Stream calls to one contract
**Protocol ops:** every function invocation of one contract — including internal calls from other contracts, which a mempool or tx-level watcher misses. Example: the Uniswap V4 pool manager.
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { To: { is: "0x8366a39cc670b4001a1121b8f6a443a643e40951" } } }
) {
Block {
Time
}
Call {
From
To
Signature {
Name
SignatureHash
}
GasUsed
Success
}
Transaction {
Hash
}
}
}
}
```
---
## Stream by function name or selector
**Method-level feeds:** filter by decoded function name to receive one method across **every** contract — for example, every ERC-20 `transfer` call on the chain.
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { Signature: { Name: { is: "transfer" } } } }
) {
Block {
Time
}
Call {
From
To
Signature {
Name
SignatureHash
}
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
To pin one exact ABI variant — or to match an **undecoded** method — filter the 4-byte selector instead (uppercase hex, no `0x`):
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { Signature: { SignatureHash: { is: "70A08231" } } } }
) {
Block {
Time
}
Call {
To
Signature {
Name
SignatureHash
}
}
}
}
}
```
---
## Stream contract deployments
▶️ [Run in IDE](https://ide.bitquery.io/new-contracts-deployed-robinhood-chain)
**New-contract radar:** `Call: { Create: true }` matches every `CREATE`/`CREATE2` frame — top-level and factory-internal. On these rows **`Call.To` is the newly deployed contract address** and `Call.From` is the deployer (`Receipt.ContractAddress` is populated only for top-level deployment transactions).
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { Create: true } }
) {
Block {
Time
}
Call {
From
To
Create
Success
}
Transaction {
Hash
From
}
}
}
}
```
---
## Stream reverted calls
**Error monitoring:** every failed call with its revert reason — watch your own contracts for breakage, or the whole chain for failing bots and exploits in progress. `Call.Error` carries the message (commonly `execution reverted`).
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { Reverted: true } }
) {
Block {
Time
}
Call {
From
To
Error
Reverted
Success
Signature {
Name
}
}
Transaction {
Hash
}
}
}
}
```
Scope it with a `Call.To` filter to alert only on your own deployments.
---
## Internal ETH value transfers
**Value tracing:** calls that move native ETH (`Call.Value > 0`) — including internal transfers that never appear as top-level transaction values. The [Transfers cube](/docs/blockchain/robinhood/robinhood-transfers/) models the same movements with USD enrichment; use Calls when you want them inside their execution context.
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { Value: { gt: "0" } } }
) {
Block {
Time
}
Call {
From
To
Value
ValueInUSD
Signature {
Name
}
}
Transaction {
Hash
}
}
}
}
```
---
## Calls from a wallet
Everything one address executes — as transaction sender or as an internal caller (routers and bots show up here with their full fan-out). Swap in any address; rows appear only while it is active.
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: { Call: { From: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } } }
) {
Block {
Time
}
Call {
To
Value
Signature {
Name
}
}
Transaction {
Hash
}
}
}
}
```
---
## Full call tree of a transaction
**The `debug_traceTransaction` replacement:** every call frame of one transaction, ordered by `Call_Index`, with `CallerIndex`/`CallPath` to rebuild the tree and decoded arguments per frame.
```graphql
{
EVM(network: robinhood, dataset: archive) {
Calls(
orderBy: { ascending: Call_Index }
where: {
Transaction: {
Hash: {
is: "0x816be7f8f359f85066599fcd2585cbf7c3b544590315afc5298dc7e538b3678b"
}
}
}
) {
Call {
Index
CallerIndex
CallPath
From
To
Delegated
Create
Success
GasUsed
Value
Signature {
Name
}
}
}
}
}
```
---
## Top called contracts
**Discovery:** the most-invoked contracts over a window, with how many distinct methods each serves.
```graphql
{
EVM(network: robinhood) {
Calls(
limit: { count: 10 }
orderBy: { descendingByField: "calls" }
where: { Block: { Time: { since_relative: { hours_ago: 1 } } } }
) {
Call {
To
}
calls: count
signatures: count(distinct: Call_Signature_SignatureHash)
}
}
}
```
---
## Top function signatures
Which methods dominate the chain — grouped by signature with counts. Rows with an empty `Name` are undecoded selectors.
```graphql
{
EVM(network: robinhood) {
Calls(limit: { count: 15 }, orderBy: { descendingByField: "count" }) {
Call {
Signature {
Name
SignatureHash
}
}
count
}
}
}
```
---
## Top gas-burning contracts
**Gas analytics:** rank contracts by total gas consumed over a window — where the chain's compute actually goes.
```graphql
{
EVM(network: robinhood) {
Calls(
limit: { count: 10 }
orderBy: { descendingByField: "gas" }
where: { Block: { Time: { since_relative: { hours_ago: 1 } } } }
) {
Call {
To
}
gas: sum(of: Call_GasUsed)
calls: count
}
}
}
```
---
## Call volume in a time window
One-row stats for dashboards: total calls, distinct callers, distinct called contracts. Use `dataset: combined` when the window must be complete regardless of realtime depth.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Calls(where: { Block: { Time: { since_relative: { hours_ago: 1 } } } }) {
count
callers: count(distinct: Call_From)
contracts: count(distinct: Call_To)
}
}
}
```
---
## Use-case patterns
| Goal | Approach |
| --- | --- |
| Trace explorer / tx debugger | [Per-transaction call tree](#full-call-tree-of-a-transaction) with `Index`/`CallerIndex`/`CallPath` |
| New-contract & token-factory radar | [`Create: true` stream](#stream-contract-deployments) — `Call.To` is the deployed address |
| Contract error alerting | [`Reverted: true`](#stream-reverted-calls) scoped to your `Call.To` |
| Method-level analytics | [Name / selector streams](#stream-by-function-name-or-selector); counts via [top signatures](#top-function-signatures) |
| Internal ETH flow tracing | [`Value > 0` calls](#internal-eth-value-transfers), or [Transfers](/docs/blockchain/robinhood/robinhood-transfers/) for USD-priced movements |
| Bot / router monitoring | [`Call.From` stream](#calls-from-a-wallet) for the full execution fan-out |
| Chain ops dashboards | [Top called contracts](#top-called-contracts), [gas burners](#top-gas-burning-contracts), [window stats](#call-volume-in-a-time-window) |
| Event-side view of the same activity | [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api/) |
---
## Tips
1. **Filter production streams.** The calls firehose outweighs every other cube — per-contract, per-selector, deployments-only, and reverts-only sockets are cheap.
2. For calls, `SignatureHash` is the **4-byte selector, uppercase hex, no `0x`** (events use the full 32-byte topic hash instead).
3. `Create: true` rows put the **deployed contract in `Call.To`**; `Receipt.ContractAddress` fills only for top-level deployment transactions.
4. Function names collide across ABIs and undecoded methods have empty names — pin exact behavior with the selector filter.
5. Every executed call appears, including contract-to-contract `balanceOf`-style reads — filter by name/selector to cut that noise from analytics.
6. Rebuild trace trees client-side from `Index`, `CallerIndex`, and `CallPath`; `InternalCalls` tells you how many children a frame has.
7. Realtime depth varies — measure with the [window probe](#check-the-calls-window); use `combined` for fixed windows. Archive retains up to roughly the last 3 months of calls; for older or bulk data, ask about [exports](https://bitquery.io/forms/api).
8. Decoded `Arguments` are the function **inputs**; for emitted results, join the same transaction on the [Events API](/docs/blockchain/robinhood/robinhood-events-api/).
---
## FAQ
### Can I trace Robinhood transactions without a tracing node?
Yes — filter `EVM.Calls` by `Transaction.Hash` and order by `Call_Index` to get every internal call frame with decoded inputs, gas, and revert state: a `debug_traceTransaction` replacement served over GraphQL. Stream the same cube for live traces.
### How do I detect new contract deployments in real time?
Subscribe with `Call: { Create: true }`. Each row's `Call.To` is the freshly deployed contract address and `Call.From` its deployer — factory-internal deployments included. See [Stream contract deployments](#stream-contract-deployments).
### How do I monitor failed or reverted calls?
Subscribe with `Call: { Reverted: true }` (optionally scoped by `Call.To` to your contracts) and read `Call.Error` for the revert reason. See [Stream reverted calls](#stream-reverted-calls).
### How do I filter by a 4-byte function selector?
Use `Call.Signature.SignatureHash` with the selector as uppercase hex without `0x` — e.g. `A9059CBB` for `transfer(address,uint256)`. This also matches methods whose ABI is unknown (empty `Name`).
### How far back does Robinhood calls data go?
`archive` retains up to roughly the last 3 months of calls (on a newer chain like Robinhood that is currently its complete history), and `realtime` holds a rolling recent window — measure either with the [window probe](#check-the-calls-window). For older or bulk history, Bitquery can provide data exports on request.
### Which cube should I use — Calls, Events, or Transfers?
`Calls` is execution: who invoked what, with inputs, gas, and reverts. [`Events`](/docs/blockchain/robinhood/robinhood-events-api/) is what contracts emitted. [`Transfers`](/docs/blockchain/robinhood/robinhood-transfers/) is pre-modeled asset movement with USD enrichment. See [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/).
---
## Robinhood Chain GraphQL API: Trades, Pons Launchpad, Live Streams
URL: https://docs.bitquery.io/docs/blockchain/robinhood/
Robinhood Chain API (chain ID 4663): trades, transfers, balances, holders, liquidity, events, calls and the Pons launchpad via Bitquery GraphQL and WebSocket.
# Robinhood Chain API: Trades, Pons Launchpad and Real-Time Streams
**Robinhood Chain** (`network: robinhood`, chain ID **4663**) is Robinhood's EVM Layer 2, built with the Arbitrum Orbit stack and live on mainnet since July 2026. Gas is paid in ETH, the chain carries the **USDG** stablecoin and Robinhood's **tokenized stocks and ETFs**, and it hosts a dense cluster of meme-coin launchpads, led by **Pons**. Bitquery indexes the whole chain — blocks, transactions, internal calls, decoded events, token transfers, balances, DEX trades and pool liquidity — and serves it through one GraphQL endpoint where any query can run as a live WebSocket stream.
This page is the map. Use it to pick the cube that answers your question, then jump to the linked guide. The **[Pons Launchpad API](#pons)** has its own section below because it is the launchpad developers ask about most.
:::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/)
:::
---
## Robinhood Chain at a glance {#network-facts}
| Property | Value |
| --- | --- |
| Bitquery network name | `robinhood` in `EVM(network: robinhood)`; `bid:robinhood` in the `Trading` cubes |
| Chain ID | `4663` |
| Stack | EVM, Arbitrum Orbit rollup |
| Gas token | ETH |
| Public explorer | [robinhoodchain.blockscout.com](https://robinhoodchain.blockscout.com) — Bitquery is an indexed data API, not an explorer or an RPC node |
| WETH | `0x0bd7d308f8e1639fab988df18a8011f41eacad73` |
| USDG (Global Dollar, 6 decimals) | `0x5fc5360d0400a0fd4f2af552add042d716f1d168` |
| Uniswap v4 PoolManager | `0x8366a39cc670b4001a1121b8f6a443a643e40951` — the chain-wide v4 singleton that Pons and pools.trade pools route through |
| GraphQL endpoint | `https://streaming.bitquery.io/graphql` for queries and subscriptions |
---
## Quick start: stream every trade on Robinhood Chain {#quick-start}
The `Trading` cubes carry live swaps with USD prices for Robinhood Chain and eight other chains in one schema. Paste this into the [Bitquery IDE](https://ide.bitquery.io) to watch the network trade in real time:
```graphql
subscription {
Trading {
Trades(
where: {Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}}
) {
Block { Time }
Trader { Address }
Pair {
Token { Name Symbol Address }
QuoteToken { Name Symbol Address }
}
Amounts { Base Quote }
AmountsInUsd { Base }
}
}
}
```
Change `subscription` to `query`, add `limit: {count: 10}` and `orderBy: {descending: Block_Time}`, and the same selection set returns the latest trades instead. Prices, OHLCV candles, market cap, whale trades and top-trader leaderboards are on the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) page.
:::tip Trading cubes for live data, DEXTrades for deep history
`Trading.Trades` / `Tokens` / `Pairs` cover real-time plus roughly the last 30 days with USD pricing baked in. Use the chain-level `DEXTrades` cube for older history or when you need the call and event context around a swap. See the [Trading data overview](/docs/trading/trading-data-overview/).
:::
---
## Pick the right API {#pick-the-right-api}
| What you want | Use this | Guide |
| --- | --- | --- |
| Live swaps, USD prices, OHLCV, market cap, top traders | `Trading` cubes; `DEXTrades` for older history | [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) |
| New pools, trending tokens, pair lookup, token search | `Events` (`Initialize`, `PoolCreated`) and `Trading` cubes | [New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) |
| Every new token, across all launchpads | `Transfers` (launch mints) and `Events` | [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) |
| Pons launches, curve trades, graduations, liquidity lock | `Events`, `Calls`, `Trading` | [Pons Launchpad API](/docs/blockchain/robinhood/pons-api) |
| Who sent what to whom, whale alerts, wallet ledgers | `Transfers` | [Robinhood Transfers API](/docs/blockchain/robinhood/robinhood-transfers) |
| A wallet's portfolio and balance history | `Balances` | [Robinhood Balances API](/docs/blockchain/robinhood/robinhood-balances-api) |
| Holder rankings, counts and distribution | `Holders` | [Robinhood Token Holders API](/docs/blockchain/robinhood/robinhood-token-holders-api) |
| Total supply of a token or watchlist | `TransactionBalances` | [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply) |
| Pool reserves, TVL, per-swap slippage | `DEXPools` | [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity) |
| Any decoded contract event, an `eth_getLogs` replacement | `Events` | [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api) |
| Method calls, internal traces, contract deployments, reverts | `Calls` | [Robinhood Calls & Traces API](/docs/blockchain/robinhood/robinhood-calls-api) |
| Transactions, receipts, status, gas and fees | `Transactions` | [Robinhood Transactions & Receipts API](/docs/blockchain/robinhood/robinhood-transactions-receipts-api) |
| Perp margin deposits and withdrawals on Lighter | `Transfers`, `Events`, `Calls` | [Lighter Perp DEX API](/docs/blockchain/robinhood/lighter-perp-dex-api) |
---
## Pons Launchpad API on Robinhood Chain {#pons}
**[Pons](https://www.ponsfamily.com/launchpad)** (Pons Family) is the bonding-curve launchpad on Robinhood Chain. Every launch mints a fixed **1 billion** supply into its own curve contract. Traders buy and sell against that curve until it takes in its graduation threshold (**4.2 ETH** for native-quoted launches; a per-asset amount for other quotes), at which point the curve is swept, the proceeds seed a **Uniswap v4 pool behind the Pons meme hook**, and the liquidity position is **permanently locked**. A creator can quote a launch in **ETH, USDG, cbBTC, or a tokenized stock or ETF** such as TSLA, NVDA or SPY.
The [Pons Launchpad API guide](/docs/blockchain/robinhood/pons-api) covers the full lifecycle with runnable queries:
- **New launches** — the decoded `TokenLaunched` event, a `Calls`-based launch feed with full archive history, and the on-chain token metadata (name, symbol, image, description, socials). See [Newly launched tokens](/docs/blockchain/robinhood/pons-api#newly-launched-tokens) and [Token metadata](/docs/blockchain/robinhood/pons-api#token-metadata).
- **Bonding-curve trades** — `CurveBuy` and `CurveSell` events with snipe-tax fields, plus the same trades as `Protocol: pons_v2` rows in the `Trading` cube for USD prices and OHLCV. See [Bonding-curve trades](/docs/blockchain/robinhood/pons-api#bonding-curve-trades).
- **Graduations** — `LaunchSwept` and `PoolGraduated`, the graduated v4 pool, and how to find the Pons pool of one token without picking up copycat pools. See [Graduation](/docs/blockchain/robinhood/pons-api#graduation).
- **Locked liquidity** — verifying the lock in `PonsV2LaunchLocker`. See [Verifying the Pons liquidity lock](/docs/blockchain/robinhood/pons-api#liquidity-lock).
- **Contract addresses and event reference** — every factory, curve, hook, router and locker event with its topic0. See [Contract addresses](/docs/blockchain/robinhood/pons-api#contract-addresses) and [Event reference](/docs/blockchain/robinhood/pons-api#event-reference).
- **After graduation** — holders, supply, pool liquidity and slippage for graduated tokens. See [Holders and supply](/docs/blockchain/robinhood/pons-api#holders-and-supply).
| Pons V2 contract | Address |
| --- | --- |
| Launch factory (`PonsV2LaunchFactory`) | `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` |
| Launch router (`PonsV2LaunchAndBuy`) | `0xe33e9e479df8802cb0866d5d05258bec4cf62948` |
| Meme hook (`PonsV2MemeHook`), on every graduated pool | `0xe5e702641ea86f4ae6cc3cdaed2b886f976be044` |
| Launch locker (`PonsV2LaunchLocker`) | `0x267444d099b10fb5ed7c3cc7b7c767adca574952` |
| Bonding curve | one contract per token — the receiver of the launch mint |
Stream every new Pons launch as it happens:
```graphql
subscription {
EVM(network: robinhood) {
Calls(
where: {
Call: {
To: {in: [
"0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e",
"0xe33e9e479df8802cb0866d5d05258bec4cf62948"
]}
Input: {startsWith: ["0xf35abbcf", "0xa72101af", "0xf85f8e41"]}
Success: true
}
}
) {
Block { Time }
Transaction { Hash From }
Call { To Value Input Output }
}
}
}
```
`Transaction.From` is the creator, and the first two 32-byte words of `Call.Output` are the new token and its curve. The [guide](/docs/blockchain/robinhood/pons-api#newly-launched-tokens) explains the selectors, the decoding, and why `launchTokenFor` is deliberately left out of the filter.
:::caution Pons and pools.trade are opposites
Pons has a real bonding curve and a graduation event. [pools.trade](/docs/blockchain/robinhood/pools-trade-api) tokens trade in a Uniswap v4 pool from block one with no curve and no graduation. Queries written for one return nothing on the other — see [How Pons differs from pools.trade](/docs/blockchain/robinhood/pons-api#pons-vs-poolstrade).
:::
---
## Other launchpads on Robinhood Chain {#launchpads}
Robinhood Chain launchpads are **not interchangeable**. Each has its own factory contracts, its own event signatures, and a different relationship to the DEX it trades on. Four more have dedicated guides:
| Launchpad | Model | Guide |
| --- | --- | --- |
| **pools.trade** | Uniswap v4 pool from block one, no curve and no graduation event; Crowd Launch auctions | [Pools Trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api) |
| **Flap.sh** | Bonding curve with per-token tax and progress events, graduates to a DEX; emits a decoded `TokenCreated` | [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api) |
| **trench.today** | Bonding-curve launchpad run from a single factory proxy; `TokenCreate`, `TokenPurchase`, `TokenSale` and `Sync` events expose launches, trades and live curve reserves | [trench.today API on Robinhood](/docs/blockchain/robinhood/trench-today-api) |
| **Bags.fm** | Creator-fee launchpad | [Bags.fm API on Robinhood](/docs/blockchain/robinhood/bags-fm-api) |
For a **cross-launchpad feed** — every new token on the network regardless of which factory minted it — use the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches). It also carries per-launchpad launch queries for [hood.fun](/docs/blockchain/robinhood/robinhood-meme-coin-launches#hoodfun), [LaunchHood](/docs/blockchain/robinhood/robinhood-meme-coin-launches#launchhood), [Virtuals](/docs/blockchain/robinhood/robinhood-meme-coin-launches#virtuals), [Klik Finance](/docs/blockchain/robinhood/robinhood-meme-coin-launches#klik-finance), [Doppler](/docs/blockchain/robinhood/robinhood-meme-coin-launches#doppler-airlock) (the Airlock that Bankr and other front-ends launch through), [Ape.store](/docs/blockchain/robinhood/robinhood-meme-coin-launches#apestore) and [Clanker](/docs/blockchain/robinhood/robinhood-meme-coin-launches#clanker), and a query that [compares launch activity across launchpads](/docs/blockchain/robinhood/robinhood-meme-coin-launches#compare-launchpad-activity).
:::tip Feed for discovery, launchpad page for depth
The cross-launchpad feed answers *"what launched?"*. The per-launchpad guides answer *"what is this token doing?"* — curve trades, graduation progress, fee splits and pool state. Most production pipelines use the feed for discovery and one launchpad guide for depth.
:::
---
## Perpetual futures: Lighter on Robinhood Chain {#perps}
[Lighter](https://lighter.xyz) is the perp DEX behind in-app perpetuals in Robinhood Wallet. Its ZkLighter rollup contract lives on Robinhood Chain and receives every USDG margin deposit, pays every withdrawal, and records the rollup's batch lifecycle. The [Lighter Perp DEX API](/docs/blockchain/robinhood/lighter-perp-dex-api) shows how to track deposits, withdrawals, batch commits and the contract's flow history.
---
## Real-time streams: WebSocket, Kafka and MCP {#streaming}
- **WebSocket** — every query on every page above runs as a subscription: swap `query` for `subscription` and keep the same selection set. See [WebSocket subscriptions](/docs/subscriptions/websockets/) and [authorizing a WebSocket connection](/docs/authorization/websocket/).
- **Kafka** — for firehose-scale workloads, Robinhood Chain is published as protobuf topics: `robinhood.transactions.proto` (transactions, calls, events), `robinhood.tokens.proto` (transfers, balances), `robinhood.dextrades.proto` (DEX trades), `robinhood.dexpools.proto` (pool liquidity) and `robinhood.raw.proto` (raw blocks). See [Kafka streaming concepts](/docs/streams/kafka-streaming-concepts/) and the [streams overview](/docs/streams/).
- **MCP** — the [Bitquery MCP server](/docs/mcp/mcp-server/) exposes Robinhood Chain trades, prices and wallet history to AI agents alongside the other Trading-cube chains.
---
## Datasets and history {#datasets}
Robinhood Chain queries accept a `dataset` argument that decides how far back you can reach and how fresh the tail is.
- [`realtime`](/docs/graphql/dataset/realtime) — lowest latency, holds only the most recent days
- [`archive`](/docs/graphql/dataset/archive) — history back to when Bitquery started indexing Robinhood Chain, higher latency
- [`combined`](/docs/graphql/dataset/combined) — both, stitched
- [Data coverage and retention](/docs/graphql/data-coverage-retention) — what each window actually holds
Two rules of thumb. If a query works on recent data but returns nothing for older blocks, the dataset argument is almost always the reason. And a few cubes — `Transactions`, `DEXPools` and `TransactionBalances` — are realtime-only on Robinhood Chain; each guide's dataset section says what applies to it.
History is sold per chain. The free trial and paid self-service plans are real-time only; paid plans add history through the Robinhood archive add-on on the [pricing page](https://bitquery.io/pricing), which unlocks `archive` and `combined` on `DEXTrades`, `DEXTradeByTokens`, `Calls` and `Events`. A second add-on covers historical `Transfers`, `Balances` and `Holders`. The Pons guide's [historical data section](/docs/blockchain/robinhood/pons-api#historical-data) walks through it.
---
---
## Robinhood Chain New Pools & Trending Tokens API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-new-pools-trending/
Query new Uniswap pools, trending tokens, most active pools, pair lookups and token search on Robinhood Chain with Bitquery GraphQL and WebSocket streams.
# Robinhood Chain New Pools & Trending Tokens API
This page covers the four questions a token screener asks on **Robinhood Chain**: *what pools were just created*, *what is trading right now*, *what is this pair*, and *where is the token with this symbol*. Every answer is a GraphQL query you can run on your own key, page through, and convert to a WebSocket stream — no rate-limited third-party endpoint in between.
If you have been calling a public aggregator's Robinhood endpoints and hit their limits, coverage gaps, or delays, the table below maps each one to its Bitquery equivalent.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) — prices, OHLCV, market cap, top traders
- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity) — pool reserves, TVL and price impact
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) — new tokens by launchpad
- [Crypto Price API](/docs/trading/crypto-price-api/) — the `Trading` cubes in full
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## What you would call elsewhere {#endpoint-mapping}
| Screener endpoint | Bitquery equivalent | Section |
| --- | --- | --- |
| `networks/robinhood/new_pools` | `Initialize` and `PoolCreated` events on `EVM.Events` | [New pools](#new-pools) |
| `networks/robinhood/pools` | `Trading.Trades` grouped by `Pair.Pool.Address` | [Most active pools](#most-active-pools) |
| `networks/robinhood/trending_pools` | `Trading.Trades` over a 24-hour bound | [Trending tokens](#trending-tokens) |
| `dex/pairs/robinhood/{pool}` | `Trading.Trades` filtered on `Pair.Pool.Address`, or `Pair.Pool.Id` for Uniswap v4 | [Look up a pair](#pair-lookup) |
| `dex/search?q={text}` | `Trading.Trades` filtered on `Token.Symbol` / `Token.Name` | [Search for a token](#token-search) |
| Pool reserves and TVL | `EVM.DEXPoolEvents` | [Liquidity API](/docs/blockchain/robinhood/robinhood-liquidity) |
Two differences are worth knowing before you port a screener across. Bitquery returns **every pool on the chain**, including the thousands minted by launchpads each day, so most feeds want a filter rather than the raw firehose. And any query here becomes a live stream by swapping `query` for `subscription`, which removes the polling loop a REST screener forces on you.
---
## New pools {#new-pools}
Robinhood Chain creates pools through two paths, and a complete new-pool feed reads both.
### Uniswap v4 pools
Uniswap v4 keeps every pool inside one singleton, the **PoolManager** at `0x8366a39cc670b4001a1121b8f6a443a643e40951`, which emits `Initialize` for each new pool. This is the busiest path on the chain by a wide margin, because the launchpads graduate into it.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
Block: {Time: {since_relative: {hours_ago: 1}}}
}
) {
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_Bytes_Value_Arg { hex }
}
}
}
}
}
```
`Initialize` decodes into eight arguments: `id` (the v4 pool id), `currency0` and `currency1` (the pair, where `0x000…000` means native ETH), `fee`, `tickSpacing`, `hooks`, `sqrtPriceX96` and the opening `tick`.
The **`hooks` argument is the useful one for filtering**. It is `0x000…000` for a plain pool, and a protocol's own address when that protocol owns the pool — so a single `Arguments` filter isolates one launchpad's graduations:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
Arguments: {includes: {
Name: {is: "hooks"}
Value: {Address: {is: "0xe5e702641ea86f4ae6cc3cdaed2b886f976be044"}}
}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
That hook address is the [Pons](/docs/blockchain/robinhood/pons-api) meme hook, so the query returns Pons graduations only. Swap it for any other protocol's hook.
### Uniswap v3 and other factories
The older factory model emits `PoolCreated` from the factory contract itself. Several factories are live on Robinhood Chain, so filter by the event name and read `LogHeader.Address` to see which factory minted each pool.
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
Log: {Signature: {Name: {is: "PoolCreated"}}}
Block: {Time: {since_relative: {hours_ago: 6}}}
}
) {
Block { Time }
LogHeader { Address }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
`PoolCreated` gives `token0`, `token1`, `fee`, `tickSpacing` and the new `pool` address.
To see which factories are actually producing pools, group the same event by emitter:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 15}
orderBy: {descendingByField: "count"}
where: {
Log: {Signature: {Name: {is: "PoolCreated"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
LogHeader { Address }
count
}
}
}
```
The chain-wide Uniswap V3 factory `0x1f7d7550b1b028f7571e69a784071f0205fd2efa` dominates this list. It is **not** owned by any launchpad, so do not treat it as a protocol filter.
### Stream new pools
Both feeds work as subscriptions. This one pushes every new v4 pool as its block is indexed:
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
}
) {
Block { Time }
Transaction { Hash From }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
}
}
}
}
}
```
:::caution A raw new-pool feed is mostly launchpad noise
Thousands of pools are created on Robinhood Chain every day, and the overwhelming majority never attract a second trade. If you are building a watchlist rather than an archive, filter by `hooks`, or start from [trending tokens](#trending-tokens) and work backwards to the pool.
:::
---
## Trending tokens {#trending-tokens}
The `Trading` cubes carry swaps with USD pricing already attached, so a trending list is one aggregation over a time bound. Rank by **trade count and unique traders** rather than USD volume: thin pools can print enormous dollar figures from a single swap.
### Most traded tokens in the last 24 hours
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descendingByField: "trades"}
where: {
Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Pair {
Token { Symbol Name Address }
}
trades: count
traders: uniq(of: Trader_Address)
buys: count(if: {Side: {is: "Buy"}})
sells: count(if: {Side: {is: "Sell"}})
}
}
}
```
`Side` is the string `"Buy"` or `"Sell"`, so the two `count(if: …)` aggregates give you buy pressure alongside the raw count. Widen or narrow the window with `hours_ago`.
### Most active pools {#most-active-pools}
The same aggregation keyed on the pair answers "which pools are hot", which is what a trending-pools endpoint returns. Rows are grouped by the whole `Pair` selection, so Uniswap v4 pairs come back separately even though they share one `Pool.Address` — read `Pool.Id` to tell them apart:
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descendingByField: "trades"}
where: {
Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Pair {
Pool { Address Id }
Token { Symbol Address }
QuoteToken { Symbol }
Market { Protocol }
}
trades: count
traders: uniq(of: Trader_Address)
}
}
}
```
### Where trading happens
Grouping by protocol shows how the chain's activity is split, and how many distinct pools each venue is running:
```graphql
{
Trading {
Trades(
limit: {count: 15}
orderBy: {descendingByField: "trades"}
where: {
Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Pair { Market { Protocol ProtocolFamily } }
trades: count
traders: uniq(of: Trader_Address)
}
}
}
```
Uniswap v3 and v4 carry most of the trades on the chain. The bonding-curve launchpads sit at the other end of the shape: they mint one pool per launched token, so they run far more pools than the AMMs while averaging a small fraction of the trades on each.
:::caution Do not count pools with `uniq(of: Pair_Pool_Address)`
No single field counts pools correctly across venues, which is why the query above does not try. Uniswap v4 keeps every pool inside one singleton contract, so **all v4 pairs report the same `Pool.Address`** and that aggregate collapses them to `1`. The reverse is true of `Pool.Id`, which only v4-style venues populate. Count pools within one protocol at a time, using `Pool.Id` for Uniswap v4 and PancakeSwap Infinity and `Pool.Address` for everything else.
:::
---
## Look up a pair {#pair-lookup}
Given a pool address, return its recent trades with both sides of the pair, the venue, and price in the quote asset and in USD. This works for pools that have their own contract — Uniswap v2 and v3, PancakeSwap v3, and the bonding-curve launchpads. **Uniswap v4 needs `Pool.Id` instead**, covered right below.
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
Pair: {
Market: {NetworkBid: {is: "bid:robinhood"}}
Pool: {Address: {is: "0xbbaefcfcd7b92ed0df1a3eec22a21ba6beb0b52b"}}
}
}
) {
Block { Time }
Pair {
Token { Symbol Name Address }
QuoteToken { Symbol Address }
Market { Protocol }
Pool { Address Id }
}
Price
PriceInUsd
Amounts { Base Quote }
AmountsInUsd { Base }
Side
Trader { Address }
TransactionHeader { Hash }
}
}
}
```
`Price` and `PriceInUsd` are plain numbers on this cube, not nested objects. For candles, market cap and supply on the same pair, see the [Trades API](/docs/blockchain/robinhood/robinhood-trades); for reserves and price impact, see the [Liquidity API](/docs/blockchain/robinhood/robinhood-liquidity).
### Uniswap v4 pairs: look up by pool id {#v4-pool-id}
Uniswap v4 has no per-pool contract. Every v4 pool lives inside the PoolManager singleton, so **`Pool.Address` is `0x8366a39cc670b4001a1121b8f6a443a643e40951` on every v4 pair** and filtering on it returns the whole venue rather than one pair. The per-pool identifier is `Pool.Id`, the 32-byte v4 pool id:
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
Pair: {
Market: {NetworkBid: {is: "bid:robinhood"}}
Pool: {Id: {is: "0x7fb39eb653999feb9f0d3b1410848911383dfc681f3585229df4aa5b560bf0ba"}}
}
}
) {
Block { Time }
Pair {
Token { Symbol Name Address }
QuoteToken { Symbol }
Market { Protocol }
Pool { Id }
}
Price
PriceInUsd
Side
Trader { Address }
}
}
}
```
This is the same value the `Initialize` event carries in its `id` argument, so a pool you picked up from the [new-pool feed](#new-pools) can be handed straight to this query — add the `0x` prefix, which the event argument omits. If you only have a token address, filter on `Pair.Token.Address` instead and read `Pool.Id` off the result.
### Newly listed tokens
Sorting ascending inside a recent window gives the first trades to arrive — tokens that just started trading, with the pool and venue they landed on:
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {ascending: Block_Time}
where: {
Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}
Block: {Time: {since_relative: {hours_ago: 2}}}
}
) {
Block { Time }
Pair {
Token { Symbol Name Address }
QuoteToken { Symbol }
Market { Protocol }
Pool { Address }
}
}
}
}
```
:::note This is "first trade in the window", not "first trade ever"
The `Trading` cubes hold a rolling window of roughly the last 30 days. Ascending order inside that window returns the oldest rows it still holds, so for a token older than the window you get its oldest *retained* trade. To pin a real launch time, find the mint on the [Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) or the launchpad's own guide.
:::
---
## Search for a token {#token-search}
### By symbol
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descendingByField: "trades"}
where: {
Pair: {
Market: {NetworkBid: {is: "bid:robinhood"}}
Token: {Symbol: {includesCaseInsensitive: "cat"}}
}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Pair { Token { Symbol Name Address } }
trades: count
traders: uniq(of: Trader_Address)
}
}
}
```
### By name
```graphql
{
Trading {
Trades(
limit: {count: 25}
orderBy: {descendingByField: "trades"}
where: {
Pair: {
Market: {NetworkBid: {is: "bid:robinhood"}}
Token: {Name: {includesCaseInsensitive: "gamestop"}}
}
Block: {Time: {since_relative: {hours_ago: 24}}}
}
) {
Pair { Token { Symbol Name Address } }
trades: count
}
}
}
```
:::caution Symbols and names are not unique
Anyone can deploy a token called `GME`. A name search on Robinhood Chain returns the tokenized stock alongside look-alikes, and ordering by trade count is what separates them — the real one is usually far ahead. Always resolve to a **contract address** before you quote a price, and never treat a symbol match as identity.
:::
---
## Datasets and windows {#datasets}
| Data | Where it lives | Reach |
| --- | --- | --- |
| New pools (`Initialize`, `PoolCreated`) | `EVM.Events` | `realtime` holds the most recent days; add `dataset: combined` or `archive` for history |
| Trending, pair lookup, search | `Trading` cubes | A rolling window of roughly the last 30 days; takes no `dataset` argument |
| Pool reserves and TVL | `EVM.DEXPoolEvents` | **Realtime only** on Robinhood Chain — see the [Liquidity API](/docs/blockchain/robinhood/robinhood-liquidity) |
The most common surprise is an event query that works for today and returns nothing for last month: that is the default `realtime` dataset, and `dataset: combined` fixes it. See [data coverage and retention](/docs/graphql/data-coverage-retention).
---
## FAQ {#faq}
### How do I get new pools on Robinhood Chain without a third-party API?
Read `Initialize` from the Uniswap v4 PoolManager and `PoolCreated` from the v3 factories, both on `EVM.Events`. Run them as subscriptions and you have a push feed instead of a polling loop. See [New pools](#new-pools).
### Why does my new-pool feed return thousands of pools an hour?
Because it is complete. Robinhood Chain launchpads mint pools continuously and most never trade again. Filter by the `hooks` argument on v4, or build your list from [trending tokens](#trending-tokens) instead.
### How do I find trending tokens or pairs?
Aggregate `Trading.Trades` over a `Block.Time` bound, ranked by `count` and `uniq(of: Trader_Address)`. Rank by trade count rather than USD volume, since thin pools distort dollar figures.
### How do I look up a pair by pool address?
Filter `Trading.Trades` on `Pair.Pool.Address`. That returns both sides of the pair, the venue, the price in quote and USD terms, and the trader. **Uniswap v4 is the exception**: all its pools share the PoolManager address, so filter `Pair.Pool.Id` instead. See [Look up a pair](#pair-lookup) and [Uniswap v4 pairs](#v4-pool-id).
### Can I search tokens by symbol or name?
Yes, with `includesCaseInsensitive` on `Token.Symbol` or `Token.Name`. Symbols are not unique on-chain, so rank by trade count and resolve to a contract address before trusting a match.
### Does this cover pool liquidity and TVL?
Not on this page. Reserves, depth and per-swap slippage live in the [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity), which uses the `DEXPools` cubes.
---
## Next steps
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) — prices, OHLCV candles, market cap and top traders
- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity) — reserves, TVL and price impact
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) — new tokens by launchpad
- [Pons Launchpad API](/docs/blockchain/robinhood/pons-api) — the launchpad behind most v4 graduations
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — the full cube map
- [WebSocket subscriptions](/docs/subscriptions/websockets/) — turn any query above into a stream
---
## Robinhood Events API & WebSocket Streams
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-events-api/
Stream every Robinhood smart contract event over GraphQL WebSockets — decoded logs, topics, call & receipt context. A no-node alternative to eth_getLogs.
# Robinhood Events API & WebSocket Streams
Stream **every smart contract event on Robinhood** with Bitquery GraphQL — decoded arguments, raw topics, and the emitting transaction, call, and receipt joined into one record. The `EVM.Events` cube on `network: robinhood` is a drop-in **alternative to running your own node**: no RPC infrastructure, no log-decoding pipeline, no ABI management for known signatures.
Open **one WebSocket that listens to everything**, or **hundreds of narrowly filtered sockets** — per contract, per event signature, per raw topic hash, even per decoded argument value. Every subscription on this page was verified live over WebSocket, and every query was executed against the production endpoint before publishing.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [EVM Events schema](/docs/schema/evm/events/)
- [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/)
- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/)
- [Robinhood Liquidity & Slippage API](/docs/blockchain/robinhood/robinhood-liquidity/)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches/)
- [WebSocket authentication](/docs/authorization/websocket/)
:::
**On this page:** [Why not a node](#why-stream-events-instead-of-running-a-node) · [Datasets & history](#datasets-and-history) · [Event anatomy](#what-one-event-row-contains) · [Firehose](#stream-all-events-firehose) · [By contract](#stream-events-from-one-contract) · [By signature](#stream-one-event-across-all-contracts) · [By topic0](#stream-by-raw-topic0-signature-hash) · [By argument](#watch-an-address-across-all-decoded-arguments) · [By wallet](#events-from-a-wallets-transactions) · [Historical queries](#latest-events-query) · [Use cases](#use-case-patterns) · [FAQ](#faq)
---
## Why stream events instead of running a node
| | Your own node (`eth_subscribe` / `eth_getLogs`) | Bitquery Events stream |
| --- | --- | --- |
| Infrastructure | Run and sync a Robinhood node, manage reconnects and reorgs | One WebSocket to `streaming.bitquery.io` |
| Decoding | Raw topics + data; you maintain ABIs and decoders | `Arguments` arrive **decoded and typed** for known signatures; raw `Topics` always included |
| Context | Logs only — separate calls for tx, trace, receipt | Transaction, internal `Call`, and `Receipt` joined onto every event |
| Filtering | Address + topics only | Address, signature name, signature hash, **decoded argument values**, tx sender, time — server-side |
| Backfill | Separate `eth_getLogs` pagination logic | Same query with `dataset: archive` / `combined` |
| Scale | One node, you shard consumers | One firehose socket or hundreds of filtered sockets |
If you are migrating node code: your `eth_getLogs` `address` filter maps to `LogHeader.Address`, and `topics[0]` maps to `Log.Signature.SignatureHash`.
---
## Datasets and history
- **`realtime`** (the default) — a rolling window of recent blocks whose depth varies; don't assume it, measure it with the probe below.
- **`archive`** — deep event history, retained up to roughly the **last 3 months** (Robinhood is a newer chain, so today the archive holds its complete history; older data ages out as the cap applies); its head lags the chain by minutes.
- **`combined`** — archive + realtime union; the safe choice for fixed windows (24h, 7d).
Need bulk history beyond what you want to page through the API? Bitquery can also provide **historical data exports** — [contact support](https://bitquery.io/forms/api).
### Check the events window
Run this against `realtime` (or `archive`) to see exactly what the dataset currently holds:
```graphql
{
EVM(network: robinhood) {
Events {
count
earliest: Block { Time(minimum: Block_Time) }
latest: Block { Time(maximum: Block_Time) }
}
}
}
```
---
## What one event row contains
| Group | What it gives you |
| --- | --- |
| **`Log`** | Emitting context: `SmartContract`, log `Index`, and the `Signature` (`Name`, full `Signature`, `SignatureHash`, `Parsed`) |
| **`Topics`** | The raw indexed topics (`Hash` array — topic0 is the event signature hash) |
| **`Arguments`** | Decoded, typed argument values (`address`, `bigInteger`, `string`, `hex`, `bool`, `integer`) with names |
| **`Transaction`** | Hash, `From`/`To`, value, full gas and fee fields (incl. USD) |
| **`Call`** | The internal call that emitted the log: call path, signature, gas, revert/error flags |
| **`Receipt`** | `GasUsed`, `CumulativeGasUsed`, deployed `ContractAddress`, receipt `Type` |
| **`Block`** | `Number`, `Time`, `Nonce` |
:::info LogHeader.Address vs Log.SmartContract
`LogHeader.Address` is the **emitting address** — the `address` field a node would return in `eth_getLogs`. `Log.SmartContract` is the **code that produced the log**, which differs behind proxies: several major Robinhood tokens (WETH, USDG) emit through proxy addresses backed by separate implementation contracts. Filter `LogHeader.Address` to watch a deployed address; read `Log.SmartContract` to group proxies that share one implementation.
:::
Hash fields (`SignatureHash`, `Topics.Hash`) are hex strings **without** a `0x` prefix.
---
## Stream all events (firehose)
One socket, every event on the chain, with the full record — decoded arguments, raw topics, transaction, call, and receipt. Events arrive in per-block batches.
:::warning High volume
The unfiltered firehose delivers every event on a busy chain — great for exploration and building your own indexer, heavy for everything else. Use the filtered streams below in production.
:::
```graphql
subscription {
EVM(network: robinhood) {
Events {
Block {
Number
Time
Nonce
}
Call {
CallPath
InternalCalls
From
To
Signature {
Name
Parsed
Signature
SignatureHash
SignatureType
}
CallerIndex
Create
Delegated
Error
Gas
GasUsed
Index
Reverted
SelfDestruct
Success
Value
ValueInUSD
}
Topics {
Hash
}
Receipt {
CumulativeGasUsed
ContractAddress
Type
GasUsed
}
Transaction {
From
To
Type
Cost
CostInUSD
Gas
GasFeeCap
GasFeeCapInUSD
GasPriceInUSD
GasPrice
GasTipCapInUSD
GasTipCap
Hash
Value
ValueInUSD
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
Log {
Signature {
Name
Abi
Parsed
Signature
SignatureHash
SignatureType
}
SmartContract
EnterIndex
ExitIndex
Index
LogAfterCallIndex
Pc
}
}
}
}
```
:::tip WebSocket connection
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/). Any subscription on this page also runs as a query — add `limit` and `orderBy` and drop the `subscription` keyword.
:::
:::tip Prefer Kafka for the firehose
Consuming the full event feed continuously? Bitquery also delivers Robinhood data as **Kafka streams** — decoded transactions, calls, and events on the protobuf topic `robinhood.transactions.proto` — with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## Stream events from one contract
**Protocol monitoring:** everything a single deployed address emits — the streaming equivalent of an `eth_getLogs` address filter. Example: WETH.
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: { LogHeader: { Address: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" } } }
) {
Block {
Time
}
Transaction {
Hash
}
Log {
Signature {
Name
}
SmartContract
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
### Multiple contracts, one socket
Watch a whole list of contracts with `Address.in` — one socket per protocol instead of one per contract.
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: {
Address: {
in: [
"0x0bd7d308f8e1639fab988df18a8011f41eacad73"
"0x5fc5360d0400a0fd4f2af552add042d716f1d168"
]
}
}
}
) {
Block {
Time
}
Log {
Signature {
Name
}
SmartContract
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
---
## Stream one event across all contracts
**Network-wide feeds:** filter by decoded signature name to receive one event type from **every** contract — for example, every ERC-20 `Transfer` on Robinhood in a single socket (the backbone of a token indexer). Works the same for `Swap`, `Approval`, `OwnershipTransferred`, or any launchpad event (see [Flap.sh](/docs/blockchain/robinhood/flap-sh-api/) and [Bags.fm](/docs/blockchain/robinhood/bags-fm-api/) for protocol-specific examples).
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: { Log: { Signature: { Name: { is: "Transfer" } } } }
) {
Block {
Time
}
Log {
SmartContract
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
:::note Names can collide
Different ABIs reuse the same event name — Robinhood carries more than one distinct `Swap` signature, for instance. A name filter catches all variants; pin one exact ABI with the [signature-hash filter](#stream-by-raw-topic0-signature-hash) below.
:::
---
## Stream by raw topic0 (signature hash)
Filter on `Log.Signature.SignatureHash` — the keccak of the event signature, i.e. `topics[0]` — **without the `0x` prefix**. This pins one exact ABI variant, and it also works for **undecoded events**: rows where `Signature.Name` is empty and `Parsed` is `false` still carry their hash and raw `Topics`, so no log on the chain is out of reach.
Example: the canonical ERC-20 `Transfer(address,address,uint256)` topic0.
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
Log: {
Signature: {
SignatureHash: {
is: "ddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
}
}
}
}
) {
Block {
Time
}
Log {
Signature {
Name
SignatureHash
}
SmartContract
}
Topics {
Hash
}
}
}
}
```
---
## Watch an address across all decoded arguments
**Wallet / token surveillance:** match events where **any decoded argument** equals an address — transfers in or out, approvals, swaps, or protocol events mentioning it, in one stream, regardless of event type or contract. This is a filter a raw node cannot do server-side.
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
Arguments: {
includes: {
Value: { Address: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } }
}
}
}
) {
Block {
Time
}
Log {
Signature {
Name
}
SmartContract
}
Transaction {
Hash
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Add `Name: { is: "token" }` (or any argument name) inside `includes` to match a specific argument instead of any position. As a historical query, argument matching scans widely — combine it with a `Block.Time` window or a contract filter for speed.
---
## Events from a wallet's transactions
Everything emitted by transactions **sent** by one address — a debugging and bot-monitoring view (which pools did my router touch, which events did my deployment emit).
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: { Transaction: { From: { is: "0xcaf681a66d020601342297493863e78c959e5cb2" } } }
) {
Block {
Time
}
Transaction {
Hash
}
Log {
Signature {
Name
}
SmartContract
}
}
}
}
```
Rows appear only while the wallet is actively sending transactions — swap in any sender you care about.
---
## Latest events query
The query counterpart of the firehose: page through recent events, newest first.
```graphql
{
EVM(network: robinhood) {
Events(limit: { count: 10 }, orderBy: { descending: Block_Time }) {
Block {
Number
Time
}
Transaction {
Hash
From
To
}
Log {
Signature {
Name
SignatureHash
}
SmartContract
Index
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
---
## All events in one transaction
**Forensics / debugging:** decompose a transaction into its ordered event log. A DEX swap, for example, unrolls into its `Transfer`s, pool `Sync`/`Swap` events, and any protocol hooks — with decoded arguments for each.
```graphql
{
EVM(network: robinhood, dataset: archive) {
Events(
orderBy: { ascending: Log_Index }
where: {
Transaction: {
Hash: {
is: "0xdb0f8aed6d900da3751670f311dbb8a7ae3f44022d15eff2b72a5d0863a1750f"
}
}
}
) {
Log {
Index
Signature {
Name
}
SmartContract
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
---
## Top event signatures
**Discovery:** which events dominate the chain right now — grouped by signature with counts. Rows with an empty `Name` are undecoded signatures; their `SignatureHash` still identifies them.
```graphql
{
EVM(network: robinhood) {
Events(limit: { count: 15 }, orderBy: { descendingByField: "count" }) {
Log {
Signature {
Name
SignatureHash
}
}
count
}
}
}
```
---
## Most active event emitters
Which contracts emit the most events over a window, and how many distinct signatures each uses — a fast map of what's hot on chain.
```graphql
{
EVM(network: robinhood) {
Events(
limit: { count: 10 }
orderBy: { descendingByField: "count" }
where: { Block: { Time: { since_relative: { hours_ago: 1 } } } }
) {
Log {
SmartContract
}
count
signatures: count(distinct: Log_Signature_SignatureHash)
}
}
}
```
---
## Event volume in a time window
One-row stats for dashboards: total events and distinct emitting contracts. Use `dataset: combined` when the window must be complete regardless of the realtime depth.
```graphql
{
EVM(network: robinhood) {
Events(where: { Block: { Time: { since_relative: { hours_ago: 1 } } } }) {
count
contracts: count(distinct: Log_SmartContract)
}
}
}
```
---
## Use-case patterns
| Goal | Approach |
| --- | --- |
| Token indexer without a node | Stream `Signature.Name: "Transfer"` (or pin the [topic0 hash](#stream-by-raw-topic0-signature-hash)); backfill with the same query on `dataset: archive` |
| DEX analytics | Stream `Swap` by signature hash per ABI variant; join context from `Transaction` / `Call` |
| Launchpad detection | Creation events per protocol — see [Meme Coin Launches](/docs/blockchain/robinhood/robinhood-meme-coin-launches/), [Flap.sh](/docs/blockchain/robinhood/flap-sh-api/), [Bags.fm](/docs/blockchain/robinhood/bags-fm-api/) |
| Pool reserve / price state | Purpose-built cubes are easier — [DEXPoolEvents](/docs/blockchain/robinhood/robinhood-liquidity/) |
| Wallet / compliance watch | [Argument address filter](#watch-an-address-across-all-decoded-arguments) — one stream, every event type |
| Protocol ops & alerting | [Contract filter](#stream-events-from-one-contract) on your deployments; alert on `OwnershipTransferred`, role changes, pauses |
| Incident forensics | [Per-transaction event log](#all-events-in-one-transaction), plus `Call.Reverted` / `Receipt` context |
| Chain discovery | [Top signatures](#top-event-signatures) and [top emitters](#most-active-event-emitters) |
---
## Tips
1. **Filter production streams.** The firehose is for exploration and full indexers; per-contract, per-signature, and per-hash sockets are cheap — open as many as you need, or multiplex several subscriptions over one WebSocket connection.
2. `LogHeader.Address` = emitting address (node-style filter); `Log.SmartContract` = the code behind it — they differ for proxy contracts.
3. Hash fields have **no `0x` prefix** — `SignatureHash` and `Topics.Hash` are bare hex.
4. Event **names collide across ABIs** (multiple `Swap` variants exist) — filter by `SignatureHash` when exact ABI identity matters.
5. Undecoded events (`Name: ""`, `Parsed: false`) are still delivered and filterable by hash — nothing on chain is invisible.
6. Realtime depth varies — measure it with the [window probe](#check-the-events-window); use `combined` for fixed windows and `archive` for full history (its head lags the chain by minutes).
7. Decoded-argument filters scan broadly as historical queries — scope them with a time window or contract filter; as subscriptions they are cheap.
8. For bulk backfills beyond API paging, ask Bitquery about [historical data exports](https://bitquery.io/forms/api).
---
## FAQ
### Can I listen to Robinhood contract events without running a node?
Yes — that is this API's core use. A GraphQL `subscription` on `EVM(network: robinhood) { Events }` over WebSocket replaces `eth_subscribe("logs")`, with decoded arguments and joined transaction/call/receipt context that a node doesn't provide. Backfill uses the same query with `dataset: archive`.
### Should I open one WebSocket or many?
Both work. One firehose socket can feed your own router, or you can open a separate narrowly-filtered subscription per contract, signature, or address — hundreds of concurrent filtered sockets are a supported pattern, and several subscriptions can also share one connection.
### Are event arguments decoded?
Yes — `Arguments` returns named, typed values (`address`, `bigInteger`, `string`, `hex`, `bool`, `integer`) for known signatures. Unknown signatures still stream with raw `Topics` and their `SignatureHash`.
### How do I filter by raw topic0?
Use `Log.Signature.SignatureHash` with the keccak hash of the event signature, **without** the `0x` prefix — see [the topic0 stream](#stream-by-raw-topic0-signature-hash).
### How far back does Robinhood events data go?
`archive` retains up to roughly the last 3 months of events (on a newer chain like Robinhood that is currently its complete history), and `realtime` holds a rolling recent window — measure either with the [window probe](#check-the-events-window). For older or bulk history, Bitquery can provide data exports on request.
### How do I get every event a specific transaction emitted?
Filter `Transaction.Hash` and order by `Log_Index` — see [All events in one transaction](#all-events-in-one-transaction).
### Which cube should I use — Events, Transfers, or Calls?
`Events` is the decoded-log firehose. For token movements specifically, [Transfers](/docs/blockchain/robinhood/robinhood-transfers/) is pre-modeled with USD enrichment; for pool state, use [DEXPoolEvents](/docs/blockchain/robinhood/robinhood-liquidity/). See [Transfers vs Events vs Calls](/docs/start/mental-model-transfers-events-calls/).
---
## Robinhood Liquidity & Slippage API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-liquidity/
Query & stream Robinhood DEX pool liquidity, TVL, and slippage with Bitquery GraphQL: Uniswap V2/V3/V4 and PancakeSwap reserves, depth, and price impact.
# 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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [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 typical row reads:
| 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) |
| `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)
▶️ Runnable IDE examples: [new Uniswap v4 pools](https://ide.bitquery.io/uniswap-v4-pools-on-robinhood-chain) and [v4 hooks in use](https://ide.bitquery.io/uniswap-v4-hooks-robinhood-chain)
```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. 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
{
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
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.
:::
---
## 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: **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
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) } }
}
}
}
```
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) } }
}
}
}
```
The realtime window only reaches back a limited time — 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`). See [WebSocket authentication](/docs/authorization/websocket/).
:::
:::tip Prefer Kafka for the firehose
Consuming pool updates at firehose scale? Bitquery also delivers Robinhood DEX data as **Kafka streams** (protobuf topic `robinhood.dextrades.proto`) with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## 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
}
}
}
}
}
```
:::warning Degenerate pools report absurd depth
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
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.
```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 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 (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?
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.
---
## Robinhood Meme Coin Launches API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-meme-coin-launches/
New token launches across every Robinhood Chain launchpad — Flap.sh, Doppler, Virtuals, Clanker, Klik, Bags.fm — via mint-transfer and TokenCreated queries.
# Robinhood Meme Coin Launches API
Track **meme coin token launches on Robinhood** with Bitquery GraphQL APIs. This guide shows how to detect newly created tokens from popular Robinhood launchpads and bots — **hood.fun**, **LaunchHood**, **Virtuals**, **Flap.sh**, **Klik Finance**, **Doppler** (the Airlock that Bankr and other front-ends launch through), **Ape.store**, **Bags.fm**, and **Clanker** — using `EVM(network: robinhood)` Events and Transfers cubes.
:::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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) — bonding-curve launchpad, graduations, Uniswap v4 pools
- [Pools.trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api)
- [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api)
- [trench.today API on Robinhood](/docs/blockchain/robinhood/trench-today-api)
- [Bags.fm API on Robinhood](/docs/blockchain/robinhood/bags-fm-api)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
:::tip Stream the same query
For each launch query below, open the matching **WebSocket** IDE link to run it as a real-time GraphQL subscription over WebSocket. You can also convert a query to a stream in the IDE by changing the operation type to `subscription`.
:::
---
▶️ Cross-launchpad stream: [New tokens on Robinhood Chain, all launchpads](https://ide.bitquery.io/stream-new-tokens-robinhood-chain)
## How token launches are detected
Most Robinhood meme launch contracts mint tokens in a create transaction. You can detect those launches in two ways:
| Method | Cube | Pattern |
| --- | --- | --- |
| **Events** | `EVM.Events` | Filter `LogHeader.Address` to the launch contract; for Flap.sh, also filter `Log.Signature.Name: TokenCreated` |
| **Transfers** | `EVM.Transfers` | Mint from the zero address (`0x000…000`) to a receiver, with `Transaction.To` equal to the launch contract and a fixed launch mint `Amount` |
Zero-address sender (`0x0000000000000000000000000000000000000000`) marks a mint. Pairing that with the launchpad contract as `Transaction.To` scopes results to that protocol’s creations.
The fixed `Amount` in each transfer query is the **full initial token supply minted at launch** — `1000000000` (1 billion) for most launchpads and `100000000000` (100 billion) for Clanker. Filtering on this value isolates the launch mint from ordinary transfers, so adjust it if a protocol uses a different launch supply.
:::note Amounts are decimal-normalized
Bitquery's `Transfer.Amount` is already adjusted for the token's `Decimals`, so `1000000000` means 1 billion whole tokens — not the raw on-chain integer you'd see on a block explorer. Compare against the normalized value, not the raw one.
:::
:::note `AmountInUSD` is `0` on launch mints
On Robinhood, `Transfer.AmountInUSD` is populated only for native ETH transfers. A freshly minted token has no price, so every launch-mint row below shows `"AmountInUSD": "0"`; it is selected for consistency with other transfer queries, not because it carries a value here.
:::
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.
### Stream launches as they happen
Launches are the case where polling is worst: a query tells you what already launched, and by the time you re-run it the opportunity has moved. The same mint-transfer filter works as a subscription, so you get each launch pushed at block time.
```graphql
subscription NewRobinhoodLaunches {
EVM(network: robinhood) {
Transfers(
where: {
Transfer: { Sender: { is: "0x0000000000000000000000000000000000000000" } }
}
) {
Block {
Time
}
Transaction {
Hash
To
}
Transfer {
Receiver
Amount
Currency {
Name
Symbol
SmartContract
Decimals
}
}
}
}
}
```
This streams **every** mint on the chain. Narrow it the same way the queries below do — add `Transaction: { To: { is: "" } }` for one launchpad, and the launch-mint `Amount` if you want only the initial supply mint rather than every subsequent mint.
:::note Do not add `dataset:` to a subscription
Subscriptions always read the live stream. The `dataset: combined` tip above applies to queries reaching backwards, not to streams.
:::
:::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
Every transfer query on this page is **identical except two values**: the launchpad address in `Transaction.To` and the launch-mint `Amount`. To track a different launchpad, copy any transfer query below and swap in the address (and, for Clanker, the amount) from this table.
| Protocol | Contract → `Transaction.To` | Mint `Amount` | Queries |
| --- | --- | --- | --- |
| **hood.fun** | `0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c` | `1000000000` | [Transfers](https://ide.bitquery.io/hoodfun-newly-creaed-tokens) ([WS](https://ide.bitquery.io/hoodfun-newly-creaed-tokens---Websocket)) |
| **LaunchHood** | `0x62b33a039d289cbda50ebeb72fe4261449e61bcf` | `1000000000` | [Transfers](https://ide.bitquery.io/launchpad-newly-creaed-tokens) ([WS](https://ide.bitquery.io/launchpad-newly-creaed-tokens---Websocket)) |
| **Virtuals** | `0xd4ccbfa37e2f35611b3042e4096ad7a3459bd007` | _any_ (no fixed supply) | [Transfers](https://ide.bitquery.io/Virtuals-Newly-created-tokens) |
| **Flap.sh** | `0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09` | `1000000000` | [Events](https://ide.bitquery.io/All-events-from-Flapsh) · [TokenCreated](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-logs-TokenCreated) ([WS](https://ide.bitquery.io/Flap-sh-Newly-created-tokens-using-logs-TokenCreated---Websocket)) · [Transfers](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-transfer-data) ([WS](https://ide.bitquery.io/Flap-Sh-Newly-created-tokens-using-transfer-data---Websocket)) |
| **Klik Finance** | `0x16cf6788b762ee8969744586ed16fc5705140dd7` | `1000000000` | [Transfers](https://ide.bitquery.io/Klik-Finance-Newly-created-tokens-using-transfers) ([WS](https://ide.bitquery.io/Klik-Finance-Newly-created-tokens-using-transfers-websocket)) |
| **Doppler Airlock** (Bankr, Long.xyz and other front-ends) | `0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862` (Airlock) · `0x22e99278308b393ea1260859b181ad7e78f5eeed` (launcher most front-ends call) | `1000000000` | [Transfers](https://ide.bitquery.io/Bankr-Bot-Newly-created-tokens) ([WS](https://ide.bitquery.io/Bankr-Bot-Newly-created-tokens---Websocket)) |
| **Ape.store** | `0x6e4910ea5a04376032f6564da9a9e4e88b7a87c1` | `1000000000` | [Transfers](https://ide.bitquery.io/Apestore-Newly-created-tokens) ([WS](https://ide.bitquery.io/Apestore-Newly-created-tokens---Websocket)) |
| **Bags.fm** | `0xe8cc4431adf8b5a847c113ef0c6af9043219cb37` | `1000000000` | [Transfers](https://ide.bitquery.io/Bagsfm-Newly-created-tokens) ([WS](https://ide.bitquery.io/Bagsfm-Newly-created-tokens---Websocket)) |
| **Clanker** | `0xd3f2cc1731b7fd17f28798835c2e02f0a1839a94` | `100000000000` | [Transfers](https://ide.bitquery.io/Clanker-Newly-created-tokens) ([WS](https://ide.bitquery.io/Clanker-Newly-created-tokens---Websocket)) |
| **Pons V2** | `0x7ed598bcef8bd9edd8c97a195c6d13f40801ec7e` (factory) · `0xe33e9e479df8802cb0866d5d05258bec4cf62948` (router) | `1000000000` | [Pons Launchpad API](/docs/blockchain/robinhood/pons-api) |
| **pools.trade** | `0x0000ffffbe8efe702c8703ae3477ff5de3d319c0` · `0x00004c4ccc709ef590f7c81102c0689f0263d4e9` (entry contracts) | `1000000000` | [Pools.trade API](/docs/blockchain/robinhood/pools-trade-api) |
| **trench.today** | `0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d` (factory proxy) | see guide | [trench.today API](/docs/blockchain/robinhood/trench-today-api) |
_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/)** was one of the first fair-launch memecoin launchpads 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. Older generations' launch history sits outside the realtime window, so query them with `dataset: combined` or `archive`.
:::
### hood.fun Newly created tokens
:::caution hood.fun has stopped launching
hood.fun has produced no launch since mid-July 2026, so on the default realtime dataset this query returns nothing. It is pinned to `dataset: archive` below to return the historical launches; re-check realtime before assuming the launchpad is gone for good.
:::
▶️ [Run in IDE](https://ide.bitquery.io/hoodfun-newly-creaed-tokens) · [WebSocket stream](https://ide.bitquery.io/hoodfun-newly-creaed-tokens---Websocket)
```graphql
{
EVM(network: robinhood, dataset: archive) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x5fcc1df0dc020cf454e742e9a8ae2554c37a452c"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## LaunchHood
**[LaunchHood](https://launchhood.com/)** is a memecoin launchpad on the Robinhood network where every coin lists directly on Uniswap at creation, with a fixed **1 billion** supply. Detect new LaunchHood tokens as mint transfers from the zero address where `Transaction.To` is the LaunchHood factory contract.
### LaunchHood Newly created tokens
:::caution LaunchHood has stopped launching
LaunchHood has produced no launch since mid-August 2026, so on the default realtime dataset this query returns nothing. It is pinned to `dataset: archive` below to return the historical launches.
:::
▶️ [Run in IDE](https://ide.bitquery.io/launchpad-newly-creaed-tokens) · [WebSocket stream](https://ide.bitquery.io/launchpad-newly-creaed-tokens---Websocket)
```graphql
{
EVM(network: robinhood, dataset: archive) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x62b33a039d289cbda50ebeb72fe4261449e61bcf"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Virtuals
**[Virtuals Protocol](https://virtuals.io/)** launches on Robinhood can be detected as mint transfers from the zero address where `Transaction.To` is the Virtuals contract. Unlike the other launchpads on this page, Virtuals tokens don't use a fixed launch supply, so this query omits the `Transfer.Amount` filter and matches on the zero-address mint alone.
### Virtuals Newly created tokens
▶️ [Run in IDE](https://ide.bitquery.io/Virtuals-Newly-created-tokens)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0xd4ccbfa37e2f35611b3042e4096ad7a3459bd007"}}
Transfer: {Sender: {is: "0x0000000000000000000000000000000000000000"}}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Flap.sh
Flap.sh launches on Robinhood can be monitored via contract events and mint transfers.
### All events from Flap.sh
List event signatures emitted by the Flap.sh contract to discover which logs are available for indexing.
▶️ [Run in IDE](https://ide.bitquery.io/All-events-from-Flapsh)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 100}
where: {LogHeader: {Address: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}}
) {
count
Log {
Signature {
Name
}
SmartContract
}
}
}
}
```
### Flap.sh Newly created tokens using logs (`TokenCreated`)
Filter Flap.sh `TokenCreated` events and decode argument values (token address, metadata fields, and related parameters).
▶️ [Run in IDE](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-logs-TokenCreated) · [WebSocket stream](https://ide.bitquery.io/Flap-sh-Newly-created-tokens-using-logs-TokenCreated---Websocket)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 10}
where: {
Log: {Signature: {Name: {is: "TokenCreated"}}}
LogHeader: {Address: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}
}
) {
Transaction {
Hash
From
To
}
Log {
Signature {
Name
}
SmartContract
}
Arguments {
Name
Value {
... on EVM_ABI_Integer_Value_Arg {
integer
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
... on EVM_ABI_Bytes_Value_Arg {
hex
}
... on EVM_ABI_Boolean_Value_Arg {
bool
}
}
}
}
}
}
```
### Flap.sh Newly created tokens using transfer data
Track Flap.sh mints as transfers from the zero address with amount `1000000000` in transactions sent to the Flap.sh contract.
▶️ [Run in IDE](https://ide.bitquery.io/Flapsh-Newly-created-tokens-using-transfer-data) · [WebSocket stream](https://ide.bitquery.io/Flap-Sh-Newly-created-tokens-using-transfer-data---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
Sample response
Each row is one newly launched token. `Transfer.Sender` is the zero address (the mint), `Transfer.Receiver` is the deployer/first holder, and `Currency.SmartContract` is the new token address.
```json
{
"EVM": {
"Transfers": [
{
"Block": { "Number": "12873456", "Time": "2026-07-15T11:42:08Z" },
"Transaction": {
"Hash": "0x9f2c...a41b",
"From": "0x39d83c23dbf34fa574b9afbb0c0e364bdfd97099",
"To": "0x26605f322f7ff986f381bb9a6e3f5dab0beaeb09"
},
"TransactionStatus": { "Success": true },
"Transfer": {
"Amount": "1000000000",
"AmountInUSD": "0",
"Sender": "0x0000000000000000000000000000000000000000",
"Receiver": "0x39d83c23dbf34fa574b9afbb0c0e364bdfd97099",
"Currency": {
"Name": "Example Meme",
"Symbol": "MEME",
"SmartContract": "0x9077841e155faaf4e4e89470822c2187eeef7777",
"Decimals": 18,
"Fungible": true,
"Native": false,
"ProtocolName": ""
}
}
}
]
}
}
```
---
## Klik Finance
Detect **[Klik Finance](https://klik.finance/)** token launches on Robinhood by filtering mint transfers where `Transaction.To` is the Klik Finance contract.
### Klik Finance Newly created tokens using transfers
▶️ [Run in IDE](https://ide.bitquery.io/Klik-Finance-Newly-created-tokens-using-transfers) · [WebSocket stream](https://ide.bitquery.io/Klik-Finance-Newly-created-tokens-using-transfers-websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x16cf6788b762ee8969744586ed16fc5705140dd7"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Doppler Airlock
`0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862` is the **Doppler Airlock**, the launch contract behind [Bankr](https://bankr.bot/), Long.xyz and other front-ends on Robinhood Chain, and one of the largest launch sources on the network. Its source is verified on the [chain explorer](https://robinhoodchain.blockscout.com/address/0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862) under the contract name `Airlock`. It emits `Create` for every launch and `Migrate` when a token moves to its final pool.
| Role | Address | Notes |
| --- | --- | --- |
| **Airlock** (launch contract) | `0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862` | Emits `Create`, `Migrate`, `Collect` |
| **Doppler hook / initializer** | `0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544` | Verified as `DopplerHookInitializer`. It is both the initializer named in every `Create` and the `hooks` address on the resulting Uniswap v4 pool, which makes it the filter for finding those pools |
| **LongLauncher** (front-end launcher) | `0x22e99278308b393ea1260859b181ad7e78f5eeed` | Verified as `LongLauncher`. Most launches are routed through it rather than sent to the Airlock directly |
Because most launches arrive through the launcher, **filter `Transaction.To` on both the Airlock and the launcher**; a filter on the Airlock alone misses the majority. Attribute a launch to a front-end by the launcher contract it came through, not by this page's label.
:::caution The `Create` event's argument **names** are wrong — read by position
The Airlock is indexed with the wrong ABI, so `Arguments.Name` returns names from an unrelated contract. The verified source declares:
```solidity
event Create(address asset, address indexed numeraire, address initializer, address poolOrHook);
```
Until the ABI is corrected, map the arguments by **`Arguments.Index`**:
| `Arguments.Index` | Name the API returns | What it actually is |
| --- | --- | --- |
| `0` | `caller` | **`numeraire`** — the quote asset the token launched against (USDG, GLD, NVDA and other tokenized stocks) |
| `1` | `token0` | **`asset`** — the newly launched token |
| `2` | `token1` | **`initializer`** — always `0x4e346895…`, the `DopplerHookInitializer` |
| `3` | `optionPair` | **`poolOrHook`** — duplicates the asset on every launch checked (120 of 120, and `LongLauncher` reports the same pair of values in its own event). The pool's actual hook is a separate contract, below |
The raw log confirms the shape: two topics (the signature plus one indexed argument) and three data words, so index `0` is the indexed `numeraire` from `topic1` and indexes `1`–`3` are the data words in order.
One more trap: an `Arguments: {includes: {Value: {Address: …}}}` filter matches an address in **any** position, so on its own it cannot prove a token was launched here — it also matches when your address was merely the quote asset. Tokenized stocks are common numeraires, so a popular one shows up against hundreds of launches it did not produce.
:::
### Finding a Doppler token's Uniswap v4 pool
Every Doppler launch opens a Uniswap v4 pool with a consistent shape: the **numeraire is `currency0`**, the **asset is `currency1`**, `hooks` is always the `DopplerHookInitializer`, and `fee` is `8388608` — Uniswap v4's dynamic-fee flag rather than a fixed rate. That makes the hook a clean filter for every Doppler pool on the chain:
```graphql
{
EVM(network: robinhood, dataset: combined) {
Events(
limit: {count: 25}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x8366a39cc670b4001a1121b8f6a443a643e40951"}}
Log: {Signature: {Name: {is: "Initialize"}}}
Arguments: {includes: {
Name: {is: "hooks"}
Value: {Address: {is: "0x4e3468951d49f2eea976ed0d6e75ffcb44a9a544"}}
}}
}
) {
Block { Time }
Transaction { Hash }
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg { address }
... on EVM_ABI_BigInt_Value_Arg { bigInteger }
... on EVM_ABI_Bytes_Value_Arg { hex }
}
}
}
}
}
```
The `id` argument is the v4 pool id, which the [New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending#v4-pool-id) uses to look a v4 pair up — v4 pools share one contract address, so the id is the only per-pool handle.
:::note `LaunchCreated` is richer, but not yet decoded
`LongLauncher` emits `LaunchCreated(poolOrHook, asset, numeraire, poolInitializer, launcher, tickerKey, deployedAt, reservedUntil, normalizedTicker)`, which carries the ticker string the Airlock's `Create` does not. That event is **not decoded** in the index today — it appears only under its topic0 `adc6f1f726f7c710…` with no argument names. Until it is decoded, use the Airlock's `Create`, or match the topic0 and decode the payload client-side.
:::
### Doppler newly created tokens
▶️ [Run in IDE](https://ide.bitquery.io/Bankr-Bot-Newly-created-tokens) · [WebSocket stream](https://ide.bitquery.io/Bankr-Bot-Newly-created-tokens---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {in: ["0xeb7c034704ef8dcd2d32324c1545f62fb4ad0862", "0x22e99278308b393ea1260859b181ad7e78f5eeed"]}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Ape.store
Monitor **[Ape.store](https://ape.store/)** meme coin launches on Robinhood with the same mint-transfer pattern.
### Ape.store Newly created tokens
▶️ [Run in IDE](https://ide.bitquery.io/Apestore-Newly-created-tokens) · [WebSocket stream](https://ide.bitquery.io/Apestore-Newly-created-tokens---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0x6e4910ea5a04376032f6564da9a9e4e88b7a87c1"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Bags.fm
Query **[Bags.fm](https://bags.fm/)** newly created tokens on Robinhood by mint amount and Bags.fm contract address.
### Bags.fm Newly created tokens
▶️ [Run in IDE](https://ide.bitquery.io/Bagsfm-Newly-created-tokens) · [WebSocket stream](https://ide.bitquery.io/Bagsfm-Newly-created-tokens---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0xe8cc4431adf8b5a847c113ef0c6af9043219cb37"}}
Transfer: {
Amount: {eq: "1000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## Clanker
Track **[Clanker](https://clanker.world/)** token launches on Robinhood. Clanker mints use amount `100000000000` (different from the `1000000000` used by the other launchpads above).
### Clanker Newly created tokens
▶️ [Run in IDE](https://ide.bitquery.io/Clanker-Newly-created-tokens) · [WebSocket stream](https://ide.bitquery.io/Clanker-Newly-created-tokens---Websocket)
```graphql
{
EVM(network: robinhood) {
Transfers(
orderBy: {descending: Block_Time}
limit: {count: 50}
where: {
Transaction: {To: {is: "0xd3f2cc1731b7fd17f28798835c2e02f0a1839a94"}}
Transfer: {
Amount: {eq: "100000000000"}
Sender: {is: "0x0000000000000000000000000000000000000000"}
}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
Decimals
Fungible
Native
ProtocolName
}
}
}
}
}
```
---
## FAQ
### How do I track new Robinhood meme coin launches in real time?
Open any **WebSocket** link in the [contract map](#launchpad-and-bot-contract-map) above, or take a launch query on this page and change its operation type from a query to a `subscription` in the Bitquery IDE. Each new launch is then pushed to your client as it is mined.
### Which launchpads and bots does this page cover?
Virtuals, Flap.sh, Klik Finance, the Doppler Airlock (Bankr and other front-ends), Ape.store, Bags.fm, and Clanker on the Robinhood network, plus hood.fun and LaunchHood for history. Pons, pools.trade and trench.today have their own guides. Each has its own contract address and mint amount listed in the contract map.
### How do I track a launchpad that isn't listed here?
Copy any transfer query on this page and replace the address in `Transaction.To` with the launchpad's contract. Keep the `Transfer.Sender` zero-address filter (it isolates mints) and set `Transfer.Amount` to that launchpad's initial mint supply.
### Why do the queries filter transfers by a fixed `Amount`?
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.
---
## Next steps
- Use the **WebSocket stream** links above (or switch the query to `subscription` in the IDE) for real-time launch alerts.
- Track a launchpad not listed here by swapping `Transaction.To` and `Amount` per the [contract map](#launchpad-and-bot-contract-map).
- Follow new tokens into markets with the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
- Inspect holder and wallet flows with [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers).
---
## Robinhood Token Holders API — Rankings & Distribution
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-token-holders-api/
Query Robinhood token holders with Bitquery GraphQL: top-holder rankings, holder counts, distribution stats, whale floors and dormancy screens.
# Robinhood Token Holders API — Rankings & Distribution
Query **token holders on Robinhood** with Bitquery's dedicated `EVM.Holders` cube — the token-centric view: who holds a token, ranked by balance, with per-holder change history (`FirstChangeTime`, `LastChangeTime`, `UpdateCount`) built in. One query replaces the transfer-indexing pipeline you would otherwise need, and it powers holder leaderboards, holder counts, distribution stats, whale floors, dormancy screens, and airdrop snapshots.
This is the API equivalent of the block explorer's token-holders tab (Blockscout's holders endpoint) with rankings, counts, distribution stats and history that you can query in bulk or stream.
For the wallet-centric view — one address's full portfolio — use the [Robinhood Balances API](/docs/blockchain/robinhood/robinhood-balances-api/) instead. Every query on this page was executed against the production endpoint before publishing.
:::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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Balances API](/docs/blockchain/robinhood/robinhood-balances-api/)
- [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/) (live movement between holders)
- [Robinhood Trades](/docs/blockchain/robinhood/robinhood-trades/) (prices to value holdings)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) (holder distribution on a bonding-curve launchpad)
:::
**On this page:** [Concepts](#cube-concepts) · [Top holders](#top-holders-of-a-token) · [Holder count](#holder-count-of-a-token) · [Whale floors](#holders-above-a-balance-floor) · [Distribution](#holder-distribution-statistics) · [Dormant holders](#dormant-holders-diamond-hands) · [Stock tokens](#tokenized-stock-holders-nvda) · [ETH rich list](#native-eth-rich-list) · [Pagination](#paginating-full-holder-snapshots) · [FAQ](#faq)
---
## Cube concepts
- **Rows are (holder, token) pairs**: `Holder.Address` plus a `Balance` with `Amount`, `FirstChangeTime`, `LastChangeTime`, and `UpdateCount`. Select `Currency` fields when you query across tokens.
- Use **`dataset: archive`** — holder tables are computed from full history.
- **No USD field on this cube** — threshold and rank by token `Amount` (USDG ≈ dollars); join prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/) to value holdings.
- **`Balance.LastChangeTime.till` filters by inactivity, not history**: a **future** date includes every holder (the current snapshot); a **past** date returns only wallets whose balance hasn't changed since then — with their frozen balances — which makes it a dormancy screen, not time travel.
- A plain `count` includes **everyone who ever held** (including now-zero balances). Add `Balance: { Amount: { gt: "0" } }` for **current** holders — the two numbers differ a lot on active tokens.
- The cube also accepts `Holder.Address` filters for wallet-side lookups, but portfolios are better served by the [Balances API](/docs/blockchain/robinhood/robinhood-balances-api/).
---
## Top holders of a token
The holder leaderboard — ranked by balance, with each holder's history stats. Example: USDG. A far-future `LastChangeTime.till` (here 2099) explicitly includes all holders (see [concepts](#cube-concepts)); tighten it to screen for dormancy.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Balance: { LastChangeTime: { till: "2099-12-31T23:59:59Z" } }
}
limit: { count: 100 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
## Holder count of a token
One number per question: how many wallets **currently** hold the token (with the `gt: "0"` filter), or how many **ever** held it (without).
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Balance: { Amount: { gt: "0" } }
}
) {
holders: count
}
}
}
```
Drop the `Balance` filter to count all-time holders instead.
---
## Holders above a balance floor
**Whale lists and eligibility checks:** a regular `where` filter on `Balance.Amount` keeps only holders above a threshold — for USDG, the floor is effectively in dollars.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Balance: { Amount: { ge: "100000" } }
}
limit: { count: 10 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
}
}
}
}
```
---
## Holder distribution statistics
Concentration analysis in one aggregate call: current holder count, total held, and the mean / median / 99th-percentile holder size. Expect a long tail — the median holder is typically far below the mean.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Balance: { Amount: { gt: "0" } }
}
) {
holders: count
total: sum(of: Balance_Amount)
avg: average(of: Balance_Amount)
med: median(of: Balance_Amount)
p99: quantile(of: Balance_Amount, level: 0.99)
}
}
}
```
`standard_deviation` and other `quantile` levels are available for deeper concentration metrics (top-N share is easiest computed client-side from the [top holders](#top-holders-of-a-token) list against `total`).
---
## Dormant holders (diamond hands)
Set `LastChangeTime.till` to a **past** date to keep only wallets whose balance hasn't moved since then — their `Amount` is the balance frozen at their last change. Combine with `FirstChangeTime` and `UpdateCount` to separate long-term holders from one-touch airdrop recipients.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: {
Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } }
Balance: { LastChangeTime: { till: "2026-07-01T00:00:00Z" }, Amount: { gt: "0" } }
}
limit: { count: 10 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
## Tokenized stock holders (NVDA)
Robinhood's tokenized equities are ordinary ERC-20s, so holder analytics work unchanged — `Amount` reads as the tokenized share count. Example: NVIDIA; swap in AAPL (`0xaf3d76f1834a1d425780943c99ea8a608f8a93f9`) or any other stock token.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: { Currency: { SmartContract: { is: "0xd0601ce157db5bdc3162bbac2a2c8af5320d9eec" } } }
limit: { count: 10 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
FirstChangeTime
LastChangeTime
UpdateCount
}
}
}
}
```
---
## Native ETH rich list
Filter `Currency.Native: true` for the chain's largest ETH holders. **Contracts appear as holders** — the WETH contract naturally tops the list since it custodies wrapped ETH; filter or label known contracts for a people-only ranking.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: { Currency: { Native: true } }
limit: { count: 10 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
}
}
}
}
```
---
## Paginating full holder snapshots
**Airdrop snapshots and exports:** page through the complete holder set with `limit.offset`, keeping the same `orderBy` so pages don't overlap.
```graphql
{
EVM(dataset: archive, network: robinhood) {
Holders(
where: { Currency: { SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" } } }
limit: { count: 5, offset: 5 }
orderBy: { descending: Balance_Amount }
) {
Holder {
Address
}
Balance {
Amount
}
}
}
}
```
For very large one-off snapshots, Bitquery can also provide [data exports](https://bitquery.io/forms/api).
---
## Use-case patterns
| Goal | Approach |
| --- | --- |
| Holder leaderboard page | [Top holders](#top-holders-of-a-token), refreshed on your interval |
| Distribution / concentration dashboards | [Holder count](#holder-count-of-a-token) + [distribution stats](#holder-distribution-statistics); top-N share client-side |
| Airdrop eligibility & snapshots | [Balance floors](#holders-above-a-balance-floor) + [offset pagination](#paginating-full-holder-snapshots) |
| Diamond-hands / dormancy analysis | [`LastChangeTime` screens](#dormant-holders-diamond-hands) with `FirstChangeTime` / `UpdateCount` |
| Stock-token cap tables | [Tokenized stock holders](#tokenized-stock-holders-nvda) |
| Live movement between holders | Stream the token on the [Transfers API](/docs/blockchain/robinhood/robinhood-transfers/) |
---
## Tips
1. Use `dataset: archive` and always keep a `limit` — popular tokens have very large holder sets.
2. Add `Balance: { Amount: { gt: "0" } }` whenever you mean **current** holders; plain counts include every wallet that ever held.
3. There is no USD field on this cube — rank and threshold in token units (USDG ≈ dollars) and join prices from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/) for valuations.
4. `LastChangeTime.till` in the future = full current snapshot; in the past = dormancy screen with frozen balances. It is not an as-of-date balance calculator — for historical *balances* use the [Balances API's date filter](/docs/blockchain/robinhood/robinhood-balances-api/).
5. Contracts are holders too (WETH tops native rankings by design) — maintain a label list to exclude them from people-only rankings.
6. `UpdateCount` separates active traders (high) from set-and-forget holders (low) at a glance.
---
## FAQ
### How do I get the top holders of a Robinhood token?
Query `EVM.Holders` on `dataset: archive`, filter `Currency.SmartContract`, and order by `Balance_Amount` descending — see [Top holders](#top-holders-of-a-token). Each row includes the holder's first/last change time and update count.
### How do I get a token's holder count?
Run the [holder-count query](#holder-count-of-a-token) with `Balance: { Amount: { gt: "0" } }` for current holders, or without it for all-time holders.
### Can I take an airdrop snapshot of all holders?
Yes — page through the full holder set with `limit: { count, offset }` under a stable `orderBy`, optionally with a [balance floor](#holders-above-a-balance-floor) for eligibility. For very large snapshots, ask about data exports.
### How do I find dormant or diamond-hand holders?
Set `Balance.LastChangeTime.till` to a past date — only wallets untouched since then return, with their frozen balances. See [Dormant holders](#dormant-holders-diamond-hands).
### Why is there no USD value on holder rows?
The Holders cube reports token amounts only. Use token-unit thresholds (USDG ≈ dollars), or multiply amounts by a price from the [Trades API](/docs/blockchain/robinhood/robinhood-trades/).
### Should I use Holders or Balances?
`Holders` is token-centric (one token → many wallets): rankings, counts, distribution. [`Balances`](/docs/blockchain/robinhood/robinhood-balances-api/) is wallet-centric (one wallet → many tokens): portfolios, multi-address batches, and as-of-date balance history.
---
## Robinhood Token Supply API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-token-supply/
Robinhood Token Supply API: query and stream token total supply with Bitquery's EVM TransactionBalances API — single tokens, watchlists, and all active tokens.
# Robinhood Token Supply API
Get **token total supply** on the **Robinhood** network with Bitquery's `EVM.TransactionBalances` API. This guide covers the **latest supply of a token**, a **real-time supply stream**, and the **supply of all active tokens**.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [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/)
:::
:::caution `TransactionBalances` is realtime-only on Robinhood
This cube has no archive table on Robinhood: it holds only the most recent days, so a token with no transaction in that window returns no row, and `dataset: archive` errors. Keep queries bounded with a `Block.Time` filter and a `limit`.
:::
:::note Supply is decimal-normalized
`TokenBalance.TotalSupply` is already adjusted for the token's decimals, so it returns whole-token values (e.g. `100000000.000000000000000000`) — not the raw on-chain integer.
:::
---
▶️ [Token lookup by contract address - Run in IDE](https://ide.bitquery.io/token-lookup-by-address-robinhood-chain)
## Latest Supply of a Token
Get the most recent total supply for a single token by filtering on its contract address and taking the newest balance record.
```graphql
{
EVM(network: robinhood) {
TransactionBalances(
limit: {count: 1}
orderBy: {descending: Block_Time}
where: {TokenBalance: {Currency: {SmartContract: {is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73"}}}}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
Sample response
```json
{
"EVM": {
"TransactionBalances": [
{
"TokenBalance": {
"Currency": {
"Symbol": "WETH",
"HasURI": false,
"SmartContract": "0x0bd7d308f8e1639fab988df18a8011f41eacad73"
},
"TotalSupply": "18584.722713864831985195"
}
}
]
}
}
```
---
## Real-Time Supply Stream for Tokens on Robinhood
Subscribe to live total-supply updates across Robinhood tokens. The `SmartContract: {not: "0x"}` filter excludes the native coin so only token supply changes stream through.
```graphql
subscription {
EVM(network: robinhood) {
TransactionBalances(
where: {
TokenBalance: {
Currency: {
SmartContract: {not: "0x"}
}
}
}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
---
## 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. 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"}}}}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
Sample response
```json
{
"EVM": {
"TransactionBalances": [
{
"TokenBalance": {
"Currency": { "Symbol": "HEIST", "HasURI": false, "SmartContract": "0xfbb3171fc52fca9f8ff10b2494a6055a51f68717" },
"TotalSupply": "100000000.000000000000000000"
}
},
{
"TokenBalance": {
"Currency": { "Symbol": "ROBINHOOD", "HasURI": false, "SmartContract": "0x217b7013e00c13ce4f3bc968238e0b13ce297382" },
"TotalSupply": "100000000000.000000000000000000"
}
},
{
"TokenBalance": {
"Currency": { "Symbol": "BabyJugger", "HasURI": false, "SmartContract": "0xd8e25ced04f51efa18fa94b460f6e924c3aa23ae" },
"TotalSupply": "1000000000.000000000000000000"
}
}
]
}
}
```
---
## 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, bounded to the last six hours so the `limitBy` scan stays fast (widen the bound for tokens that transact rarely). 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: {Block: {Time: {since_relative: {hours_ago: 6}}}, 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?
Query `EVM.TransactionBalances` filtered by the token's `Currency.SmartContract`, ordered by `descending: Block_Time` with `limit: 1`. The newest record holds the latest `TotalSupply`.
### How do I stream supply changes in real time?
Run the `subscription` on `TransactionBalances` with `Currency.SmartContract: {not: "0x"}`. Each supply change on a token is pushed to your client as it is indexed.
### How do I list supply for all active tokens at once?
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.
---
## Next steps
- Combine supply with price from the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades) for market-cap and FDV calculations.
- Track newly launched tokens with the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches) and [Flap.sh API](/docs/blockchain/robinhood/flap-sh-api).
- Inspect holder and wallet flows with [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers).
---
## Robinhood Trades API & Streams
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-trades/
Robinhood Trades API: live trades, USD prices, OHLCV candles, market cap, whale trades, buy/sell pressure, and top traders via Bitquery GraphQL & WebSockets.
# Robinhood Trades API & Streams
Bitquery exposes **Robinhood** trade and price data through the **Trading** APIs. Use these queries and real-time GraphQL subscriptions to get **live trades, USD prices, OHLCV/K-line candles, market cap, whale trades, top traders, and token leaderboards** on Robinhood — all scoped with the `bid:robinhood` network filter.
## Video Tutorial | Robinhood Chain APIs - Real-Time Trades, Transfers & Meme Launches
:::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 New Pools & Trending Tokens API](/docs/blockchain/robinhood/robinhood-new-pools-trending) — new pools, trending tokens, pair lookup and token search
- [Robinhood Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [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/)
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api) — bonding-curve launchpad, graduations, Uniswap v4 pools
- [Pools.trade API on Robinhood](/docs/blockchain/robinhood/pools-trade-api)
- [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/)
:::
---
## Network identifier
| Field | Value | Notes |
| --- | --- | --- |
| `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` |
| MERRY (first-buyers example, a recent Bags launch) | `0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a` |
| 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
▶️ [Stream all Robinhood Chain trades - Run in IDE](https://ide.bitquery.io/stream-robinhood-chain-trades)
Stream real-time trades on Robinhood via a GraphQL subscription on `Trading.Trades` that includes details such as Trader Address, Base and Quote Currency Details, amounts, type of trade (buy or sell), market cap and transaction details.
▶️ [Run in IDE](https://ide.bitquery.io/Robinhood-Trades)
```graphql
subscription {
Trading {
Trades(
where: {
Pair: {
Market: {
NetworkBid: {
is: "bid:robinhood"
}
}
}
}) {
Block {
Time
}
Trader{
Address
}
Amounts{
Base
Quote
}
AmountsInUsd{
Base
}
Pair{
Token{
Name
Symbol
Address
}
QuoteToken{
Name
Symbol
Address
}
}
Side
Supply{
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader{
Hash
}
}
}
}
```
:::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/).
:::
:::tip Prefer Kafka for the firehose
Consuming the full Robinhood trade feed continuously? Bitquery also delivers DEX data as **Kafka streams** (protobuf topic `robinhood.dextrades.proto`) with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## Historical Trades on Robinhood
The Trading APIs cover roughly the **last 30 days** of history (for newer networks, data starts when Bitquery indexing began — measure the exact coverage with [this query](#check-the-trading-data-window)). This example pulls a past window using relative time bounds.
▶️ [Run in IDE](https://ide.bitquery.io/Historical-Robinhood-Trades)
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {ascending: Block_Date}
where: {
Block: {
Time: {
since_relative: {weeks_ago: 3}
till_relative: {weeks_ago: 1}
}
}
Pair: {
Market: {
NetworkBid: {
is: "bid:robinhood"
}
}
}
}) {
Block {
Time
}
Trader{
Address
}
Amounts{
Base
Quote
}
AmountsInUsd{
Base
}
Pair{
Token{
Name
Symbol
Address
}
QuoteToken{
Name
Symbol
Address
}
}
Side
Supply{
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader{
Hash
}
}
}
}
```
---
## Latest Trades on Robinhood
Query the most recent trades across all Robinhood tokens — the query counterpart to the real-time stream above — ordered by newest first. The `Block.Time` bound keeps the scan to the last hour; without it, sorting the whole rolling window by time is slow enough to hit the gateway timeout.
```graphql
{
Trading {
Trades(
limit: { count: 50 }
orderBy: { descending: Block_Time }
where: {
Block: { Time: { since_relative: { hours_ago: 1 } } }
Pair: {
Market: {
NetworkBid: { is: "bid:robinhood" }
}
}
}
) {
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Pair {
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
Address
}
}
Side
Supply {
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader {
Hash
}
}
}
}
```
---
## Whale Trades on Robinhood
:::caution USD amounts on thin pools
`AmountsInUsd` is derived from the pool price at trade time, so a thin or manipulated pool can print absurd dollar values. Sanity-check whale rows against the pool's liquidity, and rank leaderboards by trade `count` rather than USD volume when in doubt.
:::
▶️ [Run in IDE](https://ide.bitquery.io/largest-swaps-robinhood-chain)
Fetch large trades by filtering on USD value. This example returns trades of at least `$10,000` — adjust the `AmountsInUsd.Base` threshold as needed.
```graphql
{
Trading {
Trades(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {Pair: {Market: {NetworkBid: {is: "bid:robinhood"}}}, AmountsInUsd: {Base: {ge: 10000}}}
) {
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Pair {
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
Address
}
}
Side
Supply {
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader {
Hash
}
}
}
}
```
---
## Real-Time Trades for a Specific Token
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)
```graphql
subscription {
Trading {
Trades(
where: {
Pair: {
Token: {
Address: {
is: "0x9077841e155faaf4e4e89470822c2187eeef7777"
}
}
Market: {
NetworkBid: {
is: "bid:robinhood"
}
}
}
}) {
Block {
Time
}
Trader{
Address
}
Amounts{
Base
Quote
}
AmountsInUsd{
Base
}
Pair{
Token{
Name
Symbol
Address
}
QuoteToken{
Name
Symbol
Address
}
}
Side
Supply{
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader{
Hash
}
}
}
}
```
---
## Trades for a Specific Pair or Pool
Scope trades to a single liquidity pool using `Pool.Address` — useful when a token trades across multiple pools and you want just one.
```graphql
{
Trading {
Trades(
limit: { count: 50 }
orderBy: { descending: Block_Time }
where: {
Pair: {
Market: {
NetworkBid: { is: "bid:robinhood" }
}
Pool: {
Address: { is: "0xbbaefcfcd7b92ed0df1a3eec22a21ba6beb0b52b" }
}
}
}
) {
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Pair {
Pool {
Address
}
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
Address
}
}
Side
Supply {
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader {
Hash
}
}
}
}
```
---
## First Buyers of a Token on Robinhood
Get the earliest trades for a token (example: the MERRY meme token, launched within the rolling window), 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
{
Trading {
Trades(
limit: { count: 50 }
orderBy: { ascending: [Block_Time, TransactionHeader_Index] }
where: {
Pair: {
Token: {
Address: { is: "0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a" }
}
Market: {
NetworkBid: { is: "bid:robinhood" }
}
}
Side: { is: "Buy" }
}
) {
Block {
Time
}
Trader {
Address
}
Amounts {
Base
Quote
}
AmountsInUsd {
Base
}
Pair {
Token {
Name
Symbol
Address
}
QuoteToken {
Name
Symbol
Address
}
}
Side
TransactionHeader {
Hash
}
}
}
}
```
---
## Trades by a Trader
Using this GraphQL API endpoint you can get token trades by a trader with details such as trade amount, trade type, token details, marketcap, FDV and transaction hash.
▶️ [Run in IDE](https://ide.bitquery.io/Robinhood-Trades-by-a-trader)
```graphql
{
Trading {
Trades(
limit: { count: 50 }
orderBy: { descending: Block_Time }
where: {
Trader:{
Address:{
is: "0xf73644da46ab85da864fc4284322f489134ee82c"
}
}
Pair: {
Market: {
NetworkBid: {
is: "bid:robinhood"
}
}
}
}) {
Block {
Time
}
Trader{
Address
}
Amounts{
Base
Quote
}
AmountsInUsd{
Base
}
Pair{
Token{
Name
Symbol
Address
}
QuoteToken{
Name
Symbol
Address
}
}
Side
Supply{
FullyDilutedValuationUsd
MarketCap
}
TransactionHeader{
Hash
}
}
}
}
```
---
## Top Traders of a Token on Robinhood
▶️ Network-wide version: [Top Traders by Volume on Robinhood Chain](https://ide.bitquery.io/top-traders-robinhood-chain)
Rank the biggest traders of a specific token by total USD volume, with a buy/sell split and trade count. Aggregates `Trading.Trades` grouped by trader.
```graphql
{
Trading {
Trades(
limit: { count: 50 }
orderBy: { descendingByField: "volume_usd" }
where: {
Pair: {
Token: {
Address: { is: "0x9077841e155faaf4e4e89470822c2187eeef7777" }
}
Market: {
NetworkBid: { is: "bid:robinhood" }
}
}
}
) {
Trader {
Address
}
volume_usd: sum(of: AmountsInUsd_Base)
bought_usd: sum(
of: AmountsInUsd_Base
if: { Side: { is: "Buy" } }
)
sold_usd: sum(
of: AmountsInUsd_Base
if: { Side: { is: "Sell" } }
)
trades: count
}
}
}
```
---
## Latest Price of a Token on Robinhood
Get the latest USD normalised price of a token on Robinhood network using this API endpoint using `Trading.Tokens`.
:::note A single token might be traded on multiple pools, with each pool having a difference in price. As for the price returned by Bitquery we provide the weighted average price across all pools. To know more about the price calculation refer to [this](/docs/trading/crypto-price-api/price-index-algorithm/#how-token-prices-are-determined) document.
If you want to monitor price for a particular pool, we suggest usage of `Trading.Pairs` instead of `Trading.Tokens` where you could specify the pool address.
:::
▶️ [Run in IDE](https://ide.bitquery.io/latest-price-of-a-token_10)
```graphql
{
Trading {
Tokens(
where: {Token: {Address: {is: "0x9077841e155faaf4e4e89470822c2187eeef7777"}, NetworkBid: {is: "bid:robinhood"}}, Interval: {Time: {Duration: {eq: 1}}}}
orderBy: {descending: Interval_Time_End}
limit: {count: 1}
) {
latest_price: Price {
Ohlc {
Close
}
}
}
}
}
```
---
## Latest Price of a Token for a Liquidity Pool
This API endpoint retrieves the latest price of a token for a particular token pair or liquidity pool using the `Trading.Pairs` cube.
▶️ [Run in IDE](https://ide.bitquery.io/latest-price-of-a-token-on-a-pool)
```graphql
{
Trading {
Pairs(
where: {
Pool: {
Address:{
is: "0xbbaefcfcd7b92ed0df1a3eec22a21ba6beb0b52b"
}
}
Token: {
Address: {
is: "0x9077841e155faaf4e4e89470822c2187eeef7777"
},
NetworkBid: {is: "bid:robinhood"}},
Interval: {Time: {Duration: {eq: 1}}}
}
orderBy: {descending: Interval_Time_End}
limit: {count: 1}
) {
Pool{
Address
}
latest_price: Price {
Ohlc {
Close
}
}
}
}
}
```
---
## Market Cap, FDV and Supply of a Token
Get the latest market cap, fully-diluted valuation, supply, and price for a single Robinhood token in one row. `limit: 1` with `orderBy: { descending: Interval_Time_Start }` returns the most recent interval — the current snapshot.
```graphql
{
Trading {
Tokens(
limit: { count: 1 }
orderBy: { descending: Interval_Time_Start }
where: {
Token: {
Address: { is: "0x9077841e155faaf4e4e89470822c2187eeef7777" }
NetworkBid: { is: "bid:robinhood" }
}
Interval: { Time: { Duration: { eq: 1 } } }
}
) {
Token {
Name
Symbol
Address
}
Price {
Ohlc {
Close
}
}
Supply {
MarketCap
FullyDilutedValuationUsd
CirculatingSupply
TotalSupply
MaxSupply
}
Volume {
Usd
}
}
}
}
```
---
## Token Supply on Robinhood
While `Trading.Tokens` (above) returns supply alongside price and market cap, you can also read **total supply** directly from the `EVM.TransactionBalances` cube. `TokenBalance.TotalSupply` is decimal-normalized (whole tokens). See the full guide in the [Robinhood Token Supply API](/docs/blockchain/robinhood/robinhood-token-supply).
### Latest Supply of a Token
Get the most recent total supply for a single token by filtering on its contract address.
```graphql
{
EVM(network: robinhood) {
TransactionBalances(
limit: {count: 1}
orderBy: {descending: Block_Time}
where: {TokenBalance: {Currency: {SmartContract: {is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73"}}}}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
### Real-Time Supply Stream
Stream live total-supply updates across Robinhood tokens. The `SmartContract: {not: "0x"}` filter excludes the native coin.
```graphql
subscription {
EVM(network: robinhood) {
TransactionBalances(
where: {
TokenBalance: {
Currency: {
SmartContract: {not: "0x"}
}
}
}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
### 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. 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"}}}}
) {
TokenBalance {
Currency {
Symbol
HasURI
SmartContract
}
TotalSupply
}
}
}
}
```
---
## OHLCV / K-Line Candles for a Token
Token-level OHLCV candles (USD-normalised, weighted across all pools) for charting. This example uses 1-minute candles (`Duration: 60`); use `300` (5m) or `3600` (1h — the maximum candle) as needed.
```graphql
{
Trading {
Tokens(
limit: { count: 100 }
orderBy: { descending: Interval_Time_Start }
where: {
Token: {
Address: { is: "0x9077841e155faaf4e4e89470822c2187eeef7777" }
NetworkBid: { is: "bid:robinhood" }
}
Interval: { Time: { Duration: { eq: 60 } } }
}
) {
Interval {
Time {
Start
End
}
}
Price {
Ohlc {
Open
High
Low
Close
}
}
Volume {
Base
Quote
Usd
}
Supply {
MarketCap
FullyDilutedValuationUsd
}
Token {
Name
Symbol
Address
}
}
}
}
```
---
## Real-Time OHLCV Stream for a Pair on Robinhood
This GraphQL stream for 1 second OHLCV streams the USD normalised OHLC/K-line data for a token pair, and also contains info such as interval start and end time, marketcap, volume and token details for both base and quote tokens.
▶️ [Run in IDE](https://ide.bitquery.io/OHLCV-stream-for-a-token-pair-on-robinhood)
```graphql
subscription{
Trading {
Pairs(
where: {
Pool: {
Address:{
is: "0xbbaefcfcd7b92ed0df1a3eec22a21ba6beb0b52b"
}
}
Token: {
Address: {
is: "0x9077841e155faaf4e4e89470822c2187eeef7777"
},
NetworkBid: {is: "bid:robinhood"}},
Interval: {Time: {Duration: {eq: 1}}}
}
) {
Interval{
Time{
Start
End
}
}
Price {
Ohlc {
Open
High
Low
Close
}
}
Token{
Name
Symbol
Address
}
QuoteToken{
Name
Symbol
Address
}
Volume{
Base
Quote
Usd
}
Supply{
MarketCap
}
}
}
}
```
---
## Top Tokens on Robinhood by Volume
▶️ [Run in IDE](https://ide.bitquery.io/top-tokens-by-volume-robinhood-chain)
Rank the most actively traded Robinhood tokens by USD volume over the last 24 hours, aggregated from 1-second intervals with `sum`.
```graphql
{
Trading {
Tokens(
limit: {count: 50}
limitBy: {count: 1, by: Token_Id}
orderBy: {descending: [Volume_Usd]}
where: {Interval: {Time: {Start: {since_relative: {days_ago: 1}}, Duration: {eq: 1}}}, Token: {NetworkBid: {is: "bid:robinhood"}}}
) {
sum(of: Volume_Base)
usd: sum(of: Volume_Usd)
Token {
Name
Symbol
Address
}
Supply {
MarketCap
FullyDilutedValuationUsd
}
}
}
}
```
---
## 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"
"0x66c9ba158b2b80c2a51ca75f3e4155a682676c7a"
]
}
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?
Run a GraphQL `subscription` on `Trading.Trades` filtered by `Pair.Market.NetworkBid: "bid:robinhood"`. Every matching trade is pushed to your client as it is indexed. Any query on this page can be turned into a stream by switching the operation to `subscription`.
### What is the difference between `NetworkBid` and `Network`?
Both scope results to Robinhood. `NetworkBid: "bid:robinhood"` is the indexed identifier and is faster; `Network: "Robinhood"` is the human-readable equivalent. Prefer `NetworkBid` in filters.
### How do I get the current price of a Robinhood token?
Use `Trading.Tokens` for the USD-normalised, pool-weighted price, or `Trading.Pairs` when you need the price on a specific pool.
### Can I get OHLCV / candlestick data for Robinhood tokens?
Yes. Query `Trading.Tokens` or `Trading.Pairs` with an `Interval.Time.Duration` in seconds — from 1 second up to a maximum of 3600 (1 hour) per candle.
### How far back does Robinhood trade data go?
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).
---
## Robinhood Transactions & Receipts API
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-transactions-receipts-api/
Query Robinhood transactions and receipts with Bitquery GraphQL: block receipts, single-tx receipts, status, gas and fees. No node required.
# Robinhood Transactions & Receipts API
Query **transactions and their receipts on Robinhood** with Bitquery GraphQL. The `EVM.Transactions` cube returns one row per transaction with its **receipt** (status, gas used, cumulative gas, contract address, logs bloom), **fee breakdown** (effective gas price, burnt, miner reward), and header fields — a no-node replacement for the JSON-RPC receipt methods that also streams live over WebSocket.
This page is organized around the **RPC methods people migrate from** — `eth_getBlockReceipts`, `eth_getTransactionReceipt`, `eth_getTransactionByHash` — with the Bitquery equivalent for each. Every query was executed against the production endpoint before publishing, and the stream was verified live over WebSocket.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Events API](/docs/blockchain/robinhood/robinhood-events-api/) (logs — receipts don't nest them here)
- [Robinhood Calls & Traces API](/docs/blockchain/robinhood/robinhood-calls-api/)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers/)
- [WebSocket authentication](/docs/authorization/websocket/)
:::
**On this page:** [RPC mapping](#rpc-method-mapping) · [Dataset caveat](#dataset-realtime-only) · [Block receipts](#eth_getblockreceipts-equivalent) · [Single receipt](#eth_gettransactionreceipt-equivalent) · [Transaction by hash](#eth_gettransactionbyhash-equivalent) · [Getting logs](#getting-the-logs-for-a-receipt) · [Latest & stream](#latest-transactions-and-live-stream) · [Failed txs](#failed-transactions) · [Account history](#transactions-for-an-account) · [Receipt fields](#receipt-field-reference) · [FAQ](#faq)
---
## RPC method mapping
| JSON-RPC method | Bitquery equivalent |
| --- | --- |
| `eth_getBlockReceipts` | `Transactions` filtered by `Block.Number` (or `Block.Hash`) — [below](#eth_getblockreceipts-equivalent) |
| `eth_getTransactionReceipt` | `Transactions` filtered by `Transaction.Hash` — [below](#eth_gettransactionreceipt-equivalent) |
| `eth_getTransactionByHash` | Same filter, selecting header fields incl. `Transaction.Data` — [below](#eth_gettransactionbyhash-equivalent) |
| `eth_getTransactionReceipt().logs` | `Events` cube, same block or tx filter — [below](#getting-the-logs-for-a-receipt) |
| `eth_getBlockTransactionCountByNumber` | `Transactions` + `count` on a block — [below](#block-transaction-stats) |
| `eth_subscribe("newHeads"/txs)` | `subscription { Transactions }` — [below](#latest-transactions-and-live-stream) |
---
## Dataset: realtime only
:::warning Use `dataset: realtime` for transactions and receipts
Unlike the [Events](/docs/blockchain/robinhood/robinhood-events-api/) and [Calls](/docs/blockchain/robinhood/robinhood-calls-api/) cubes, the **`Transactions` cube has no archive table on Robinhood**. `dataset: archive` errors (*"no table can query Transaction"*), and `combined` only serves blocks still inside the realtime window. So receipt queries work for **recent blocks** — the realtime window is a rolling span of recent days; measure it with the [window probe](#window-probe). Blocks older than the window need a [data export](https://bitquery.io/forms/api).
:::
The block and transaction identifiers in the examples are **illustrative recent values** — they roll out of the realtime window over time. Get a current block number from the [latest-transactions query](#latest-transactions-and-live-stream) and substitute it.
### Window probe
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions {
count
earliest: Block { Time(minimum: Block_Time) }
latest: Block { Time(maximum: Block_Time) }
}
}
}
```
---
## `eth_getBlockReceipts` equivalent
Every transaction receipt in one block: filter `Block.Number` and order by `Transaction.Index` — each row is one receipt. Substitute a recent block number.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(
where: { Block: { Number: { eq: "18038003" } } }
orderBy: { ascending: Transaction_Index }
limit: { count: 1000 }
) {
Block {
Number
Hash
Time
}
Transaction {
Hash
Index
From
To
Type
Nonce
Value
}
Receipt {
Status
Type
CumulativeGasUsed
GasUsed
ContractAddress
Bloom
PostState
}
Fee {
EffectiveGasPrice
}
TransactionStatus {
Success
}
}
}
}
```
To target the block **by hash** (the other form `eth_getBlockReceipts` accepts), swap the filter:
```graphql
where: { Block: { Hash: { is: "0x69ab18694427b809459cad7a44b1ae369095897b2d86571410a1430902a9fb1d" } } }
```
:::note Robinhood is an Arbitrum-Orbit chain
Blocks include system/sequencer transactions (e.g. `Receipt.Type: 106` from the sequencer address `0x…000a4b05`) alongside user transactions — exactly what a node returns for the block. Filter them out by `Transaction.Type` or sender if you only want user activity.
:::
---
## `eth_getTransactionReceipt` equivalent
One transaction's receipt — filter `Transaction.Hash`.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(
where: { Transaction: { Hash: { is: "0x01f956f16e7200e1a2054e3a701bf6b2496972a23544b4d2f122f0894a0f0835" } } }
) {
Block {
Number
Hash
Time
}
Transaction {
Hash
Index
From
To
Type
Nonce
Value
Gas
GasPrice
}
Receipt {
Status
Type
CumulativeGasUsed
GasUsed
ContractAddress
Bloom
}
Fee {
EffectiveGasPrice
Burnt
MinerReward
}
TransactionStatus {
Success
EndError
}
}
}
}
```
`Receipt.Status` is the RPC-style `"1"`/`"0"`; `TransactionStatus.Success` is the same as a boolean, with `EndError` / `FaultError` carrying the revert reason when it failed.
---
## `eth_getTransactionByHash` equivalent
The same filter, selecting the transaction header — including `Transaction.Data` (the input calldata) and the fee-cap fields.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(
where: { Transaction: { Hash: { is: "0x01f956f16e7200e1a2054e3a701bf6b2496972a23544b4d2f122f0894a0f0835" } } }
) {
Block {
Number
Time
}
Transaction {
Hash
Index
From
To
Nonce
Value
Gas
GasPrice
GasFeeCap
GasTipCap
Type
Data
}
}
}
}
```
For the decoded function call and internal calls of a transaction, use the [Calls & Traces API](/docs/blockchain/robinhood/robinhood-calls-api/#full-call-tree-of-a-transaction) instead of raw `Data`.
---
## Getting the logs for a receipt
`eth_getTransactionReceipt` embeds a `logs` array; here logs live in the **[Events cube](/docs/blockchain/robinhood/robinhood-events-api/)**, decoded. Query them for the same transaction (or the whole block) and order by `Log.Index`:
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Events(
where: { Transaction: { Hash: { is: "0x01f956f16e7200e1a2054e3a701bf6b2496972a23544b4d2f122f0894a0f0835" } } }
orderBy: { ascending: Log_Index }
) {
Log {
Index
SmartContract
Signature {
Name
SignatureHash
}
}
Arguments {
Name
Type
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
Swap the filter to `Block: { Number: { eq: "…" } }` for every log in a block (the `eth_getBlockReceipts` logs, flattened).
---
## Latest transactions and live stream
▶️ Runnable IDE examples: [daily transaction count](https://ide.bitquery.io/robinhood-chain-daily-transactions), [daily active wallets](https://ide.bitquery.io/robinhood-chain-active-wallets), [gas usage and price](https://ide.bitquery.io/robinhood-chain-gas-fees), [blocks per day](https://ide.bitquery.io/robinhood-chain-block-time)
The newest transactions with their receipts — and the block numbers to plug into the examples above.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(limit: { count: 10 }, orderBy: { descending: Block_Time }) {
Block {
Number
Time
}
Transaction {
Hash
From
To
Value
Type
}
Receipt {
Status
GasUsed
}
TransactionStatus {
Success
}
}
}
}
```
Stream every transaction as it is mined — the push-based counterpart, verified live over WebSocket:
```graphql
subscription {
EVM(network: robinhood) {
Transactions {
Block {
Number
Time
}
Transaction {
Hash
From
To
Value
}
Receipt {
Status
GasUsed
}
TransactionStatus {
Success
}
}
}
}
```
:::tip WebSocket connection
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/).
:::
:::tip Prefer Kafka for the firehose
Consuming every transaction continuously? Bitquery also delivers Robinhood data as **Kafka streams** (protobuf topic `robinhood.transactions.proto`) with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
---
## Failed transactions
Filter `TransactionStatus.Success: false` for reverted transactions with their error text — an error monitor across the chain.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(
limit: { count: 10 }
orderBy: { descending: Block_Time }
where: { TransactionStatus: { Success: false } }
) {
Block {
Time
}
Transaction {
Hash
From
To
}
TransactionStatus {
Success
EndError
FaultError
}
Receipt {
Status
GasUsed
}
}
}
}
```
---
## Transactions for an account
Every top-level transaction sent by an address (`Transaction.From`), with receipts — an account history / nonce tracker. Swap in an active sender.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(
limit: { count: 10 }
orderBy: { descending: Block_Time }
where: { Transaction: { From: { is: "0xcc1120e4af58abbecae0c0e3c4b2d343c1283695" } } }
) {
Block {
Time
}
Transaction {
Hash
To
Value
Nonce
}
Receipt {
Status
GasUsed
}
}
}
}
```
`Transaction.From` is the top-level sender (EOA). For a contract's inbound calls including internal ones, use the [Calls API](/docs/blockchain/robinhood/robinhood-calls-api/#stream-calls-to-one-contract).
---
## Block transaction stats
The count and gas of one block in a single aggregate — the `eth_getBlockTransactionCountByNumber` answer, plus success rate and total gas.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transactions(where: { Block: { Number: { eq: "18038003" } } }) {
txns: count
success: count(if: { TransactionStatus: { Success: true } })
gas: sum(of: Receipt_GasUsed)
}
}
}
```
---
## Receipt field reference
| JSON-RPC receipt field | Bitquery field |
| --- | --- |
| `blockNumber` / `blockHash` | `Block.Number` / `Block.Hash` |
| `transactionHash` / `transactionIndex` | `Transaction.Hash` / `Transaction.Index` |
| `from` / `to` | `Transaction.From` / `Transaction.To` |
| `status` | `Receipt.Status` (`"1"`/`"0"`) or `TransactionStatus.Success` (bool) |
| `cumulativeGasUsed` | `Receipt.CumulativeGasUsed` |
| `gasUsed` | `Receipt.GasUsed` |
| `contractAddress` | `Receipt.ContractAddress` |
| `logsBloom` | `Receipt.Bloom` |
| `effectiveGasPrice` | `Fee.EffectiveGasPrice` |
| `type` | `Receipt.Type` (or `Transaction.Type`) |
| `root` (pre-Byzantium) | `Receipt.PostState` |
| `logs` | [`Events` cube](#getting-the-logs-for-a-receipt) (separate, decoded) |
Also on `Fee`: `Burnt`, `MinerReward`, `PriorityFeePerGas`, `GasRefund`, `Savings` (plus `*InUSD` variants). On `Transaction`: `GasFeeCap`, `GasTipCap`, `Data`, `Nonce`, `CallCount`, `Protected`.
---
## Tips
1. Use **`dataset: realtime`** — the `Transactions` cube has no archive on Robinhood; older blocks need a [data export](https://bitquery.io/forms/api).
2. `Receipt.Status` is RPC-style `"1"`/`"0"`; `TransactionStatus.Success` is the boolean form and carries `EndError` / `FaultError` on failure.
3. Receipts don't nest logs here — pull them from the [Events cube](#getting-the-logs-for-a-receipt) by block or tx hash.
4. Block/tx identifiers in queries roll out of the realtime window over time; fetch current ones from the [latest-transactions query](#latest-transactions-and-live-stream).
5. Sequencer/system transactions (`Type: 106`) appear in blocks — filter by `Transaction.Type` or sender for user-only views.
6. For decoded function inputs and internal calls, use the [Calls API](/docs/blockchain/robinhood/robinhood-calls-api/); for token movement, use [Transfers](/docs/blockchain/robinhood/robinhood-transfers/).
---
## FAQ
### What is the eth_getBlockReceipts equivalent on Robinhood?
Query the `EVM.Transactions` cube filtered by `Block.Number` (or `Block.Hash`), ordered by `Transaction.Index`, selecting `Receipt`, `Fee`, and `TransactionStatus` — one row per receipt. See [the query](#eth_getblockreceipts-equivalent). Use `dataset: realtime`.
### How do I get a single transaction's receipt?
Filter `Transaction.Hash` on the same cube — the [`eth_getTransactionReceipt` equivalent](#eth_gettransactionreceipt-equivalent). Add `Transaction.Data` and fee-cap fields for the [`eth_getTransactionByHash`](#eth_gettransactionbyhash-equivalent) view.
### Where are the receipt logs?
Logs are a separate, decoded cube — [Events](/docs/blockchain/robinhood/robinhood-events-api/). Filter it by the same `Transaction.Hash` or `Block.Number` and order by `Log.Index`. See [Getting the logs](#getting-the-logs-for-a-receipt).
### Why does dataset archive fail for transactions?
The `Transactions` cube is realtime-only on Robinhood — there is no archive table, so `archive` errors and `combined` only covers the realtime window. Recent blocks work; for older history request a [data export](https://bitquery.io/forms/api).
### How do I check whether a transaction succeeded or reverted?
Read `TransactionStatus.Success` (boolean) with `EndError` / `FaultError` for the reason, or `Receipt.Status` for the `"1"`/`"0"` form. Filter `Success: false` to list [failed transactions](#failed-transactions).
---
## Robinhood Transfers API & Streams
URL: https://docs.bitquery.io/docs/blockchain/robinhood/robinhood-transfers/
Query & stream Robinhood transfers with Bitquery GraphQL: ETH, USDG, tokenized stocks (AAPL, NVDA), whale alerts, wallet ledgers, and compliance monitors.
# Robinhood Transfers API & Streams
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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [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/)
- [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 — 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).
- 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** 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. 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
Stream live transfers for dashboards, bots, and alerting.
:::warning Filter live streams
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)
```graphql
subscription {
EVM(network: robinhood) {
Transfers {
Transfer {
Amount
AmountInUSD
Sender
Receiver
Type
Success
Currency {
Name
Symbol
SmartContract
Native
}
}
Transaction {
Hash
From
To
}
Block {
Number
Time
}
}
}
}
```
:::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/).
:::
:::tip Prefer Kafka for the firehose
Consuming all Robinhood transfers continuously? Bitquery also delivers this data as **Kafka streams** (protobuf topic `robinhood.tokens.proto`) with consumer-group scaling and replay. See [Kafka Streaming Concepts](/docs/streams/kafka-streaming-concepts/).
:::
### 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**.
```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
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)
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transfers(
limit: { count: 10 }
orderBy: { descending: Block_Time }
) {
Transfer {
Amount
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"
}
}
]
}
}
```
---
## Native ETH transfers
Useful for gas/treasury monitoring and large native ETH value moves (`Type` is often `call` or `transaction`).
```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
{
EVM(network: robinhood, dataset: realtime) {
Transfers(
where: {
Transfer: {
Currency: { Native: false }
Success: true
}
}
limit: { count: 10 }
orderBy: { descending: Block_Time }
) {
Transfer {
Amount
AmountInUSD
Sender
Receiver
Type
Currency {
Name
Symbol
SmartContract
}
}
Transaction {
Hash
}
Block {
Time
}
}
}
}
```
---
## Transfers for a specific token
▶️ [Whale WETH transfers - Run in IDE](https://ide.bitquery.io/whale-transfers-robinhood-chain)
Filter with `Transfer.Currency.SmartContract`. Example: WETH on Robinhood.
▶️ [Run in IDE](https://ide.bitquery.io/Transfers-for-a-token-on-robinhood)
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transfers(
where: {
Transfer: {
Currency: {
SmartContract: { is: "0x0bd7d308f8e1639fab988df18a8011f41eacad73" }
}
Success: true
}
}
limit: { count: 10 }
orderBy: { descending: Block_Time }
) {
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
Symbol
SmartContract
}
}
Transaction {
Hash
}
Block {
Time
}
}
}
}
```
### 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
}
}
}
}
```
---
## Latest transfer per token (activity pulse)
One call, one **latest** transfer per token: `limitBy` on the currency contract turns the firehose into a network-wide "which tokens are moving right now" pulse — useful for screeners and discovery dashboards.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transfers(
where: { Transfer: { Success: true, Currency: { Native: false } } }
limitBy: { by: Transfer_Currency_SmartContract, count: 1 }
limit: { count: 20 }
orderBy: { descending: Block_Time }
) {
Block {
Time
}
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Symbol
SmartContract
}
}
}
}
}
```
---
## USDG stablecoin transfers
**Accounting / payments / compliance:** track Global Dollar (USDG) flows. USDG rows report `AmountInUSD: 0`, but since USDG is a dollar stablecoin, `Transfer.Amount` **is** the dollar size — filter on it directly.
```graphql
{
EVM(network: robinhood, dataset: realtime) {
Transfers(
where: {
Transfer: {
Currency: {
SmartContract: { is: "0x5fc5360d0400a0fd4f2af552add042d716f1d168" }
}
Amount: { gt: "1000" }
Success: true
Sender: { not: "0x0000000000000000000000000000000000000000" }
Receiver: { not: "0x0000000000000000000000000000000000000000" }
}
}
limit: { count: 10 }
orderBy: { descending: Transfer_Amount }
) {
Transfer {
Amount
AmountInUSD
Sender
Receiver
Currency {
Name
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.
```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. 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
{
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
Multiple contracts can share one ticker — Robinhood has **two different contracts both using the GME symbol** (`0x1b0e319c6a659f002271b69db8a7df2f911c153e` and `0xc2362aff2a2a4cc1f48cf3dab2c4e2605eb94ba3`). 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**. 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)
}
}
}
```
---
## 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. Note `usd` comes back `0` here — 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. Expect a long-tail distribution: the average typically 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.
```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`).
```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). 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** (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.
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; 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 — 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?
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.
---
## trench.today API on Robinhood
URL: https://docs.bitquery.io/docs/blockchain/robinhood/trench-today-api/
trench.today API on Robinhood Chain: new token launches, bonding-curve buys and sells, and live curve reserves via Bitquery GraphQL and WebSocket streams.
# trench.today API on Robinhood
**trench.today** is a meme-coin launchpad on the **Robinhood** network, one of the most active token factories on the chain. This guide shows how to track **newly launched trench.today tokens**, **bonding-curve buys and sells**, and **live curve reserves** with Bitquery GraphQL APIs, using the `EVM(network: robinhood)` Events cube.
:::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 Chain API overview](/docs/blockchain/robinhood/) — every Robinhood Chain API, launchpad guide and stream in one place
- [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades)
- [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches)
- [Flap.sh API on Robinhood](/docs/blockchain/robinhood/flap-sh-api) — another Robinhood launchpad
- [Pons Launchpad API on Robinhood Chain](/docs/blockchain/robinhood/pons-api)
- [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers)
- [WebSocket subscriptions](/docs/subscriptions/websockets/)
:::
---
## trench.today contracts
All trench.today protocol events are emitted through a single factory proxy, which makes filtering simple: pin every query to one `LogHeader.Address`.
| Role | Address | Emits |
| --- | --- | --- |
| **Factory / curve engine** (EIP-1967 proxy) | `0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d` | `TokenCreate`, `TokenPurchase`, `TokenSale`, `Sync` |
| **Implementation** (behind the proxy) | `0x5d15bdd2a834c66149c38c5ae19c5f4b60cbc397` | Shown as `Log.SmartContract` in decoded events |
:::caution Decoded event names exist on the realtime dataset only
On `dataset: realtime` (the default) the four events carry decoded names and `Arguments`, and every query on this page works as written. On `dataset: archive` and `dataset: combined` the same rows are stored **undecoded**, so a `Log.Signature.Name` filter returns **zero rows** there, silently. For history, filter by topic0 instead and decode the payload client-side:
| Event | topic0 (`Log.Signature.SignatureHash`) |
| --- | --- |
| `TokenCreate` | `e2eb7016a2fc7f0aec441cc8bc9a7ecd75d29d94478782bab1cfa9c5b0dbdf1b` |
| `TokenPurchase` | `b284604a447841f5b5ee1495033bc7db1ab2f84c2624a7b7a3e9f014f32e8e7b` |
| `TokenSale` | `fe41490121bfbd4555a4f9aabe1e789de1641611b7edd2a0dc1c594f684ba193` |
| `Sync` | `27efe2fec96cb0ff68b9206e3dca402a919bb7172e2f2d12d49b633df3eabc4f` |
```graphql
{
EVM(network: robinhood, dataset: archive) {
Events(
limit: {count: 10}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {SignatureHash: {is: "e2eb7016a2fc7f0aec441cc8bc9a7ecd75d29d94478782bab1cfa9c5b0dbdf1b"}}}
}
) {
Block { Time }
Transaction { Hash }
LogHeader { Address Data }
Log { Signature { SignatureHash } }
}
}
}
```
:::
The four events cover the full bonding-curve lifecycle:
| Event | Meaning | Key arguments |
| --- | --- | --- |
| `TokenCreate` | New token launched | `creator`, `curve`, `token`, `quote`, `name`, `symbol`, `timestamp`, `tokenURI` |
| `TokenPurchase` | Buy on the curve | `token`, `buyer`, `amountOut`, `quoteAmountUsed`, `protocolFee`, `extraFee`, `extraFeeReceiver`, `extraFeeRate` |
| `TokenSale` | Sell on the curve | `token`, `seller`, `amountIn`, `netQuoteOut`, `protocolFee`, `extraFee`, `extraFeeReceiver` |
| `Sync` | Post-trade curve reserves | `token`, `realQuoteReserves`, `realTokenReserves`, `virtualQuote`, `virtualToken` |
:::note Amounts are raw on-chain integers
Event argument values (`amountOut`, `quoteAmountUsed`, reserves, fees) are the raw on-chain integers — divide by `1e18` for whole-token / native amounts. The `quote` argument of `TokenCreate` is the zero address, meaning the curve quotes in the chain's native token.
:::
---
## Newly launched tokens
Every launch emits a decoded **`TokenCreate`** event with the creator, the new token address, its bonding `curve` contract, and full metadata (`name`, `symbol`, `tokenURI`).
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-newly-created-tokens) · [WebSocket stream](https://ide.bitquery.io/trench-today-newly-created-tokens-stream)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {Name: {is: "TokenCreate"}}}
}
) {
Block {
Time
Number
}
Transaction {
Hash
From
}
Log {
Signature {
Name
}
SmartContract
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
:::tip Stream the same query
Change the operation type from a query to a `subscription` in the Bitquery IDE (and drop `limit`/`orderBy`) to receive every new trench.today launch in real time over WebSocket.
:::
---
## Token buys (`TokenPurchase`)
Each buy on the bonding curve emits `TokenPurchase` with the `buyer`, tokens received (`amountOut`), native spent (`quoteAmountUsed`), and the protocol fee.
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-token-purchases)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {Name: {is: "TokenPurchase"}}}
}
) {
Block {
Time
}
Transaction {
Hash
From
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
## Token sells (`TokenSale`)
Sells mirror buys: `amountIn` is the tokens sold, `netQuoteOut` the native returned to the `seller` after fees.
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-token-sales)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {Name: {is: "TokenSale"}}}
}
) {
Block {
Time
}
Transaction {
Hash
From
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
## Live trades stream (buys + sells)
Subscribe to both trade events in one WebSocket stream — the backbone of a trench.today trading bot or live feed.
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-live-trades-stream)
```graphql
subscription {
EVM(network: robinhood) {
Events(
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {Name: {in: ["TokenPurchase", "TokenSale"]}}}
}
) {
Block {
Time
}
Transaction {
Hash
From
}
Log {
Signature {
Name
}
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
`Log.Signature.Name` tells you whether each message is a buy (`TokenPurchase`) or a sell (`TokenSale`).
---
## Bonding-curve reserves (`Sync`)
After every trade the curve emits `Sync` with its current state: `realQuoteReserves` / `realTokenReserves` (actual balances) and `virtualQuote` / `virtualToken` (the constant-product virtual reserves). The instantaneous curve price is `virtualQuote / virtualToken`, and real reserves show how far a token has progressed along its curve.
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-bonding-curve-sync)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 20}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Log: {Signature: {Name: {is: "Sync"}}}
}
) {
Block {
Time
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
---
## All events for a single token
Every trench.today event carries a `token` argument, so one `Arguments.includes` filter follows a token through its whole lifecycle — creation, every buy and sell, and each reserve update. Replace the address with the token you're tracking.
▶️ [Run in IDE](https://ide.bitquery.io/trench-today-all-events-for-a-token)
```graphql
{
EVM(network: robinhood) {
Events(
limit: {count: 50}
orderBy: {descending: Block_Time}
where: {
LogHeader: {Address: {is: "0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d"}}
Arguments: {
includes: {
Name: {is: "token"}
Value: {Address: {is: "0xe6052a3eb17590ceac6652bc751065224749cccc"}}
}
}
}
) {
Block {
Time
}
Transaction {
Hash
From
}
Log {
Signature {
Name
}
}
Arguments {
Name
Value {
... on EVM_ABI_Address_Value_Arg {
address
}
... on EVM_ABI_String_Value_Arg {
string
}
... on EVM_ABI_BigInt_Value_Arg {
bigInteger
}
}
}
}
}
}
```
---
## FAQ
### How do I detect a newly launched trench.today token?
Filter events by `Log.Signature.Name: "TokenCreate"` on the factory address `0x77dc6f6361b7b99456fc3761ce5b7dda80d83f9d`. The decoded arguments include the `token` address, its `creator`, the bonding `curve` contract, and metadata (`name`, `symbol`, `tokenURI`). Run it as a `subscription` for real-time launch alerts.
### How do I get trench.today trades?
Query the same factory address for `TokenPurchase` (buys) and `TokenSale` (sells), or subscribe to both at once with `Name: {in: ["TokenPurchase", "TokenSale"]}`. Amounts are raw integers — divide by `1e18`.
### How do I compute a token's bonding-curve price?
Use the `Sync` event: the curve price in native terms is `virtualQuote / virtualToken`. `Sync` fires after every trade, so streaming it gives you a live price and reserve feed per token.
### Why is there one contract address instead of separate factory and curve contracts?
trench.today runs everything through a single EIP-1967 proxy (`0x77dc…f9d`). Each token still gets its own `curve` contract (reported in `TokenCreate`), but events are emitted by the proxy, so a single `LogHeader.Address` filter captures the entire protocol. Decoded events report the implementation `0x5d15…397` as `Log.SmartContract`.
### Can I use the Trading cube for trench.today trades?
Bonding-curve trades live in the `EVM` Events cube queries shown on this page. Once a token migrates to a DEX pool, its trading appears under Uniswap markets on Robinhood — follow it with the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
---
## Next steps
- Stream **`TokenCreate`** for real-time launch alerts, then follow each token with the [all-events-for-a-token query](#all-events-for-a-single-token).
- Track other Robinhood launchpads with the [Robinhood Meme Coin Launches API](/docs/blockchain/robinhood/robinhood-meme-coin-launches).
- Explore prices, OHLCV, whale trades, and top traders in the [Robinhood Trades API](/docs/blockchain/robinhood/robinhood-trades).
- Inspect holder and wallet flows with [Robinhood Transfers](/docs/blockchain/robinhood/robinhood-transfers).