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

# Yellowstone gRPC Geyser plugin

> Stream real-time Solana data with the Yellowstone gRPC Geyser plugin and learn how to build analytics, trading, and indexing tools.

*Solana is fast. Geyser is faster.*

Yellowstone gRPC Geyser is a high-speed, plugin-based interface that streams live Solana blockchain data directly from validator memory, eliminating the latency of traditional RPC methods.

<Check>
  ### Geyser is available starting from Growth

  Geyser is available as a separate paid add-on starting from the [Growth plan](https://chainstack.com/pricing).
</Check>

<Note>
  ### Mainnet only

  The Yellowstone gRPC Geyser plugin is only available on Solana mainnet. It is not available on Solana devnet.
</Note>

Benefits

* Real-time streaming of transactions, account updates, blocks, and slot changes.
* Uses a standard gRPC interface with protobuf-formatted payloads.
* Accessible from any language supporting gRPC (Python, Go, Rust, JavaScript).
* Ideal for analytics, sniping bots, MEV strategies, data indexing, real-time dashboards, and compliance monitoring.
* `from_slot`/`fromSlot` support to replay recent slots and recover events missed during a brief disconnect. For an example, see `learning-examples/recover_missed_slots_with_from_slot.py` in [Solana Geyser Python tutorial](https://github.com/chainstacklabs/grpc-geyser-tutorial). The replay buffer holds a limited number of recent slots, not full history. See [Replay depth with from\_slot](#replay-depth-with-from_slot).

## Replay depth with from\_slot

The `from_slot` field replays recent slots from a server-side ring buffer, so a client that briefly disconnects can reconnect and catch up without missing events. It is a reconnection-recovery mechanism, not a historical backfill.

On Global Nodes, the buffer holds approximately the last 100 slots (around a minute). Requesting a `from_slot` older than the buffer returns an error:

```text theme={"system"}
broadcast from <slot> is not available, last available: <slot>
```

For arbitrary historical data beyond the buffer, use the standard JSON-RPC methods ([`getBlock`](/reference/solana-getblock), [`getSignaturesForAddress`](/reference/solana-getsignaturesforaddress), and [`getTransaction`](/reference/gettransaction)) instead of `from_slot`.

<Note>
  Need a deeper replay window? [Dedicated Nodes](/docs/dedicated-node) can be configured with a larger `from_slot` buffer for latency-sensitive workloads. [Contact us](https://chainstack.com/contact/) to set this up.
</Note>

## Enable the Yellowstone gRPC Geyser plugin

1. Deploy a Solana [Global Node](/docs/global-elastic-node)

2. Click on your deployed Solana node.

3. Click **Add-ons** > **Yellowstone gRPC Geyser Plugin** > **Install**.

## Connect to your endpoint

Once the add-on is installed, the node's **Access and credentials** view gains a **Yellowstone gRPC** section with the gRPC endpoint and the x-token. This endpoint is separate from the node's HTTPS and WSS endpoints, and the token travels in request metadata rather than in the URL — see [gRPC access via x-token](/docs/authentication-methods-for-different-scenarios#grpc-access-via-x-token). The x-token is the same value as the node's auth token, so if your RPC endpoint already works you already have it.

Geyser listens on port **443** with TLS. On Global Nodes, the console shows the full endpoint, `https://yellowstone-solana-mainnet.core.chainstack.com:443`. On Dedicated Nodes, it shows a bare hostname with no scheme or port. Whichever form the console shows, pass your client the form it expects, where `HOST` is the hostname alone — `yellowstone-solana-mainnet.core.chainstack.com` on Global Nodes:

| Client | Endpoint form |
| - | - |
| `@triton-one/yellowstone-grpc` (TypeScript), `yellowstone-grpc-client` (Rust) | `https://HOST:443` — the scheme is required |
| `grpc` (Python), `grpc-go` (Go), `grpcurl` | `HOST:443` — host and port only, no scheme |

The two forms are not interchangeable. A TypeScript or Rust client given a bare host fails to connect, and a Python or Go client given a scheme fails to resolve it.

<CodeGroup>
  ```js Node.js theme={"system"}
  const { default: Client } = require("@triton-one/yellowstone-grpc");

  const client = new Client("https://yellowstone-solana-mainnet.core.chainstack.com:443", "YOUR_X_TOKEN");
  console.log(await client.getVersion());
  ```

  ```python Python theme={"system"}
  import grpc

  auth = grpc.metadata_call_credentials(
      lambda ctx, cb: cb((("x-token", "YOUR_X_TOKEN"),), None)
  )
  creds = grpc.composite_channel_credentials(grpc.ssl_channel_credentials(), auth)
  channel = grpc.aio.secure_channel("yellowstone-solana-mainnet.core.chainstack.com:443", creds)
  ```
</CodeGroup>

For full working examples, see [Listening to programs using Geyser and Yellowstone gRPC (Node.js)](/docs/solana-listening-to-programs-using-geyser-and-yellowstone-grpc-node-js) and [Solana: transactions and block time with Yellowstone gRPC](/docs/solana-transactions-block-time-yellowstone-grpc).

## Limits

\$49/month:

* Unlimited stream events
* 2 concurrent streams available per platform account
* Up to 200 accounts per filter

\$149/month:

* Unlimited stream events
* 7 concurrent streams available per platform account
* Up to 200 accounts per filter

\$449/month:

* Unlimited stream events
* 25 concurrent streams available per platform account
* Up to 200 accounts per filter

### Filter limits

On Global Nodes, regardless of the plan, a single subscribe request can include up to the following number of filters of each type:

| Filter type | Maximum filters per request |
| - | - |
| `accounts` | 5 |
| `slots` | 5 |
| `transactions` | 20 |
| `transactions_status` | 10 |
| `blocks` | 10 |
| `blocks_meta` | 5 |
| `entries` | 5 |

Within those filters, the following limits apply:

* Each public key list in a filter holds up to 200 keys — `account` and `owner` in `accounts` filters; `account_include`, `account_exclude`, and `account_required` in `transactions` and `transactions_status` filters; and `account_include` in `blocks` filters.
* A subscribe request can include up to 2 `accounts_data_slice` entries.
* An `accounts` filter must set `account` or `owner`, and a `transactions` or `transactions_status` filter must set at least one condition, such as `account_include` or `vote`. A filter without conditions, which would stream every update of its type, is rejected.
* The SPL Token Program (`TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA`) is rejected in the `account` field of `accounts` filters and in the `account_include` field of `transactions`, `transactions_status`, and `blocks` filters.
* The System Program (`11111111111111111111111111111111`) is rejected in the `owner` field of `accounts` filters.

A subscribe request that exceeds any of these limits is rejected. On a [Dedicated Node](/docs/dedicated-node) with the Yellowstone gRPC Geyser plugin, the filter limits can be customized.

## Tooling

See:

* [Solana Geyser Python tutorial](https://github.com/chainstacklabs/grpc-geyser-tutorial)
* [Pump fun and Bonk fun sniping bot with Geyser](https://github.com/chainstacklabs/pumpfun-bonkfun-bot)
* [Solana: Listening to pump.fun token mint using Geyser](/docs/solana-listening-to-pumpfun-token-mint-using-geyser)
* [Solana: Listening to programs using Geyser and Yellowstone gRPC (Node.js)](/docs/solana-listening-to-programs-using-geyser-and-yellowstone-grpc-node-js)
* [Yellowstone repository](https://github.com/rpcpool/yellowstone-grpc)
* [Rust example](https://github.com/rpcpool/yellowstone-grpc/tree/master/examples/rust)
* [Go example](https://github.com/rpcpool/yellowstone-grpc/tree/master/examples/golang)