> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Solana Yellowstone gRPC: Real-Time Data Streaming

> High-performance, real-time Solana blockchain data streaming using gRPC protocol with advanced filtering and ultra-low latency delivery for developers.

<Note>
  **Looking for Helius's managed gRPC service?** This page documents the open **Yellowstone gRPC** protocol as a reference. For production use with 24-hour historical replay, multi-node failover, and a fully managed environment, see [LaserStream](/laserstream) — Helius's Yellowstone-compatible gRPC offering.
</Note>

## 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.

<CardGroup cols={2}>
  <Card title="High Performance" icon="bolt">
    Binary protocol with efficient serialization for maximum throughput and minimal bandwidth usage
  </Card>

  <Card title="Real-time Streaming" icon="wave-pulse">
    Bidirectional streaming with immediate subscription creation and cancellation
  </Card>

  <Card title="Advanced Filtering" icon="filter">
    Precisely control what data you receive with account, transaction, and program filters
  </Card>

  <Card title="Multiple Data Types" icon="database">
    Subscribe to accounts, transactions, slots, blocks, and entries in a single stream
  </Card>
</CardGroup>

## Stream Types

<Tabs>
  <Tab title="Accounts">
    **Monitor account changes in real-time**

    Track balance updates, data modifications, ownership changes, and account creation/deletion events with precise filtering options.

    <Card title="Account Monitoring Guide" icon="user" href="/grpc/account-monitoring">
      Learn how to stream account updates with filtering examples
    </Card>
  </Tab>

  <Tab title="Transactions">
    **Stream transaction data and execution results**

    Receive transaction signatures, execution status, program interactions, and token balance changes as they happen.

    <Card title="Transaction Monitoring Guide" icon="receipt" href="/grpc/transaction-monitoring">
      Monitor transactions with program filtering and execution details
    </Card>
  </Tab>

  <Tab title="Slots & Blocks">
    **Track network consensus and block production**

    Monitor slot updates, block creation, and network state changes across different commitment levels.

    <Card title="Slot & Block Monitoring Guide" icon="cube" href="/grpc/slot-and-block-monitoring">
      Stream slots and blocks with transaction details
    </Card>
  </Tab>

  <Tab title="Entries">
    **Low-level blockchain entry monitoring**

    Access fundamental execution units containing transaction batches and their results.

    <Card title="Entry Monitoring Guide" icon="code" href="/grpc/entry-monitoring">
      Stream block entries with transaction batches
    </Card>
  </Tab>
</Tabs>

## How to Access Yellowstone gRPC

Choose the option that best fits your needs:

### LaserStream

[LaserStream](/laserstream/) is a multi-tenant, highly available gRPC service with automatic failover and [24-hour historical replay capabilities](/laserstream/historical-replay). Ideal for most production applications.

