Best Yellowstone gRPC providers for Solana in 2026

Solana is not a slow blockchain. In production, the network processes 3,000–4,000 non-vote transactions per second, and with the Firedancer validator client targeting 65,000+ TPS on mainnet, those numbers will only climb. For most dApp developers, standard JSON-RPC polling is good enough. For MEV searchers, arbitrage bots, liquidation engines, and real-time indexers, it is a fundamental architectural mismatch: by the time you have polled getAccountInfo and received a response, multiple slots have already passed.

The problem is not latency alone — it is the polling model itself. Repeatedly hammering getConfirmedSignaturesForAddress2 or getProgramAccounts to detect account state changes burns RPC credits, introduces variable lag, and creates race conditions that cost money on Solana where block times are 400 ms. What these workloads actually need is a push-based streaming interface that the validator feeds directly.

That interface is the Geyser plugin — and its dominant implementation is Yellowstone gRPC (also known as Dragon’s Mouth). Not all Solana RPC providers support it, and among those that do, the quality of the implementation varies from shared, rate-limited streams to fully isolated, co-located infrastructure. This guide covers what Geyser is, what infrastructure it demands, how six major providers compare for Geyser workloads, and how to get started with a production Chainstack Geyser endpoint.

Already on Chainstack? Jump straight to the Solana Yellowstone gRPC documentation or deploy your Geyser endpoint in minutes.

Yellowstone gRPC on Solana: what it is and why it matters

The Geyser plugin architecture

Solana validators expose a Geyser plugin interface — a Rust trait that allows external code to hook directly into the validator’s internal state machine. When a slot is processed, when a transaction lands, when an account is written — the Geyser plugin receives an event. This is not polling; the validator is pushing events out as they occur.

In practice, you do not run your own modified validator to use this. You connect to a Geyser-capable RPC provider that runs Yellowstone gRPC alongside its validators. Yellowstone gRPC, the implementation created by Triton One (the company that originally built the Dragon’s Mouth plugin and effectively established the ecosystem standard), exposes the Geyser event stream over a standard gRPC interface with bidirectional streaming. You send a subscription request; you receive a continuous stream of updates.

The six subscription streams

Yellowstone gRPC exposes six core subscription methods, each serving a different latency and data-volume profile:

• subscribeToSlots — Delivers slot status updates as a slot transitions through Processed, Confirmed, and Finalized. This is the lightest stream and the fastest signal for anything that needs to know what slot is current. MEV bots and trading bots typically subscribe to this stream to anchor their timing.
• subscribeToTransactions — Streams transactions as they are processed, with rich filtering options: by account keys included in the transaction (account_include), accounts that must not be present (account_exclude), program IDs, vote transactions, and failed transactions. This is the core stream for MEV bots and arbitrage monitors.
• subscribeToAccounts — Streams account state changes: every time an account’s data or lamport balance changes, you receive the full updated account struct. You can filter by pubkey, by owner program, or with memcmp filters against raw account data bytes — the same filters you would use with getProgramAccounts, but pushed in real time.
• subscribeToBlocks — Delivers full block data including all transactions, account updates, and rewards. High bandwidth. Appropriate for indexers that need a complete, ordered record of chain state.
• subscribeToBlocksMeta — Block metadata without individual transaction data: slot number, blockhash, parent slot, rewards, and block time. Significantly lower bandwidth than subscribeToBlocks. Useful when you need block-level timing signals but do not need to inspect every transaction.
• subscribeToEntry — Entry-level updates, the finest granularity available below the block level. Entries are the batches of transactions that validators package before hashing them into a block. This stream is relevant for latency-critical applications where you want the earliest possible signal that a transaction batch has been processed, before the full block is formed.

Why polling fails at Solana throughput

At 400 ms block times and thousands of TPS, polling getAccountInfo every second means you are checking state once every 2.5 blocks at best. For a lending protocol liquidation bot, that gap is the difference between catching a position at 100% utilization and arriving after another bot has already liquidated it. For a DEX arbitrage bot, a single missed block can mean a price discrepancy has already been closed.

