Two fundamentally different models

Standard Solana RPC is a pull model. Your client makes a request - getAccountInfo, getSignaturesForAddress - and the node computes an answer and returns it. WebSocket subscriptions soften this, but under the hood you're still asking the node to watch specific things and notify you, and that mechanism doesn't scale gracefully to thousands of accounts.

Geyser-based gRPC is a push model. The Geyser plugin interface lets data flow out of the validator process the moment it changes - account writes, transactions, slot transitions, full blocks. Yellowstone is the widely-used gRPC implementation of that interface: you open one long-lived stream, describe what you care about with filters, and updates arrive as they happen.

RPC makes the node answer questions. gRPC makes the node narrate what's happening, live.

What Yellowstone gRPC gives you

A single gRPC subscription can multiplex everything you need, with server-side filtering so you only receive what's relevant:

  • Accounts - updates filtered by owner program, account key, or data size.
  • Transactions - filtered by account inclusion, vote/failed flags, and more.
  • Slots & blocks - slot status transitions and full block metadata.
  • Backpressure - a streaming protocol that handles flow control properly under load.

Because filtering happens on the server, you're not flooding your client with noise and discarding 99% of it - the work happens close to the data.

subscribe.ts
// one stream, server-side filters, processed commitment
const req = {
  accounts: {
    amm: { owner: [ RAYDIUM_AMM ] },
  },
  transactions: {
    swaps: { accountInclude: [ RAYDIUM_AMM ] },
  },
  commitment: "processed",
};
 
const stream = await client.subscribe(req);
for await (const update of stream) {
  strategy.onUpdate(update); // pushed, not polled
}

Side by side

JSON-RPCYellowstone gRPC
ModelPull / requestPush / stream
LatencyPoll intervalAs processed
FilteringClient-sideServer-side
ScaleMany connectionsOne stream
Best forReads, writes, historyLive state, bots

Need a low-latency gRPC stream?

rpc edge runs Yellowstone gRPC on nodes tuned for high-frequency streaming.

View plans & pricing →

When standard RPC is still right

gRPC isn't a wholesale replacement. You'll still use JSON-RPC to send transactions, fetch a single account on demand, pull historical signatures, or do any one-shot read where setting up a stream is overkill. The two are partners: gRPC keeps you continuously aware of live state; RPC handles point lookups and writes.

The takeaway

If your application reacts to Solana in real time - market making, liquidations, copy-trading, indexing - Yellowstone gRPC is the streaming backbone you want, and it scales far better than fanning out WebSocket subscriptions. Keep RPC for what it's good at, layer gRPC for live state, and reach for shreds when first-seen is everything.

Frequently asked questions

What is Yellowstone gRPC?
Yellowstone is the widely-used gRPC implementation of Solana's Geyser plugin interface. It pushes account, transaction, slot, and block updates out of the validator the moment they're processed, with rich server-side filters - a streaming alternative to polling JSON-RPC.
What's the difference between gRPC and standard RPC on Solana?
Standard JSON-RPC is a pull model - you request, the node answers. Yellowstone gRPC is a push model - you open one long-lived stream, describe what you care about with filters, and updates arrive as the validator processes them. gRPC wins on latency and scale for real-time state.
When should I still use JSON-RPC instead of gRPC?
Use JSON-RPC to send transactions, fetch a single account on demand, pull historical signatures, or any one-shot read where setting up a stream is overkill. gRPC keeps you continuously aware of live state; RPC handles point lookups and writes. They're partners, not replacements.
Why does gRPC scale better than WebSocket subscriptions?
WebSocket subscriptions watch specific things per connection and don't fan out gracefully to thousands of accounts. A single gRPC stream multiplexes accounts, transactions, slots, and blocks with server-side filtering and proper backpressure, so the work happens close to the data.
Is there anything faster than Yellowstone gRPC?
Yes - decoding transactions directly from shreds. gRPC pushes data at the validator's processed commitment; shred streaming reads one layer further upstream at the propagation layer, giving a first-seen view before any block is assembled.