<Tip>
  Get started with LaserStream from your [Helius Dashboard](https://dashboard.helius.dev/laserstream). Mainnet requires a Business or Professional plan; Devnet is available on Developer and above. See [Plans & Pricing](/billing/plans) for details.
</Tip>

### Dedicated Nodes

[Dedicated Nodes](/dedicated-nodes/) offer an exclusive gRPC endpoint with guaranteed resource isolation. Best for specialized requirements and advanced operators.

### Compare gRPC Options

Need help deciding? Read our [gRPC comparison guide](/laserstream/laserstream-vs-dedicated-nodes) to determine whether LaserStream or dedicated nodes is the best option for your use case.

## Quickstart

Ready to start streaming?

Start by reading our comprehensive setup guide, or get started from your dashboard:

<CardGroup>
  <Card title="Yellowstone gRPC Quickstart" icon="rocket" href="/grpc/quickstart">
    Covers installation, authentication, and configuring your first stream
  </Card>

  <Card title="Get Started" icon="rocket" href="https://dashboard.helius.dev/laserstream">
    Enable LaserStream from your Helius Dashboard and start streaming.
  </Card>
</CardGroup>

## Subscription Request Structure

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

### Core Parameters

<ParamField path="commitment" type="string" required>
  **Commitment level for data consistency**

  * `processed` - Transaction processed by the node
  * `confirmed` - Transaction confirmed by cluster
  * `finalized` - Transaction finalized by cluster
</ParamField>

<ParamField path="ping" type="boolean" optional>
  **Keep connection alive**

  Set to `true` to receive pong messages every 15 seconds, preventing connection timeouts from load balancers or proxies.
</ParamField>

<ParamField path="accounts_data_slice" type="array" optional>
  **Optimize data transfer**

  Request specific byte ranges from account data:

  ```json theme={"system"}
  [
    { "offset": 0, "length": 100 },
    { "offset": 200, "length": 50 }
  ]
  ```
</ParamField>

### Filter Configuration

<Accordion title="Account Filters">
  <ParamField path="account" type="array<string>">
    Array of account public keys to monitor (logical OR)
  </ParamField>

  <ParamField path="owner" type="array<string>">
    Array of owner public keys to monitor (logical OR)
  </ParamField>

  <ParamField path="filters" type="array<object>">
    DataSize and Memcmp filters (logical AND):

    ```json theme={"system"}
    [
      { "dataSize": 165 },
      { "memcmp": { "offset": 0, "bytes": "base58_encoded_bytes" } }
    ]
    ```
  </ParamField>

  <Info>
    When multiple filter types are used, they operate as logical AND. Within arrays, values operate as logical OR.
  </Info>
</Accordion>

<Accordion title="Transaction Filters">
  <ParamField path="vote" type="boolean">
    Include/exclude vote transactions
  </ParamField>

  <ParamField path="failed" type="boolean">
    Include/exclude failed transactions
  </ParamField>

  <ParamField path="signature" type="string">
    Monitor specific transaction signature
  </ParamField>

  <ParamField path="account_include" type="array<string>">
    Include transactions involving any of these accounts (logical OR)
  </ParamField>

  <ParamField path="account_exclude" type="array<string>">
    Exclude transactions involving any of these accounts
  </ParamField>

  <ParamField path="account_required" type="array<string>">
    Include transactions involving all of these accounts (logical AND)
  </ParamField>
</Accordion>

<Accordion title="Block Filters">
  <ParamField path="account_include" type="array<string>">
    Filter transactions and accounts within blocks
  </ParamField>

  <ParamField path="include_transactions" type="boolean">
    Include all transactions within the block
  </ParamField>

  <ParamField path="include_accounts" type="boolean">
    Include all account updates within the block
  </ParamField>

  <ParamField path="include_entries" type="boolean">
    Include all entries within the block
  </ParamField>
</Accordion>

<Accordion title="Slot Filters">
  <ParamField path="filter_by_commitment" type="boolean" default="false">
    When `true`, only receive slot updates for the specified commitment level. When `false`, receive updates for all commitment levels.
  </ParamField>
</Accordion>

***

## Example: Basic Transaction Monitoring

Here's a complete example to get you started:

```typescript theme={"system"}
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);
```

<Note>
  This is a basic example. For production use, implement proper error handling, reconnection logic, and data processing. See our detailed guides for complete implementations.
</Note>

***

## Ready to Start?

<CardGroup cols={2}>
  <Card title="Complete Setup Guide" icon="rocket" href="/grpc/quickstart">
    Installation, authentication, and first stream implementation
  </Card>

  <Card title="Stream Pump AMM Data" icon="chart-line" href="/grpc/stream-pump-amm-data">
    Real-world example: monitor Pump AMM transactions
  </Card>
</CardGroup>

## Advanced Resources

* **[Yellowstone gRPC Source Repository](https://github.com/rpcpool/yellowstone-grpc)** - Complete protobuf definitions and examples
* **[Discord Community](https://discord.com/invite/6GXdee3gBj)** - Get help from developers and Helius team
* **[LaserStream Documentation](/laserstream/)** - Enhanced gRPC service with additional features