Skip to main content
Yellowstone gRPC delivers real-time Solana blockchain data with ultra-low latency by connecting directly to Solana leaders as they produce shreds. Enhanced with Jito Shreds acceleration, it provides lightning-fast, reliable data streams for demanding applications.

High Performance

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

Real-time Streaming

Bidirectional streaming with instant subscription creation and cancellation.

Advanced Filtering

Precisely control which data you receive using account, transaction, and program-level filters.

Multiple Data Types

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

​
Pricing & Access

Professional Plan

$247/month

​
Endpoints

  • EU Region: https://grpc.solanatracker.io
  • US Region: https://grpc-us.solanatracker.io

​
Features

  • Ultra-low latency data streaming
  • Accelerated with Jito Shreds
  • 24/7 uptime with automatic failover
  • No bandwidth or request-based charges

​
Stream Types

  • Accounts
  • Transactions
  • Slots & Blocks
  • Entries
Monitor account state changes in real timeTrack balance updates, data modifications, ownership changes, and account creation/deletion events with flexible filters.

Account Monitoring Guide

Learn how to stream account updates with filtering examples.

​
Quick Start

Get up and streaming in minutes:

Yellowstone gRPC Quickstart

Step-by-step setup guide with installation, authentication, and your first stream.

​
Key Features

​
Jito Shreds Acceleration

Enhanced with Jito Shreds, 50–100 ms faster data availability compared to standard Yellowstone gRPC nodes.

​
Regional Endpoints

Select the closest endpoint for optimal performance:
  • EU: https://grpc.solanatracker.io
  • US: https://grpc-us.solanatracker.io

​
Flexible Filtering

Fine-tune exactly what data you receive:
  • Filter by account, owner, or program
  • Include or exclude vote/failed transactions
  • Apply memcmp and data size filters
  • Slice account data to minimize bandwidth usage

​
Subscription Request Structure

Each gRPC subscription includes a structured request defining what and how data is streamed.

​
Core Parameters

​
commitment
string
required
Data consistency level
  • processed — fastest, unconfirmed data
  • confirmed — confirmed by cluster
  • finalized — fully finalized data
​
ping
boolean
Keep the connection aliveSet to true to receive periodic pong messages (every 15 s) and prevent timeouts.
​
accounts_data_slice
array
Optimize account data transferRequest specific byte ranges:
[
  { "offset": 0, "length": 100 },
  { "offset": 200, "length": 50 }
]

​
Filter Configuration

​
account
array<string>
List of account public keys to monitor (logical OR).
​
owner
array<string>
List of account owners to monitor (logical OR).
​
filters
array<object>
Data size and memory comparison filters (logical AND):
[
  { "dataSize": 165 },
  { "memcmp": { "offset": 0, "bytes": "base58_encoded_bytes" } }
]
Multiple filter types use AND logic. Values within arrays use OR logic.
​
vote
boolean
Include or exclude vote transactions.
​
failed
boolean
Include or exclude failed transactions.
​
signature
string
Monitor a specific transaction signature.
​
account_include
array<string>
Include transactions involving any of these accounts (OR logic).
​
account_exclude
array<string>
Exclude transactions involving these accounts.
​
account_required
array<string>
Include only transactions involving all specified accounts (AND logic).

​
Example: Basic Transaction Monitoring

A minimal example using TypeScript: 
import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";

const client = new Client(
  "https://grpc.solanatracker.io",
  "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
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);
For production deployments, include retry logic, error handling, and structured data processing. See detailed guides for robust implementation patterns.

​
Ready to Start?

Complete Setup Guide

Installation, authentication, and first stream implementation.

Monitor Pump.fun Data

Real-world example: streaming Pump.fun transactions in real time.

​
Resources

⌘I