Skip to main content

Solana gRPC - Streaming

Updated on
Oct 21, 2026

Overview​

Solana gRPC (Yellowstone-compatible Geyser gRPC) is a high-performance Solana Geyser plugin that enables real-time blockchain data streaming through gRPC interfaces. It serves as a powerful tool for developers who need to:


  • Stream blockchain data in real-time
  • Monitor on-chain activities (token mints, program interactions, state changes)
  • Query account states efficiently
  • Track transactions with minimal latency

Solana gRPC extends Solana's Geyser infrastructure by supporting both gRPC and JSON-RPC protocols, offering enterprise-grade reliability with granular control.

Transaction Versions​

Solana gRPC streams legacy, version 0, and version 1 transactions. Quicknode runs yellowstone-grpc-geyser v16.1.4 against proto v14.0.1, which carries the version 1 compute and fee settings on the message itself.

Message.versioned is true for both version 0 and version 1, so it does not tell them apart. Each version has one field the other never carries:

FieldPresent on
Message.address_table_lookupsVersion 0
Message.configVersion 1

Message.config is a TransactionConfig holding priority_fee, compute_unit_limit, loaded_accounts_data_size_limit, and heap_size. Field names follow whatever your generated stubs produce, so the TypeScript client exposes them as config.priorityFee, config.computeUnitLimit, and so on.

Four client-side version floors apply:


  • Generated stubs need yellowstone-grpc-proto v12.6.0 or later. Earlier stubs have no config field at all, so the settings are dropped while decoding and nothing reports an error.
  • Bank IDs and block footers need yellowstone-grpc-proto v13.0.0 or later. Older stubs drop bank_id and never decode block_footer updates, and nothing reports an error.
  • Block footer certificates need yellowstone-grpc-proto v14.0.1 or later. v14.0.0 decodes them as raw bytes on field numbers the server no longer sends, so the certificates come back empty.
  • Self-hosted plugins need yellowstone-grpc-geyser v15.1.1 or later. Earlier plugins downgrade version 1 messages to version 0 and drop the config. Quicknode endpoints are unaffected.

Bank IDs and Alpenglow​

Account, slot, transaction, block, block meta, entry, and block footer updates carry a bank_id, an ID the node assigns to each bank it creates. It is optional on account and slot updates, since startup account updates and the FIRST_SHRED_RECEIVED and COMPLETED slot statuses don't belong to a bank. The value is local to the node, so never compare it across connections.

One slot can carry more than one candidate bank, and fast leader handoff makes that more common. Buffer updates per slot and bank_id, keep the bank that reaches FINALIZED, and reconcile across connections on the blockhash. At PROCESSED, you can receive updates from a bank that is later abandoned.

Subscribe with an empty block_footer filter to receive SubscribeUpdateBlockFooter, which carries the slot, bank_id, bank hash, block producer time, and block user agent. Block footers are only available over Solana gRPC. The getBlock RPC method doesn't return them. To tell when a block is complete, use the block meta's entries_count and executed_transaction_count together with the footer, not ticks.

Set include_certificates on the block_footer filter to also receive certificates carried by the footer. block_final_cert is the highest-known finalization certificate and proves that its own slot is finalized, which can be earlier than the footer's slot. Attribute finalization to the certificate's slot, not the footer's slot or bank_id. With fast finalization it holds only final_aggregate, signed on the block. With slow finalization it holds a final_aggregate signed on the slot and a notar_aggregate signed on the block. skip_reward_cert and notar_reward_cert record the validators that voted skip or notarize on the slot, which feeds vote rewards. Each aggregate carries a BLS signature, the block_id it signed (empty for votes on a slot), and a signer_bitmap. The bitmap is a version byte and a little-endian u16 bit count, followed by one entry per validator in the certificate slot's epoch that marks whether it signed. Version 0 uses one bit per validator, least-significant bit first. Version 1 packs five base-3 digits per byte, least-significant digit first: 0 means absent, and 1 or 2 means a signer (distinguishing base and fallback votes). Indices follow the certificate epoch’s validator rank order: descending stake, then BLS public key. Reward certificates also refer to their own slot, not necessarily the footer’s slot.

A leader can change a block's parent after it has started sending entries. Set include_update_parent on the entry filter to receive SubscribeUpdateEntryUpdateParent when that happens. It names the cleared_bank_id whose entries are no longer valid, including entries that arrive after it, and the new parent_slot and parent_block_id. The replacement bank ID arrives in the SLOT_CREATED_BANK slot update.

