Yellowstone gRPC

Yellowstone gRPC Overview

High-performance gRPC interface overview, connection setup, and subscription patterns for Yellowstone Dragon's Mouth.

NoLimitNodes provides access to the Yellowstone Dragon's Mouth gRPC interface - a high-performance streaming API built on Solana's Geyser plugin architecture.

Yellowstone gRPC enables real-time streaming of accounts, transactions, slots, blocks, and entries with advanced filtering, significantly outperforming traditional WebSocket and polling-based approaches.

Endpoint

grpc.nln.clr3.org:443

Authenticate with the x-api-key header on every request.

Key Advantages

Low latency - direct Geyser plugin access, data arrives before RPC processing
Rich filtering - filter by account, owner, program, transaction participants, and more
Bidirectional streaming - update subscription filters without reconnecting
Typed data - Protocol Buffers provide strict typing and efficient serialization

Service Definition

The Geyser service exposes two bidirectional streaming RPCs and several unary methods:

service Geyser {  // Bidirectional streaming subscriptions  rpc Subscribe(stream SubscribeRequest) returns (stream SubscribeUpdate) {}  rpc SubscribeDeshred(stream SubscribeDeshredRequest) returns (stream SubscribeUpdateDeshred) {}   // Unary methods  rpc SubscribeReplayInfo(SubscribeReplayInfoRequest) returns (SubscribeReplayInfoResponse) {}  rpc Ping(PingRequest) returns (PongResponse) {}  rpc GetLatestBlockhash(GetLatestBlockhashRequest) returns (GetLatestBlockhashResponse) {}  rpc GetBlockHeight(GetBlockHeightRequest) returns (GetBlockHeightResponse) {}  rpc GetSlot(GetSlotRequest) returns (GetSlotResponse) {}  rpc IsBlockhashValid(IsBlockhashValidRequest) returns (IsBlockhashValidResponse) {}  rpc GetVersion(GetVersionRequest) returns (GetVersionResponse) {}}

Commitment Levels

enum CommitmentLevel {  PROCESSED = 0;  CONFIRMED = 1;  FINALIZED = 2;}

Level	Value	Description
`PROCESSED`	0	Processed by the connected node (fastest, may be reverted)
`CONFIRMED`	1	Confirmed by supermajority vote
`FINALIZED`	2	Finalized by supermajority (most reliable)

Connection Keep-Alive

The Subscribe RPC is a bidirectional stream. The client sends SubscribeRequest messages to set or update filters, and the server responds with a continuous stream of SubscribeUpdate messages.

rpc Subscribe(stream SubscribeRequest) returns (stream SubscribeUpdate) {}

SubscribeRequest

accountsmap<string, SubscribeRequestFilterAccounts>

Named account subscription filters. See Account Filters.

slotsmap<string, SubscribeRequestFilterSlots>

Named slot subscription filters. See Slot Filters.

transactionsmap<string, SubscribeRequestFilterTransactions>

Named transaction subscription filters. See Transaction Filters.

transactions_statusmap<string, SubscribeRequestFilterTransactions>

Same filters as transactions, but only returns status (no full transaction data).

blocksmap<string, SubscribeRequestFilterBlocks>

Named block subscription filters. See Block Filters.

blocks_metamap<string, SubscribeRequestFilterBlocksMeta>

Block metadata filters. See Block Metadata Filters.

entrymap<string, SubscribeRequestFilterEntry>

Entry subscription filters. See Entry Filters.

commitmentCommitmentLevel

Commitment level: PROCESSED (0), CONFIRMED (1), FINALIZED (2).

accounts_data_slicearray

Array of { offset: uint64, length: uint64 } objects to receive only specific slices of account data.

pingSubscribeRequestPing

Send a ping to keep the connection alive. Contains a single field: id (int32) - set to any integer value. The server responds with a Pong echoing the same id.

from_slotuint64

Start streaming from this slot (replay support).

SubscribeUpdate

Each update contains the matched filter names and exactly one update type:

filtersarray

Names of the filters that matched this update.

update_oneofoneof

accountSubscribeUpdateAccount

Account data change.

slotSubscribeUpdateSlot

Slot status change.

transactionSubscribeUpdateTransaction

Full transaction data.

transaction_statusSubscribeUpdateTransactionStatus

Transaction status only.

blockSubscribeUpdateBlock

Full block data.

block_metaSubscribeUpdateBlockMeta

Block metadata only.

entrySubscribeUpdateEntry

Ledger entry.

pingSubscribeUpdatePing

Server ping.

pongSubscribeUpdatePong

Pong response to client ping.

created_atTimestamp

Server-side timestamp when the update was created.

import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc"; // The SDK sends its token argument through x-token metadataconst client = new Client("grpc.nln.clr3.org:443", "YOUR_API_KEY", {  grpcMaxDecodingMessageSize: 64 * 1024 * 1024,}); await client.connect();const stream = await client.subscribe(); stream.on("data", (data) => {  if (data.slot) {    console.log(`Slot: ${data.slot.slot}, Status: ${data.slot.status}`);  }}); // Send subscription requestconst request = {  slots: {    mySlots: { filterByCommitment: true },  },  commitment: CommitmentLevel.CONFIRMED,  accounts: {},  transactions: {},  transactionsStatus: {},  blocks: {},  blocksMeta: {},  entry: {},  accountsDataSlice: [],}; stream.write(request);

Updating Filters

Since Subscribe is bidirectional, you can send a new SubscribeRequest at any time to update your filters without reconnecting:

// Initial subscription for slotsstream.write({  slots: { mySlots: {} },  accounts: {},  transactions: {},  transactionsStatus: {},  blocks: {},  blocksMeta: {},  entry: {},  accountsDataSlice: [],  commitment: CommitmentLevel.CONFIRMED,}); // Later: add account subscription without reconnectingstream.write({  slots: { mySlots: {} },  accounts: {    myAccounts: {      account: ["vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg"],    },  },  transactions: {},  transactionsStatus: {},  blocks: {},  blocksMeta: {},  entry: {},  accountsDataSlice: [],  commitment: CommitmentLevel.CONFIRMED,});