Beyond latency, getProgramAccounts is an extraordinarily expensive RPC method — many providers rate-limit or entirely disable it. Repeatedly calling it to find changed accounts is not a substitute for account subscriptions.

Workloads that need Geyser

• MEV and arbitrage bots — Need subscribeToTransactions with account filters to detect sandwich opportunities and price discrepancies across DEX pools in real time
• Liquidation bots — Need subscribeToAccounts to monitor collateral ratios continuously without polling
• Order book mirrors — Need subscribeToAccounts to replicate on-chain order book state (OpenBook, Phoenix) into in-memory structures with sub-slot latency
• Real-time indexers — Need subscribeToBlocks or subscribeToTransactions to ingest every transaction without gaps
• Data pipelines — Need subscribeToBlocks or subscribeToBlocksMeta to drive downstream analytics without polling
• Real-time dashboards — Need subscribeToSlots and subscribeToAccounts to push live chain state to frontend clients

Yellowstone gRPC on Solana: infrastructure requirements

Latency

The speed advantage of Geyser over polling is real but depends heavily on the provider’s architecture. A Geyser endpoint that is physically co-located with a Solana validator can deliver events in under 10 ms from the moment the validator processes a slot. A shared Geyser endpoint hosted on a different server from the validator, behind a load balancer shared with many other tenants, can easily add 50–200 ms of latency on top of the validator’s own processing time. For latency-critical workloads like MEV, this difference is decisive.

Throughput and filtering

A single busy Solana slot produces hundreds of transactions. An unfiltered subscribeToTransactions stream during peak activity can generate 100 MB/s or more of raw gRPC data. This is not a theoretical number — at 4,000 TPS with average transaction sizes in the kilobyte range, the math is clear. Filtering is not optional for production bots; it is a design requirement. Effective Geyser usage means defining tight account and program filters in your subscription request so you receive only the events your bot actually needs to act on.

Dedicated versus shared endpoints

Shared Geyser endpoints serve multiple tenants from the same stream. This introduces three problems for production workloads. First, rate limits: shared endpoints cap the number of subscriptions and the total data volume per client. Second, priority: during peak load, the provider’s infrastructure may apply back-pressure that delays your events relative to other tenants. Third, reliability: if a noisy neighbor saturates the shared stream, your bot may miss events or receive them out of order.

Dedicated Geyser infrastructure — a node where the Geyser stream is provisioned exclusively for your account — eliminates all three issues. For any workload where a missed event has a financial cost, dedicated is the correct choice.

Geographic proximity

Solana’s validator set is distributed across three primary regions: US East (particularly New York and Virginia), Frankfurt, and Tokyo. Network propagation from a validator to your Geyser subscriber adds latency proportional to geographic distance. An MEV bot running in Frankfurt subscribing to a Geyser endpoint also in Frankfurt will receive events before a competing bot using an endpoint hosted in Singapore, all else being equal. Provider datacenter selection matters for latency-critical use cases.

gRPC versus WebSocket

Both WebSocket subscriptions (accountSubscribe, transactionSubscribe) and Yellowstone gRPC provide push-based updates. The differences matter at scale. gRPC uses HTTP/2 with binary encoding (Protocol Buffers), which is more compact than JSON, supports bidirectional streaming natively, and handles connection multiplexing at the protocol level. WebSocket is a single TCP connection carrying JSON text — higher overhead per message, no built-in binary framing, and no native multiplexing. For a bot subscribing to dozens of accounts or program transactions simultaneously, gRPC’s efficiency advantage compounds across every event received.

WebSocket subscriptions through standard JSON-RPC are a reasonable choice for simple use cases. They are not a substitute for Geyser in production MEV or indexer workloads.

Connection resilience

