Data Streaming

Data streaming on Solana refers to mechanisms that deliver real-time blockchain updates from a node to your application without repeated polling.

Data Access Options

At the moment, RPC Fast does not provide direct UDP shred ingestion to end users. Instead, Solana data is available to our clients via two high-performance gRPC interfaces:

• Aperture gRPC (Beta)

• ShredStream gRPC

Both services are sourced directly from validator-level UDP shreds, ensuring minimal delay from the network.

Aperture gRPC (Beta)

Aperture gRPC reconstructs raw shreds into a structured stream compatible with the Yellowstone gRPC model, while bypassing traditional RPC node processing.

Compared to standard Yellowstone deployments, this approach:

• Reduces end-to-end latency by ~30–40 ms

• Avoids RPC node overhead (banking stage, account indexing, etc.)

• Delivers ordered, near-real-time block, transaction, and account updates

• Supports server-side filtering (accounts, programs, transactions, etc.)

• Provides a drop-in developer experience for existing Yellowstone clients

In short, Aperture combines shred-level speed with Yellowstone-level usability. Read more.

ShredStream gRPC

ShredStream gRPC provides a more direct representation of the underlying data flow by streaming Solana Entries reconstructed from shreds.

Key characteristics:

• Slightly higher latency compared to Aperture gRPC

• Streams raw entry data (closer to validator pipeline)

• No built-in filtering – all parsing and selection must be handled client-side

• Suitable for teams that require maximum control over decoding and processing

Feature	Aperture gRPC	ShredStream gRPC
Data source	UDP shreds	UDP shreds
Output format	Yellowstone-compatible	Entry stream
Latency	Lowest (~30–40 ms faster than RPC)	Low (slightly higher than Aperture)
Filtering	Server-side	Client-side only
Use case	HFT, analytics, production apps	Custom pipelines, low-level processing

---

Overview

Solana supports real-time blockchain data delivery through native streaming mechanisms. Instead of repeatedly polling RPC endpoints over HTTP, applications can subscribe to live updates and receive notifications as state changes occur. This is essential for responsive, state-aware applications such as explorers, dashboards, bots, wallets, and trading systems.

Streaming enables:

• Real-time UI updates (wallet balances, dashboards)

• Transaction tracking

• Program activity monitoring

• Trading and automation systems

• Indexing and analytics pipelines

Solana provides two primary streaming approaches:

1. WebSocket JSON-RPC PubSub (official RPC interface)

2. gRPC Streaming via Geyser plugins (validator-level streaming)

Both methods allow applications to stay synchronized with on-chain state – with different performance and architectural tradeoffs.

Streaming Method	Best For
JSON-RPC WebSocket	Lightweight apps, UI dashboards, wallet balance notifications, basic monitoring
gRPC / Geyser Streaming	High-frequency trading, indexing, analytics, heavy event loads, backend engines

Streaming complements rather than replaces regular HTTP RPC calls. While HTTP queries are great for on-demand lookups (e.g., historical data), streaming ensures your app is kept up-to-date in real time without hammering RPC endpoints.

RPC Fast provides both lightweight WebSocket subscriptions and high-performance streaming solutions designed for production-grade Solana infrastructure.

---

Solana RPC WebSocket PubSub

Solana’s official RPC interface includes a PubSub system over WebSockets, documented in the Solana Documentation.

Instead of calling getAccountInfo repeatedly, clients:

1. Open a persistent WebSocket connection

2. Send a subscription request

3. Receive push notifications when matching events occur

This form of streaming uses standard JSON-RPC over WebSockets (persistent connection, JSON payloads) and is part of Solana’s official RPC interface.

Architecture

Client Application
│
│ WebSocket (JSON-RPC)
▼
RPC Fast Solana Node
│
▼
Solana Validator Network

Supported Subscription Types

The RPC WebSocket interface supports:

Subscription	Description
accountSubscribe	Notifies when an account’s lamports or data change
programSubscribe	Notifies when accounts owned by a program change
logsSubscribe	Streams program log output
signatureSubscribe	Tracks transaction confirmation status
slotSubscribe	Notifies when a new slot is processed
blockSubscribe	Streams block data (if enabled)
rootSubscribe	Tracks finalized root changes

Commitment Levels

Each subscription may specify a commitment level:

• processed → lowest latency

• confirmed → voted by supermajority

• finalized → irreversible state

Choosing the right commitment is a latency vs. safety tradeoff.

Example: Account Subscription

import WebSocket from "ws";

