Solana gRPC guide

What is Solana gRPC?

Yellowstone gRPC is the streaming interface the Solana ecosystem has settled on for real-time chain data. It runs as a Geyser plugin on a validator and exposes account, transaction, slot, block and entry updates over a gRPC stream. Payloads are protobuf, filters run on the server, and the protocol has flow control.

If you build a trading bot, an indexer, a wallet or an explorer and need to see what happens on Solana as it happens, this is what you use. JSON-RPC and WebSocket pubsub still work, but they cost more to run at scale.

gRPC vs WebSocket vs RPC polling

What you can subscribe to

A Yellowstone stream is one Subscribe call. Each request carries named filters of these kinds:

• accounts: account changes by address, owner program or data filter
• transactions: transactions by the accounts they include, exclude or require, with or without votes and failed ones
• transactionsStatus: the status of matching transactions without their full payload
• slots: slot status as it moves through processed, confirmed and finalized
• blocks and blocksMeta: full blocks, or only their metadata
• entry: entries as the validator records them

The service also answers unary calls such as GetLatestBlockhash, GetSlot, GetBlockHeight, IsBlockhashValid, GetVersion and Ping. Filters of different kinds combine in one stream: all successful transactions touching program X plus updates to account Y is one subscription, not two.

Quick start — TypeScript

A minimal subscription to pump.fun transactions, against AllenHark's Frankfurt endpoint. Your server's IP must be on your allowlist; other providers expect an x-token as the second argument.

import Client, {
  CommitmentLevel,
  SubscribeRequest,
} from "@triton-one/yellowstone-grpc";

// AllenHark authenticates by your server's IP, so there is no token.
const client = new Client("http://88.216.36.108:10001", undefined, {
  "grpc.max_receive_message_length": 64 * 1024 * 1024,
});

const req: SubscribeRequest = {
  accounts: {},
  slots: {},
  transactions: {
    pumpfun: {
      accountInclude: ["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P"],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false,
    },
  },
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.PROCESSED,
};

const stream = await client.subscribe();
stream.on("data", (update) => console.log(update.transaction));
stream.write(req);

Quick start — Rust

use futures::StreamExt;
use yellowstone_grpc_client::GeyserGrpcClient;
use yellowstone_grpc_proto::prelude::*;

let mut client = GeyserGrpcClient::build_from_shared("http://88.216.36.108:10001")?
    .connect()
    .await?;

let (mut tx, mut rx) = client.subscribe().await?;

tx.send(SubscribeRequest {
    transactions: [("pumpfun".into(), SubscribeRequestFilterTransactions {
        account_include: vec!["6EF8rrecthR5Dkzon8Nwu78hRvfCKubJ14M5uBEwF6P".into()],
        vote: Some(false),
        failed: Some(false),
        ..Default::default()
    })].into_iter().collect(),
    commitment: Some(CommitmentLevel::Processed as i32),
    ..Default::default()
}).await?;

while let Some(update) = rx.next().await {
    println!("{:?}", update?);
}

Who provides Yellowstone gRPC?

Most Solana infrastructure providers offer it. Choose on where their endpoints are relative to your servers, how they authenticate, how many streams a plan allows, and how they bill:

• Helius: LaserStream, a Yellowstone-compatible stream
• Triton One: Dragon's Mouth, from the maintainers of Yellowstone
• QuickNode: Yellowstone gRPC on its larger plans or as an add-on
• Chainstack: a Geyser add-on
• Shyft: a multi-region gRPC network next to its indexed APIs
• AllenHark: Yellowstone gRPC in Frankfurt and Amsterdam, by IP allowlist, $5 a day or $99 a month, next to our ShredStream, transaction landing and servers

Latency optimizations

Four levers, in order of impact:

1. Run the consumer near the endpoint. Many Solana validators sit in European data centres such as Frankfurt and Amsterdam. A server of your own in the same city as the endpoint takes the long network path out.
2. Filter on the server. Every byte sent to you is a byte your client must keep up with. Most slow gRPC clients are slow because they asked for everything.
3. Use processed commitment when you can handle an occasional rollback. It arrives before confirmed, and well before finalized, which trails by about 32 slots.
4. Go one layer lower with shreds. gRPC shows what the validator has already processed. ShredStream delivers shreds or reconstructed entries while the block is still being built.

When not to use gRPC

Don't reach for gRPC for everything. A batch indexer that catches up overnight is simpler with getSignaturesForAddress over RPC. A wallet showing a balance is fine on WebSocket pubsub. gRPC earns its keep as the number of things you watch grows and the time you have to react shrinks: a bot watching 20,000 accounts and acting within a slot is the case it was built for.

Further reading

• AllenHark Yellowstone gRPC: plans, regions and how to connect
• ShredStream: the layer below gRPC
• Docs: AllenHark gRPC endpoints
• Blog: landing Solana transactions in 2026