Geyser streams disconnect. Network hiccups, provider maintenance, and validator restarts all cause stream interruptions. Production Geyser clients must implement reconnection logic that tracks the last received slot and resumes without assuming continuity. A naive reconnect that does not account for missed slots during the gap can cause a liquidation bot to miss a critical account update or an indexer to produce gaps in its database. This is an implementation responsibility, but it is worth selecting a provider that minimizes connection interruptions in the first place.

Chainstack for Yellowstone gRPC workloads

Chainstack’s Yellowstone gRPC offering is built on the standard Yellowstone/Dragon’s Mouth protocol, available as an add-on starting at $49/month for 1 stream, $149/month for 5 streams, and $449/month for 25 streams. It runs on paid plans (Growth and above).

For teams that need isolated infrastructure without shared rate limits, Chainstack’s Dedicated Nodes provision an exclusive Solana node with no other tenants on the same machine. Compute is priced at $0.50/hour, and you get full control over configuration including Geyser stream access without the unpredictability of a shared environment.

For teams running high-throughput bots that need predictable billing rather than per-request pricing, the Unlimited Node add-on provides flat-fee RPS tiers starting at $149/month — a meaningful cost control mechanism when your bot is generating thousands of RPC calls per minute alongside its Geyser subscription.

Chainstack holds SOC 2 Type II certification, with the audit covering security, availability, and confidentiality Trust Services Criteria. For institutional teams with compliance requirements, this is a hard dependency that eliminates several smaller providers from consideration.

Connecting to Chainstack Yellowstone gRPC

The following example shows a Python gRPC client subscribing to transaction events for a specific program. Full import paths and SDK setup are documented in the Chainstack Yellowstone gRPC docs.

import grpc
from solders.pubkey import Pubkey
# Yellowstone gRPC — subscribe to account updates for a program
# Full SDK: https://docs.chainstack.com/docs/yellowstone-grpc-geyser-plugin
channel = grpc.secure_channel(
    "your-geyser-endpoint.chainstack.com:443",
    grpc.ssl_channel_credentials()
)
# Subscribe to all transactions for a specific program
request = SubscribeRequest(
    transactions={
        "my_filter": SubscribeRequestFilterTransactions(
            vote=False,
            failed=False,
            account_include=["YourProgramPubkeyHere"],
        )
    }
)

Provider comparison

The table below summarizes public positioning as of May 2026.

Provider	Geyser / Yellowstone	Dedicated nodes	SOC 2	Pricing model	Free Geyser tier
Chainstack	Yes — Yellowstone gRPC	Yes	Yes (Type II)	RU-based + flat add-ons	No
Quicknode	Yes — Yellowstone gRPC	Yes	Yes (Type II)	Credit-based	No
Helius	Yes — Yellowstone gRPC	No	No	RPC credit + Geyser tiers	No
Triton One	Yes — Yellowstone gRPC	Yes	No	Custom / enterprise	No
Alchemy	Yes — Yellowstone gRPC	No	Yes (Type II)	CU-based	No
dRPC	Limited	No	No	Pay-as-you-go	No

Note: dRPC does not offer Yellowstone gRPC streaming. Alchemy added Yellowstone gRPC support in 2025 with a multi-node architecture and 6,000-slot replay — see the Alchemy Yellowstone gRPC overview for details.

Provider-by-provider breakdown

Chainstack

Chainstack supports Yellowstone gRPC natively with tiered stream pricing ($49/month for 1 stream up to $449/month for 25 streams). The add-on is available on Growth and above plans. Dedicated Nodes are available for teams that need isolated infrastructure: no shared tenants, no shared rate limits, compute billed at $0.50/hour. The Unlimited Node add-on adds flat-fee RPS billing on top for bots with predictable high throughput.

The SOC 2 Type II certification (achieved December 2025) covers security, availability, and confidentiality — a meaningful differentiator for fintech and institutional clients. Geographic coverage includes US East, Frankfurt, and Tokyo for Solana, aligning with where the majority of Solana validators operate.

Fit by workload:

• MEV and arbitrage bots: Strong. Dedicated nodes eliminate shared-stream unpredictability; co-location options in US East and Frankfurt align with high-density validator regions.
• Indexers and data pipelines: Strong. subscribeToBlocks with filtering, combined with flat-fee billing, prevents surprise costs during high-activity periods.
• Liquidation and DeFi automation: Strong. subscribeToAccounts with memcmp filtering maps directly to monitoring collateral accounts across a lending protocol.

Quicknode

Quicknode offers Yellowstone gRPC (branded as Yellowstone Streaming) as part of its Solana infrastructure. It is one of the more established providers for Geyser and has strong tooling around its Streams product, which can route Geyser events to webhooks, Kafka, and other downstream targets — useful for data pipeline use cases where you want managed delivery rather than a raw gRPC client.

Quicknode holds SOC 2 Type II certification and offers dedicated endpoint options. Its pricing is credit-based, which can make cost estimation harder for high-throughput Geyser workloads compared to flat-fee models. The credit system applies multipliers to certain RPC methods, so teams should audit their method mix against Quicknode’s credit schedule before committing.

Fit by workload:

• MEV and arbitrage bots: Good. Yellowstone gRPC is supported and well-documented; dedicated options available.
• Indexers and data pipelines: Very good. The Streams routing product simplifies event delivery to downstream systems.
• Liquidation and DeFi automation: Good. Full Yellowstone support covers the subscription patterns these bots need.

Helius

Helius is a Solana-only provider that has built significant tooling around the Solana ecosystem, including enhanced APIs for parsing transactions and NFT data. It supports Yellowstone gRPC and is widely used by Solana-native teams.

The limitation for production Geyser workloads is the absence of dedicated node infrastructure. Helius operates shared endpoints. For teams building MEV infrastructure where stream isolation matters, this is a notable gap. Helius does not hold SOC 2 certification, which may matter for enterprise procurement. Pricing is RPC credit-based with separate Geyser tiers.

Fit by workload:

• MEV and arbitrage bots: Moderate. Yellowstone is available but shared; production MEV bots generally need isolation.
• Indexers and data pipelines: Good. Helius’s enhanced transaction parsing APIs add value for indexers that need decoded program data alongside raw events.
• Liquidation and DeFi automation: Moderate. Shared Geyser works for less latency-sensitive liquidation bots; high-frequency liquidators should consider dedicated infrastructure.

Triton One

Triton One is the company that created the original Yellowstone gRPC plugin (Dragon’s Mouth), making them the deepest technical implementation of Geyser in the provider market. They have the longest track record with Yellowstone and their infrastructure tends to be well-regarded among Solana-native teams that need raw streaming performance.

Triton One operates primarily at the enterprise and institutional level. They do not publicly list pricing (contact sales), do not hold SOC 2 certification, and their documentation and self-serve onboarding are minimal compared to Chainstack or Quicknode. For a startup team that needs to be operational quickly, the friction is real. For a trading firm with engineering resources and a need for the absolute best Geyser depth, Triton One is worth evaluating.

Fit by workload:

• MEV and arbitrage bots: Excellent for teams that have the operational capacity to work with an enterprise provider. The technical depth is unmatched.
• Indexers and data pipelines: Excellent for the same reason — Triton One’s Yellowstone implementation covers all six subscription streams with the most complete filtering options.
• Liquidation and DeFi automation: Excellent technically, but the lack of self-serve onboarding makes iteration slower.

Alchemy

Alchemy added Yellowstone gRPC support in 2025 with a distinct architectural approach: rather than a single node feeding a gRPC stream, Alchemy runs a multi-producer, multi-consumer setup where multiple Solana nodes feed data simultaneously. The practical benefit is resilience — if one node falls behind during a congestion event, other nodes continue feeding the stream. Alchemy also offers 6,000-slot replay, allowing subscribers to recover from connection drops without gaps.

Alchemy holds SOC 2 Type II certification and offers enterprise SLAs, which matters for institutional teams that need vendor compliance documentation. The limitation is the absence of dedicated node infrastructure — Alchemy operates shared endpoints, so stream isolation for latency-critical MEV is not available. Pricing is CU-based, which makes cost forecasting harder for sustained high-throughput Geyser workloads than flat-fee models.