const ws = new WebSocket("wss://your-rpc-endpoint");

ws.on("open", () => {
  ws.send(JSON.stringify({
    jsonrpc: "2.0",
    id: 1,
    method: "accountSubscribe",
    params: [
      "ACCOUNT_PUBLIC_KEY",
      { commitment: "confirmed" }
    ]
  }));
});

ws.on("message", (data) => {
  console.log("Update:", data.toString());
});

When to Use WebSocket Streaming

Best suited for:

• Wallet balance updates

• Basic trading bots

• UI dashboards

• Lightweight monitoring

• Applications with moderate subscription counts

---

High-Performance Streaming (gRPC / Geyser-based)

For low-latency or high-throughput streaming use cases (e.g., trading engines, real-time analytics), many providers build on Solana’s Geyser plugin architecture to expose streaming via gRPC rather than plain WebSockets. This approach is more efficient for binary data and supports advanced filtering and throughput.

What Is Geyser / gRPC Streaming?

• Solana validators and nodes can load Geyser plugins that expose on-chain data events at the lowest possible level.

• Clients then connect via gRPC (binary protocol on HTTP/2) and receive a stream of structured data (accounts, transactions, blocks, slots).

• This avoids JSON overhead and enables continuous streaming with minimal latency.

Architecture

Client Backend
       │
       │  gRPC (HTTP/2, Protobuf)
       ▼
RPC Fast Geyser Stream
       │
       ▼
Validator Runtime (Geyser plugin)

Data Types Typically Streamed

• Account updates (raw + parsed)

• Transactions

• Entry/slot updates

• Blocks

• Vote updates

Benefits of gRPC Streaming

• Low latency & high throughput: Binary streaming pushes data as soon as it’s processed in memory.

• Structured protocols: Strong typing and efficient serialization (Protocol Buffers).

• Advanced filtering: Clients can subscribe only to the data types or accounts they care about.

• Better for backend engines: Helpful when handling many subscriptions or large volumes of data.

This pattern forms the basis for many existing Solana streaming services (e.g., Yellowstone gRPC, Dragon’s Mouth implementations across providers).

When to Use gRPC Streaming

Recommended for:

• High-frequency trading (HFT)

• Real-time arbitrage engines

• MEV systems

• Large-scale indexing

• Analytics pipelines

• Applications handling thousands of updates per second

---

WebSocket vs gRPC Comparison

Feature	WebSocket RPC	Geyser gRPC
Protocol	JSON over WebSocket	gRPC (Protobuf over HTTP/2)
Latency	Low	Very Low
Throughput	Moderate	High
Filtering	Basic	Advanced
Best For	Frontend apps	Backend engines
Setup Complexity	Simple	Advanced

---

Streaming vs HTTP Polling

HTTP Polling	Streaming
Repeated requests	Persistent connection
Higher latency	Near real-time
Higher RPC load	Efficient push updates
Good for historical queries	Good for live state

Most production systems combine:

• HTTP RPC → historical queries

• WebSocket → reactive updates

• gRPC → high-performance ingestion

---

Concepts & Patterns

Commitment Levels: Commitment determines how “final” a piece of data must be before it triggers a notification (processed → earliest, finalized → safest). This choice affects latency vs. certainty.

Subscription Lifecycle:

Connect → request one or more subscriptions → receive events → unsubscribe → close connection.

Filtering: Many streaming clients support filtering (e.g., specific accounts or programs) to reduce noise and bandwidth. gRPC streams often provide richer, more granular filtering options.

---

Design Considerations

1. Backpressure Handling

Applications consuming streams must be able to process events quickly or queue them appropriately.

2. Reconnection Strategy

WebSocket and gRPC connections should implement:

• Automatic reconnect

• Subscription replay

• Idempotent state handling

3. Commitment Strategy

Lower commitment = faster but less final. Higher commitment = safer but slower.

4. Filtering Strategy

Over-subscribing can overwhelm systems. Use account and program filters to reduce noise.

---

Summary

• Solana supports real-time blockchain streaming natively via RPC WebSocket PubSub — part of its core RPC API — enabling clients to subscribe to account, transaction, log, slot, and other events.

• For advanced workloads, Geyser gRPC streaming is used by many services to deliver low-latency, structured data streams with more throughput and filtering power.

• Streaming is essential for building responsive dApps: wallets, analytics dashboards, explorers, trading bots, monitoring tools, and more.

Streaming allows applications to remain synchronized with on-chain state efficiently, reduce polling overhead, and react to events with minimal latency.