Yellowstone (gRPC)

Connect over gRPC (or gRPC-web) to the Yellowstone endpoint. There is one target for the whole catalog; the method selects what you query or stream.

https://yellowstone.raptor.trade
# grpc target: yellowstone.raptor.trade:443
# auth header: x-token: $RAPTOR_TOKEN

Send your token in the x-token metadata header on every call. Unlike HTTP (an Authorization: Bearer header) and WebSocket (a token query parameter), gRPC carries the token as request metadata - see Yellowstone Authentication.

The service is geyser.Geyser. Two RPC pairs cover market data: QueryMethod / SubscribeMethod take a MethodRequest - a method path string identical to HTTP/WS (e.g. solana::market::ohlcv) and a params field holding the selector object as a JSON string. The lower-level QueryRql / SubscribeRql take a raw RQL string instead.

Rows render exactly as they do over HTTP and WebSocket: numbers are strings, DateTime and Duration are ISO strings, blobs are 0x hex, a missing value (none) is JSON null, and only booleans stay native. Each data point carries an id alongside its columns; a subscription update's change kind marks it an insert, update, or delete.

A unary QueryMethod returns the matching data. The same call from grpcurl, the TypeScript SDK, and the Rust SDK:

grpcurl -H "x-token: $RAPTOR_TOKEN" \
  -d '{
    "method": "solana::market::ohlcv",
    "params": "{\"base\":\"So11111111111111111111111111111111111111112\",\"window\":\"1m\",\"limit\":100}"
  }' \
  yellowstone.raptor.trade:443 geyser.Geyser/QueryMethod

A server-streaming SubscribeMethod sends a hydration snapshot followed by live changes. The TypeScript SDK routes changes to callbacks; the Rust SDK yields a typed stream of events. Tune delivery with hydrate, throttle, and linger.

const sub = market(client).ohlcv.subscribe(
  { base: "So111...", duration: "1m", hydrate: 50, throttle: "1s" },
  {
    on_insert: (rows) => console.log("inserts", rows),
    on_update: (rows) => console.log("updates", rows),
    on_delete: (rows) => console.log("deletes", rows),
  },
);

// stop this stream
sub.unsubscribe();

When you want to write the query yourself, QueryRql and SubscribeRql take an RQL string directly. This is the escape hatch the method + params surface is built on.

grpcurl -H "x-token: $RAPTOR_TOKEN" \
  -d '{ "rql": "from solana::market::ohlcv::1m | take { 10 }" }' \
  yellowstone.raptor.trade:443 geyser.Geyser/QueryRql

The Rust SDK also wraps the official yellowstone-grpc-client, so the same connection can speak the standard geyser protocol - account, transaction, slot, and block subscriptions - against whatever the endpoint federates. Reach it with client.geyser().

use futures::StreamExt;

let mut geyser = client.geyser().await?;
let mut accounts = geyser
    .subscribe_accounts(vec!["<pubkey>".into()], vec![])
    .await?;

while let Some(update) = accounts.next().await {
    let update = update?; // yellowstone_grpc_proto::geyser::SubscribeUpdate
}

Both SDKs build the method and params for you and decode data into typed values - see the SDK reference for Rust and TypeScript.