Yellowstone gRPC: how real-time Solana data actually streams

Yellowstone gRPC (Triton One's "Dragon's Mouth") is a Geyser plugin that streams real-time Solana data — accounts, transactions, slots, blocks, blocks-meta, and entries — to clients over gRPC subscriptions. It's the layer most serious indexers, trading bots, and data pipelines run on instead of JSON-RPC websockets.

How it works

A validator loads the plugin (--geyser-plugin-config), tapping the same Geyser hook Solana uses for account/slot/transaction notifications. A client opens a single gRPC stream with a SubscribeRequest carrying named filters; the server pushes matching updates as Protobuf messages over HTTP/2.

Versus JSON-RPC websockets:

• Lower latency and compact Protobuf payloads vs JSON.
• Rich server-side filtering — by account, owner, memcmp/dataSize, or transaction membership — so you receive only what you asked for.
• HTTP/2 flow control = real backpressure: a slow consumer doesn't silently drop updates the way websockets can.

The subscribe request

import Client from "@triton-one/yellowstone-grpc"

const client = new Client(GRPC_ENDPOINT, X_TOKEN, undefined)
const stream = await client.subscribe()

stream.write({
  accounts: {
    myFilter: {
      owner: ["TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"], // SPL Token program
      filters: [{ datasize: 165 }],                            // token accounts
      account: [], nonemptyTxnSignature: undefined,
    },
  },
  transactions: {
    txFilter: { accountInclude: ["<your-program-id>"], vote: false, failed: false },
  },
  slots: {}, blocks: {}, blocksMeta: {}, entry: {},
  commitment: 1, // 0 processed · 1 confirmed · 2 finalized
  accountsDataSlice: [],
})

stream.on("data", (update) => { /* account / transaction / slot update */ })
// reply to server pings to keep the connection alive through load balancers

Filter groups include accounts, transactions (with accountInclude/Exclude/Required), slots, blocks, blocksMeta, and entries. Clients exist for Rust (yellowstone-grpc-client), TypeScript (@triton-one/yellowstone-grpc), and Go.

The honest read

Yellowstone gRPC is almost always a premium add-on, not a free RPC tier — Triton, Helius, and QuickNode all sell it as paid streaming. It also carries more ops weight than websockets: persistent gRPC connections, ping/pong keepalives, reconnection-and-replay logic, Protobuf tooling, and filter tuning. For light needs, JSON-RPC websockets are simpler. For high-throughput, low-latency, lossless ingestion — indexers, MEV, real-time analytics — gRPC is the right tool. The repo is actively maintained (recent tags carry Alpenglow release-candidate compatibility work).

References

• rpcpool/yellowstone-grpc (GitHub)
• Triton — Dragon's Mouth gRPC docs
• Solana RPC providers compared

If your product's edge is reacting to chain state first, the question isn't whether to use gRPC — it's which provider's Dragon's Mouth you point it at.