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;
}
LevelValueDescription
PROCESSED0Processed by the connected node (fastest, may be reverted)
CONFIRMED1Confirmed by supermajority vote
FINALIZED2Finalized by supermajority (most reliable)

​
Connection Keep-Alive

Some load balancers terminate gRPC connections if the client is idle. The server sends Ping messages every 15 seconds — reply with a SubscribeRequest containing a ping message with an id field (any int32 value) to keep the connection alive.

​
Subscribe

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

​
accounts
map<string, SubscribeRequestFilterAccounts>
Named account subscription filters. See Account Filters.
​
slots
map<string, SubscribeRequestFilterSlots>
Named slot subscription filters. See Slot Filters.
​
transactions
map<string, SubscribeRequestFilterTransactions>
Named transaction subscription filters. See Transaction Filters.
​
transactions_status
map<string, SubscribeRequestFilterTransactions>
Same filters as transactions, but only returns status (no full transaction data).
​
blocks
map<string, SubscribeRequestFilterBlocks>
Named block subscription filters. See Block Filters.
​
blocks_meta
map<string, SubscribeRequestFilterBlocksMeta>
Block metadata filters (no transactions/accounts). See Block Filters.
​
entry
map<string, SubscribeRequestFilterEntry>
Entry subscription filters. See Entry Filters.
​
commitment
CommitmentLevel
Commitment level: PROCESSED (0), CONFIRMED (1), FINALIZED (2).
​
accounts_data_slice
array
Array of { offset: uint64, length: uint64 } objects to receive only specific slices of account data.
​
ping
SubscribeRequestPing
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_slot
uint64
Start streaming from this slot (replay support).

​
SubscribeUpdate

Each update contains the matched filter names and exactly one update type:
​
filters
array
Names of the filters that matched this update.
​
update_oneof
oneof
​
created_at
Timestamp
Server-side timestamp when the update was created.

​
Example: Subscribe to All Slots

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

// NLN uses x-api-key header (not x-token) — pass your API key as the token argument
const 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 request
const 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 slots
stream.write({
  slots: { mySlots: {} },
  accounts: {},
  transactions: {},
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
});

// Later: add account subscription without reconnecting
stream.write({
  slots: { mySlots: {} },
  accounts: {
    myAccounts: {
      account: ["vines1vzrYbzLMRdu58ou5XTby4qAqVRLmqo36NKPTg"],
    },
  },
  transactions: {},
  transactionsStatus: {},
  blocks: {},
  blocksMeta: {},
  entry: {},
  accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
});
Each new SubscribeRequest completely replaces the previous filters. Include all desired filters in every request.