GraphQL IDE40+ chains, one schemaFree to try

Write the query. See real on-chain data back.

Q: What does it cost to start?

Every paid plan starts with a 7-day free trial including full WebSocket streaming, no card required. Self-service runs from $49/mo — Personal is API-only and licensed for personal, non-commercial use — through Scale at $299/mo. Enterprise is a flat platform fee.

The Bitquery IDE is a browser workspace for authoring GraphQL against decoded blockchain data — historical and real-time, across 40+ networks, with a schema explorer, autocomplete and live subscriptions. No node, no indexer, no local setup.

Open the IDE Read the docs

Already know what you need? Get an API key and skip straight to code.

40+chains behind one endpoint

1PB+decoded blockchain data

10bn+API calls served monthly

A real query, a real response

The last five SOL/USDC trades on Solana

Copy it, paste it into the IDE, hit run. Every trade on every indexed venue arrives already decoded into pair, side, price and USD value — you are not parsing logs.

ide.bitquery.io/?endpoint=streaming.bitquery.io/graphql

Run ⌘↵

SolanaDexTrades.graphqlquery

# five most recent SOL/USDC trades, any Solana DEX
query RecentSolTrades {
  Solana(dataset: realtime) {
    DEXTradeByTokens(
      limit: {count: 5}
      orderBy: {descending: Block_Time}
      where: {Trade: {
        Currency: {MintAddress: {is: "So11111111111111111111111111111111111111112"}}
        Side: {Currency: {MintAddress: {is: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"}}}
      }}
    ) {
      Block { Time }
      Trade {
        Dex { ProtocolName }
        Currency { Symbol }
        Side { Currency { Symbol } }
        Amount
        Price
        PriceInUSD
      }
      Transaction { Signature }
    }
  }
}

response.json200 OK

184 ms

{
  "data": { "Solana": { "DEXTradeByTokens": [
    {
      "Block": { "Time": "2026-07-27T14:02:11Z" },
      "Trade": {
        "Dex": { "ProtocolName": "raydium_clmm" },
        "Currency": { "Symbol": "SOL" },
        "Side": { "Currency": { "Symbol": "USDC" } },
        "Amount": "412.884190",
        "Price": 184.2071,
        "PriceInUSD": 184.1904
      },
      "Transaction": { "Signature": "5tPq…9xKd" }
    },
    // 4 more, newest first
  ] } }
}
// dataset: realtime -> trades land here seconds after the slot.
// swap query for subscription and the same
// fields stream over WebSocket instead.

streaming.bitquery.io/graphqlcost 12 pointsrows 5Run this in the IDE

The workspace

What you get in the editor

Not a generic GraphQL playground pointed at a public endpoint. The IDE is wired to the Bitquery schema, so the editor knows every chain, cube and field before you type it.

Schema explorer & autocomplete

Browse the full schema in the Document panel, or press ctrl+space and let the editor complete cubes, arguments and enums. Invalid queries are flagged before you run them.

Saved queries

Save a working query to your account and reopen it from the Queries panel — the editor comes back exactly as you left it, which is what you want when a query took a while to get right.

Subscriptions in the browser

Change query to subscription and results start pushing over WebSocket in the results pane — real-time behaviour verified before you write a line of client code.

Query cost, visible

Every response reports the points it consumed, so you tune filters and limits against real cost instead of guessing. How points work →

Variables and a visual builder

Parameterise a query in the Variables panel instead of editing the string each time, or start from Builder and assemble one without writing GraphQL by hand.

Archive, realtime or combined

One argument decides whether a query reads full history, the live tip, or both stitched together — the same fields either way. See what is indexed per chain →

Starter queries

Six queries worth running on day one

Each one is valid as written. Copy, paste, change an address or a mint, and you have your own. The linked product page covers the fields, filters and limits in depth.

DEX trades for a token

What has traded, at what price, on which venue — decoded per protocol across 300+ DEXs.

query TokenTrades {
  Solana {
    DEXTradeByTokens(
      limit: {count: 20}
      orderBy: {descending: Block_Time}
      where: {Trade: {Currency: {MintAddress: {is: "<mint>"}}}}
    ) {
      Trade { Dex { ProtocolName } Price Amount PriceInUSD }
      Block { Time }
    }
  }
}

queryDEX API →

Top holders of a token

Who holds it and how concentrated it is, on any date — the distribution question, answered in one call.

query TopHolders {
  EVM(network: eth, dataset: archive) {
    TokenHolders(
      date: "2026-07-20"
      tokenSmartContract: "0xdAC17F958D2ee523a2206206994597C13D831ec7"
      limit: {count: 10}
      orderBy: {descending: Balance_Amount}
    ) {
      Holder { Address }
      Balance { Amount }
    }
  }
}

queryToken Holder API →

Every token a wallet holds

Balances rolled up from decoded balance updates, so the answer includes tokens no dashboard listed.

query WalletBalances {
  EVM(network: eth, dataset: combined) {
    BalanceUpdates(
      orderBy: {descendingByField: "balance"}
      where: {BalanceUpdate: {Address: {is: "<address>"}}}
    ) {
      Currency { Symbol SmartContract }
      balance: sum(of: BalanceUpdate_Amount, selectWhere: {gt: "0"})
    }
  }
}

queryAddress APIs →

Where a wallet sent funds

Transfers grouped by receiver and token — the first hop of a money-flow investigation.

query Outflows {
  EVM(network: eth, dataset: combined) {
    Transfers(
      limit: {count: 10}
      orderBy: {descendingByField: "sent"}
      where: {Transfer: {Sender: {is: "<address>"}}}
    ) {
      Transfer { Receiver Currency { Symbol } }
      sent: sum(of: Transfer_Amount)
    }
  }
}

queryCoinpath® money flow →

Live trades, pushed to you

The same fields as a query, delivered as they happen. Run it in the IDE and watch the pane fill.

subscription LiveRaydiumTrades {
  Solana {
    DEXTrades(
      where: {Trade: {Dex: {ProtocolName: {is: "raydium"}}}}
    ) {
      Block { Time }
      Trade {
        Buy { Price Currency { Symbol } }
        Sell { Currency { Symbol } }
      }
    }
  }
}

subscriptionWebSocket streams →

Volume and trader counts

Aggregates computed server-side — the shape behind a leaderboard, a token page or a terminal panel.

query TokenActivity {
  Solana(dataset: combined) {
    DEXTradeByTokens(
      where: {
        Trade: {Currency: {MintAddress: {is: "<mint>"}}}
        Block: {Time: {since: "2026-07-26T00:00:00Z"}}
      }
    ) {
      volumeUSD: sum(of: Trade_Side_AmountInUSD)
      trades: count
      traders: count(distinct: Transaction_Signer)
    }
  }
}

queryDEX terminals →

From query to production

The query you tested is the query you ship

Nothing is rewritten on the way out of the IDE. Same endpoint, same fields — you add an auth header, and for live data you swap the transport.

stream.tsgraphql-ws

import { createClient } from "graphql-ws";

const client = createClient({
  url: "wss://streaming.bitquery.io/graphql?token=ory_at_…"
});

client.subscribe(
  { query: "subscription { Solana { DEXTrades { Trade { Buy { Price } } } } }" },
  {
    next: (msg) => handle(msg.data),
    error: console.error,
    complete: () => {}
  }
);

request.shhttp

# any GraphQL client works: fetch, Apollo, urql, requests
curl -X POST https://streaming.bitquery.io/graphql \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $BITQUERY_TOKEN" \
  -d '{"query":"{ Solana { DEXTradeByTokens(limit: {count: 5}) { Trade { Price } } } }"}'

# -> 200 OK · application/json
# -> the same JSON you saw in the results pane

Queries are billed in points — cost scales with how much data a query actually scans, so narrower filters and smaller limits are cheaper. Subscriptions are bought as concurrent streams rather than metered per message, with points added to cover them for the billing period, so a live feed's cost stays flat. Your token is generated the moment you sign in to the IDE; the same one authorises HTTP requests, WebSocket streams, Solana gRPC and the MCP server if you want an agent asking these questions instead of a person.

Open the IDE Get an API key

Delivery at scaleKafka topics and cloud datashares when polling an API stops being the right shape.Rather not query at all?Embeddable widgets render the same data with no query writing.Schema referenceEvery cube and field, plus hundreds of worked examples per chain.

Coverage

One schema, 40+ chains

Switch a single argument and the same query runs on another network. EVM chains, Solana, Bitcoin and the UTXO family, TRON, Cardano, XRP Ledger and more — each decoded, not raw-log dumped. The blockchains hub lists what is indexed per chain.

300+DEX protocols decoded

10M+tokens tracked

Trying it is free. Every paid plan starts with a 7-day free trial — full WebSocket streaming, no card required. Self-service runs $49–$299/mo, and Enterprise is a flat platform fee.

Compare plans

FAQ

Before you open the editor

Do I need an account to use the IDE?

You need a free account to run a query, because the IDE issues your access token on sign-in — there is no key to create, copy or configure. No card and no sales call to start. Open the IDE and the first query is a paste away.

What does it cost to start?

Every paid plan starts with a 7-day free trial including full WebSocket streaming, no card required. Self-service runs from $49/mo — Personal is API-only and licensed for personal, non-commercial use — through Scale at $299/mo for production streaming. Enterprise is a flat platform fee. Full breakdown on pricing.

How do subscriptions differ from queries?

A query returns a result once, when you ask. A subscription registers your field selection and then pushes new matches over WebSocket as blocks arrive — same schema, same filters, no polling. Both work in the IDE, so you can watch a stream before you wire one up. Details in WebSocket streams.

How do points work?

Points price a query by the resources it consumes rather than counting calls, so a narrow filtered lookup costs a fraction of a broad historical scan. Every response tells you what it cost, which makes tuning a filter measurable. Subscriptions work differently: on a paid plan you buy a number of concurrent streams, and Bitquery adds enough points to keep them running for the billing period. Points, in the docs.

Can I use my own client instead?

Yes. It is a standard GraphQL endpoint over HTTP with a bearer token, so Apollo, urql, gql, plain fetch or curl all work unchanged. Subscriptions use the graphql-ws and subscriptions-transport-ws protocols. The IDE also exports a working snippet in your language once a query runs.

Where is the schema reference?

In the editor's Document panel, and in full at docs.bitquery.io — cube by cube, with worked examples per chain. If you would rather read data than write queries, Widgets and the MCP server expose the same index without GraphQL.

Paste a query. Watch the data arrive.

The editor is open, the schema is loaded and the index is live. First result in about thirty seconds.

Open the IDE Read the docs See plans

7-day free trial · 40+ chains · queries, subscriptions and gRPC on one token