​
What is Yellowstone gRPC?

Yellowstone gRPC provides ultra-low latency streaming of Solana blockchain data by tapping directly into Solana leaders to receive shreds as they’re produced. This delivers real-time data to your application with minimal delay.

High Performance

Binary protocol with efficient serialization for maximum throughput and minimal bandwidth usage

Real-time Streaming

Bidirectional streaming with immediate subscription creation and cancellation

Advanced Filtering

Precisely control what data you receive with account, transaction, and program filters

Multiple Data Types

Subscribe to accounts, transactions, slots, blocks, and entries in a single stream

​
Stream Types

Monitor account changes in real-timeTrack balance updates, data modifications, ownership changes, and account creation/deletion events with precise filtering options.

Account Monitoring Guide

Learn how to stream account updates with filtering examples

​
How to Access Yellowstone gRPC

Choose the option that best fits your needs:LaserStream - Multi-tenant, highly available gRPC service with automatic failover and historical replay capabilities. Ideal for most production applications.Dedicated Nodes - Exclusive gRPC endpoint with guaranteed resource isolation. Best for specialized requirements.Need help deciding? See our detailed comparison guide to understand which option is right for your use case.

​
Quick Start

Ready to start streaming? Begin with our comprehensive setup guide:

Yellowstone gRPC Quickstart

Complete setup guide with installation, authentication, and your first stream

​
Subscription Request Structure

Every gRPC subscription requires a properly structured request. Here’s how to build one:

​
Core Parameters

​
commitment
string
required
Commitment level for data consistency
  • processed - Transaction processed by the node
  • confirmed - Transaction confirmed by cluster
  • finalized - Transaction finalized by cluster
​
ping
boolean
Keep connection aliveSet to true to receive pong messages every 15 seconds, preventing connection timeouts from load balancers or proxies.
​
accounts_data_slice
array
Optimize data transferRequest specific byte ranges from account data:
[
  { "offset": 0, "length": 100 },
  { "offset": 200, "length": 50 }
]

​
Filter Configuration

​
account
array<string>
Array of account public keys to monitor (logical OR)
​
owner
array<string>
Array of owner public keys to monitor (logical OR)
​
filters
array<object>
DataSize and Memcmp filters (logical AND):
[
  { "dataSize": 165 },
  { "memcmp": { "offset": 0, "bytes": "base58_encoded_bytes" } }
]
When multiple filter types are used, they operate as logical AND. Within arrays, values operate as logical OR.
​
vote
boolean
Include/exclude vote transactions
​
failed
boolean
Include/exclude failed transactions
​
signature
string
Monitor specific transaction signature
​
account_include
array<string>
Include transactions involving any of these accounts (logical OR)
​
account_exclude
array<string>
Exclude transactions involving any of these accounts
​
account_required
array<string>
Include transactions involving all of these accounts (logical AND)
​
account_include
array<string>
Filter transactions and accounts within blocks
​
include_transactions
boolean
Include all transactions within the block
​
include_accounts
boolean
Include all account updates within the block
​
include_entries
boolean
Include all entries within the block
​
filter_by_commitment
boolean
default:"false"
When true, only receive slot updates for the specified commitment level. When false, receive updates for all commitment levels.

​
Example: Basic Transaction Monitoring

Here’s a complete example to get you started: 
import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";

const client = new Client("your-grpc-endpoint", "your-api-token", {
  "grpc.max_receive_message_length": 64 * 1024 * 1024
});

const stream = await client.subscribe();

// Handle incoming data
stream.on("data", (data) => {
  if (data.transaction) {
    console.log(`Transaction: ${data.transaction.signature}`);
    console.log(`Success: ${!data.transaction.meta?.err}`);
  }
});

// Subscribe to transactions with complete request structure
const subscribeRequest: SubscribeRequest = {
  transactions: {
    client: {
      accountInclude: [
        "TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA", // Token Program
        "11111111111111111111111111111111"               // System Program
      ],
      accountExclude: [],
      accountRequired: [],
      vote: false,
      failed: false
    }
  },
  commitment: CommitmentLevel.CONFIRMED,
  ping: { id: 1 }
};

stream.write(subscribeRequest);
This is a basic example. For production use, implement proper error handling, reconnection logic, and data processing. See our detailed guides for complete implementations.

​
Ready to Start?

Complete Setup Guide

Installation, authentication, and first stream implementation

Stream Pump AMM Data

Real-world example: monitor Pump AMM transactions

​
Advanced Resources