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.

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 ➤

Related docs

• Robinhood Chain API overview — every Robinhood Chain API, launchpad guide and stream in one place
• Robinhood Trades API
• Robinhood Meme Coin Launches API
• Pons Launchpad API on Robinhood Chain — bonding-curve launchpad, graduations, Uniswap v4 pools
• Pools.trade API on Robinhood
• Robinhood Transfers
• WebSocket subscriptions

---

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)

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.

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 · WebSocket stream

{
  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 · WebSocket stream

{
  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
        }
      }
    }
  }
}

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.

{
  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
        }
      }
    }
  }
}

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.

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.

{
  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 to follow post-graduation trading), the migrated token amount, and the eth seeded into the pool.

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, or check the graduated token against a Flap.sh TokenCreated / TokenCurveSetV2 pair before acting on it.

{
  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.

{
  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).

{
  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.

{
  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.

{
  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::<tweet_id>, tying a token to a tweet or other social metadata.

{
  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). 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, 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.
• Track other Robinhood launchpads and bots with the Robinhood Meme Coin Launches API.
• Explore prices, OHLCV, whale trades, and top traders in the Robinhood Trades API.
• Inspect holder and wallet flows with Robinhood Transfers.