Fit by workload:

• MEV and arbitrage bots: Moderate. Yellowstone is available and multi-node resilience helps with uptime, but no dedicated stream isolation for latency-critical trading.
• Indexers and data pipelines: Good. The 6,000-slot replay is useful for indexers recovering from restarts; combined with Alchemy’s enhanced token and NFT APIs, it suits data pipeline use cases.
• Liquidation and DeFi automation: Moderate. Real-time account monitoring via Geyser is supported; shared infrastructure limits it for the most latency-sensitive liquidation strategies.

dRPC

dRPC is a decentralized RPC network that routes requests across a distributed set of node operators. It supports Solana’s standard JSON-RPC methods and has competitive pay-as-you-go pricing, making it attractive for development and low-to-medium throughput workloads.

dRPC does not offer Yellowstone gRPC streaming. The decentralized network model makes native Geyser support architecturally difficult — Geyser requires a persistent, stateful streaming connection to a specific node with the Geyser plugin installed, which is incompatible with a routing layer that distributes requests across many independent operators. Teams that need Geyser cannot use dRPC for that component.

Like Alchemy, dRPC can play a supporting role in a hybrid stack for JSON-RPC calls, but it cannot serve as a Geyser provider.

Fit by workload:

• MEV and arbitrage bots: Not applicable (no Geyser support).
• Indexers and data pipelines: Not applicable for real-time streaming.
• Liquidation and DeFi automation: Not applicable for real-time account monitoring via Geyser.

Provider scoring

Getting started with Geyser on Chainstack

Step 1: Sign up or log in

Create an account at console.chainstack.com if you do not have one, or log in to your existing account. A Growth plan or above is required for Yellowstone gRPC access.

Step 2: Create a project and deploy a Solana Mainnet node

In the Chainstack console, create a new project and deploy a Solana Mainnet node. Select your preferred region (US East, Frankfurt, or Tokyo depending on where latency matters most for your workload).

Step 3: Add the Yellowstone gRPC add-on

From the node dashboard, navigate to the marketplace and add the Yellowstone gRPC add-on. Select the appropriate stream tier (1, 5, or 25 streams) based on your application’s subscription requirements.

Step 4: Copy your gRPC endpoint and API key

Once provisioned, the node dashboard displays your gRPC endpoint URL (format: your-node.solana-mainnet.chainstack.com:443) and your API key. These are the two credentials your gRPC client needs.

Step 5: Install the Yellowstone protobuf SDK and connect

Install the Yellowstone gRPC Python package and connect to your endpoint. The following example subscribes to slot updates — the lightest stream and a good starting point for verifying connectivity:

import grpc
import yellowstone_grpc_proto.geyser_pb2 as pb
import yellowstone_grpc_proto.geyser_pb2_grpc as pb_grpc

endpoint = "your-node.solana-mainnet.chainstack.com:443"
token = "YOUR_API_KEY"

creds = grpc.ssl_channel_credentials()
auth = grpc.metadata_call_credentials(
    lambda ctx, cb: cb([("x-token", token)], None)
)
composite_creds = grpc.composite_channel_credentials(creds, auth)

channel = grpc.secure_channel(endpoint, composite_creds)
stub = pb_grpc.GeyserStub(channel)

request = pb.SubscribeRequest(
    slots={"slots": pb.SubscribeRequestFilterSlots()},
)

for update in stub.Subscribe(iter([request])):
    if update.HasField("slot"):
        print(f"Slot {update.slot.slot}: {update.slot.status}")

For the full SDK setup, protobuf installation, and more subscription examples including subscribeToAccounts and subscribeToTransactions, see the Chainstack Yellowstone gRPC documentation.

You can also access Chainstack Solana RPC and Geyser endpoints directly from Claude, Cursor, Codex, Gemini, or Windsurf using Chainstack MCP. Learn more about Chainstack MCP.