Alpenglow consensus votes are exchanged outside transactions. Omit the vote filter or leave it false when subscribing to transactions; true excludes normal transactions.

Access​

Solana gRPC is available on Mainnet and Devnet, included with Scale and Business plans. Learn more on our pricing page.

For Devnet, create a Solana Devnet endpoint in the Quicknode Dashboard using a Scale or Business plan. Use the endpoint URL and token from that Devnet endpoint.

Endpoint and Token Configuration​

Solana gRPC operates on port 443. This is a dedicated secure port for gRPC communication and is separate from the standard Solana RPC endpoint. When connecting to the service, specify port 443 in the URL and enable compression.

  • Endpoint: The name of your gRPC-enabled endpoint (by default, this is three randomly generated words) followed by .solana-mainnet.quiknode.pro for Mainnet or .solana-devnet.quiknode.pro for Devnet, and the port number 443 (e.g., https://example-guide-demo.solana-mainnet.quiknode.pro:443)
  • Token: The alphanumeric string that follows the endpoint name in the URL (additional tokens can be generated from the Quicknode Dashboard) Endpoint Security tab.

Given the following example HTTP Provider URL: https://example-guide-demo.solana-mainnet.quiknode.pro/123456789/, your authentication credentials would be:


  • Endpoint: https://example-guide-demo.solana-mainnet.quiknode.pro:443
  • Token: 123456789

For example, a Devnet HTTP Provider URL of https://example-guide-demo.solana-devnet.quiknode.pro/123456789/ uses https://example-guide-demo.solana-devnet.quiknode.pro:443 as the gRPC endpoint and 123456789 as the token. Copy the hostname and token from your actual Devnet endpoint; changing a Mainnet hostname alone does not provision a Devnet endpoint.

Here is a sample for using this endpoint to connect with TypeScript:

import Client from '@triton-one/yellowstone-grpc';
// For HTTP Provider URL: https://example-guide-demo.solana-mainnet.quiknode.pro/123456789/
const ENDPOINT = 'https://example-guide-demo.solana-mainnet.quiknode.pro:443';
const TOKEN = '123456789';
const client = new Client(ENDPOINT, TOKEN, {
  grpcDefaultCompressionAlgorithm: 0, // 0 = gzip, 1 = zstd
});
await client.connect();

These examples target @triton-one/yellowstone-grpc v7.0.1 or later. Reading bankId or block footers needs v8.0.0 or later, and block footer certificates need v9.0.0 or later.

Authentication​

Solana gRPC authenticates with an x-token metadata header sent on every request. The value is the Token from Endpoint and Token Configuration above.

Client libraries expose this differently:


  • Go and Python set the x-token metadata header directly. See Go and Python.
  • Rust sets it with the client builder's x_token method. See Rust.
  • The TypeScript client sends it when you pass the token to the Client constructor. See TypeScript.

Compression​

The TypeScript example uses gzip. The Go, Rust, and Python setup pages show the equivalent client setting. Shipstern (formerly Vixen) uses accept-compression = "zstd". See Compression for per-language configuration.

Legacy port 10000

Port 10000 is a legacy Solana gRPC port and is metered from the uncompressed payload size. Use port 443 with compression for new and migrated connections. Port 10000 will sunset on October 1, 2026.

Migrating from Port 10000 to Port 443​

Moving an existing connection from port 10000 to port 443 changes the port you connect to, the authentication method you send, and whether you negotiate compression.


  • Port: Change the port in your endpoint from 10000 to 443.
  • Authentication: Basic Authentication is not supported on port 443. Use x-token authentication, as described in Authentication above.
  • Compression: Enable gzip or zstd on your client. See Compression for per-language configuration.

See Metered Data Pricing for how usage is metered on each port.

Metered Data Pricing​

Solana gRPC is metered on the volume of data delivered. From October 1, 2026, metered usage is 15 credits per 0.1 MB.

Port 443 meters compressed response data when the client negotiates compression. Port 10000 is legacy and meters uncompressed response data.

Making Solana gRPC Requests​

To make a request to Solana gRPC using different languages you check out below resources:

Compressed Filters (Cuckoo Filters)​

Standard subscriptions have per-filter pubkey limits (10-50 depending on plan). Compressed filters encode pubkeys into a cuckoo filter data structure, bypassing these limits. See the compressed filters documentation for implementation details.

Resources​

Last updated on