Conclusion

Geyser provider selection in 2026 comes down to two questions: does the provider run Yellowstone natively on infrastructure they control, and is the stream isolated from other tenants? Everything else — pricing, SOC 2, geographic coverage — matters, but only after those two questions are answered.

Recommendation matrix by use case:

• MEV and arbitrage bots — Chainstack or Triton One for isolated, low-latency Geyser; Chainstack for teams that also need SOC 2 compliance and self-serve onboarding
• Indexers and data pipelines — Chainstack for integrated billing and dedicated infrastructure; Quicknode if you want managed event routing to Kafka or webhooks
• Liquidation and DeFi automation — Chainstack or Helius for standard liquidation bots; dedicated infrastructure strongly recommended for latency-sensitive liquidators
• Mixed JSON-RPC + Geyser stacks — All five Geyser-capable providers (Chainstack, Quicknode, Helius, Triton One, Alchemy) can serve both streaming and JSON-RPC; pair based on compliance and throughput needs

FAQ

What is the difference between Geyser plugin and Yellowstone gRPC?

The Geyser plugin is the plugin interface built into the Solana validator that allows external code to receive real-time state change events (account updates, transactions, slot transitions). Yellowstone gRPC is the specific gRPC-based implementation of that interface, originally created by Triton One under the name Dragon’s Mouth. It is now the ecosystem-standard way to consume Geyser data. When people say “Geyser endpoint,” they almost always mean a Yellowstone gRPC endpoint.

Can I use WebSocket subscriptions instead of Geyser for MEV bots?

WebSocket subscriptions (accountSubscribe, transactionSubscribe) provide push-based updates and are suitable for light monitoring. For production MEV bots, the limitations become significant: JSON encoding adds overhead compared to Protocol Buffers, WebSocket connections are less resilient under high event volumes, and standard WebSocket subscriptions do not provide the same filtering granularity as Yellowstone’s subscribeToTransactions with account includes. For latency-critical MEV workloads, Yellowstone gRPC is the right interface.

Which Solana RPC providers offer Yellowstone gRPC in 2026?

Of the major providers, Chainstack, Quicknode, Helius, Triton One, and Alchemy all offer Yellowstone gRPC in 2026. dRPC does not offer Yellowstone streaming. Alchemy added Yellowstone with a multi-node architecture and 6,000-slot replay in 2025. The comparison table in this article summarizes the current landscape as of May 2026.

How much does a Chainstack Yellowstone gRPC endpoint cost?

Chainstack’s Yellowstone gRPC add-on is priced at $49/month for 1 stream, $149/month for 5 streams, and $449/month for 25 streams. The add-on requires a paid base plan (Growth at $49/month or above). For teams needing a dedicated node, compute is billed separately at $0.50/hour. Full pricing details are at chainstack.com/pricing/.

Do I need a dedicated node for Geyser, or is a shared endpoint enough?

It depends on your workload’s latency and reliability requirements. For development, testing, and low-frequency monitoring, a shared Geyser endpoint is sufficient. For production MEV bots, high-frequency arbitrage, or any workload where a missed event has a direct financial cost, a dedicated node is strongly recommended. Shared endpoints are subject to rate limits and can be affected by other tenants’ usage patterns.

What gRPC filtering options does Yellowstone support?

Yellowstone gRPC supports several filtering mechanisms depending on the subscription type. For subscribeToTransactions: filter by account_include (pubkeys that must appear), account_exclude (pubkeys that must not appear), account_required (all listed pubkeys must appear), vote (include or exclude vote transactions), and failed (include or exclude failed transactions). For subscribeToAccounts: filter by specific pubkeys, by owner program, and with memcmp byte-pattern filters against raw account data — the same filtering semantics as getProgramAccounts. Multiple named filters can run concurrently on a single subscription request.

Additional resources

• Solana tooling guide on Chainstack
• Blockchain protocol tutorials
• Chainstack Solana articles
• Chainstack pricing
• Chainstack network status dashboard