Best Yellowstone gRPC Providers in 2026: Compared by Use Case

Disclosure: AllenHark sells Yellowstone gRPC and is one of the seven providers compared here. Every fact about another provider comes from that provider's own docs, product or pricing pages, linked in its section.

Yellowstone gRPC (Triton calls its hosted version Dragon's Mouth) is the standard way to stream Solana accounts, transactions, slots and blocks to a server. Every provider below speaks the same protocol, so switching is mostly a change of endpoint and credential. What differs is where the endpoints are, how far back a stream can replay after a disconnect, the limits, the billing, and Alpenglow readiness.

The short answer

No single provider is best at everything. Pick by the need that matters most:

• Lowest latency in Europe: put the endpoint in the same city as your servers. AllenHark serves Frankfurt and Amsterdam, and pairs the stream with shreds when you need data before any gRPC stream has it. Helius, QuickNode and Shyft also list Frankfurt. Measure before you commit (see the test section).
• Longest replay after a disconnect: Triton's Fumarole, a separate persistent stream included with Triton mainnet subscriptions, keeps up to four days. AllenHark and Helius LaserStream replay about 48 hours through from_slot.
• Most regions: Helius, with nine LaserStream endpoints across the US, Europe and Asia.
• Compliance (SOC 2): AllenHark holds SOC 2 Type II, and Helius, Chainstack and Alchemy say they do. QuickNode lists "SOC1 & SOC2 Type 2 certified" under its Enterprise plan.
• Simplest addition to an existing RPC plan: QuickNode (included on Scale and Business, same endpoint and token) or Chainstack (a marketplace add-on from the Growth plan, using the node's existing auth token).
• Flat price, no bandwidth metering: Shyft and Chainstack sell flat monthly tiers. AllenHark sells prepaid days, weeks and months with no usage billing.
• A cheap way to test: AllenHark's day pass and week plan run a real stream without a monthly commitment (pricing). Alchemy and Triton bill pay-as-you-go.
• Dedicated with no rate limits: AllenHark Dedicated gRPC, Helius Dedicated Nodes and Shyft Dedicated gRPC Nodes.

How we compared

• What we checked: product name, regions, replay window after a disconnect, authentication, limits, dedicated options, pricing model, Alpenglow bank_id support and SOC 2.
• Where: each provider's own docs, product, pricing and blog pages, nothing else. Where a provider's pages don't state something, the table says "not published".
• When: 28 October 2026. These details change often. QuickNode folded gRPC into two plans in June and set a port to sunset on 1 October, so check the linked page before you buy.
• Latency is not compared. No two providers publish measurements taken the same way, from the same place, at the same time. Where a provider makes a speed claim, we quote it as that provider's claim, and the test section shows how to measure.
• No prices. Plans aren't like for like and prices change; each section links the provider's pricing page.
• Not covered in this round: GetBlock, dRPC and RPC Fast also document Yellowstone gRPC.

Yellowstone gRPC providers compared

Checked 28 October 2026.

AllenHark Yellowstone gRPC

AllenHark serves Yellowstone gRPC from Frankfurt and Amsterdam on port 10001. You connect from an IP address on your allowlist, or, on new subscriptions, send your API key in the x-token header. You can buy a day pass, a week or a month of gRPC Standard, where each connection is one Subscribe stream with 500 accounts per subscription, or gRPC Dedicated, which has no rate limits and no account limit and whose stream count is set with our team. Plans are prepaid with no usage billing, paid on-chain in USDC, USDT or SOL. Your SubscribeRequest reaches the node unchanged, no stream is shared with another customer, and streams are Alpenglow-ready: they carry bank_id today.

Three things to know. from_slot replays about 48 hours back, so a client can recover from a long outage, not only a reconnect gap; of the providers here, only Triton's Fumarole keeps longer. Both regions are in Europe, so a team running in the US or Asia will usually do better with a provider that has an endpoint near its servers. The endpoint serves Subscribe, SubscribeReplayInfo and the unary methods such as GetSlot and GetLatestBlockhash, but not SubscribeDeshred or SubscribeGossip.

For data earlier than any gRPC stream can deliver, pair it with AllenHark shreds or Jito Shreds, the drop-in replacement for Jito ShredStream. To send, AllenHark Relay lands transactions in the same block, at 0.1 ms over QUIC.

Sources: product page, docs, method reference, pricing.

Triton One (Dragon's Mouth)

Triton maintains the open-source Yellowstone gRPC code, and Dragon's Mouth is its hosted version, authenticated with an x-token header. Dragon's Mouth replays "recently buffered updates" with from_slot, but the docs don't state the window; SubscribeReplayInfo returns the first available slot. For longer gaps, Fumarole "stores up to 4 days of historical state" and lets a client resume from its last position; it is on by default for mainnet subscriptions, with regional clusters in Amsterdam and New York. Triton's Alpenglow guide says most updates "now carry a bank_id" and that block footers come over gRPC. Pricing is pay-as-you-go from a prepaid deposit, with streaming billed by bandwidth; dedicated nodes are a separate option.

Sources: Dragon's Mouth docs, Fumarole, Solana products, Alpenglow guide, pricing. Checked 28 October 2026.

Helius (LaserStream)

LaserStream is "wire-compatible with the open Yellowstone gRPC protocol", with nine regional endpoints, the most here. It replays about 48 hours (roughly 691,200 slots) through fromSlot; replays older than about 20 minutes return finalized data only. Helius says LaserStream connects to multiple Solana nodes and deduplicates their data before it reaches your stream. Mainnet needs a Business plan (up to 10 concurrent gRPC connections) or Professional (up to 100); data is metered in credits, and Professional plans can buy a monthly data allowance instead. Helius Dedicated Nodes trade that replay and redundancy for no rate limits and no credits, in one location. Helius holds SOC 2 Type II, audited by Sensiba LLP, and says LaserStream at processed "is the fastest way to receive account and program updates", its own claim; it also publishes a latency-measurement guide.

Sources: LaserStream docs, endpoints, historical replay, delivery guarantees, FAQ, plans, LaserStream vs dedicated nodes, SOC 2, pricing. Checked 28 October 2026.

QuickNode (Solana gRPC)

QuickNode now calls its Yellowstone-compatible stream Solana gRPC. Since 1 June 2026 it is included on Scale and Business, and Build and Accelerate can still buy it as a paid add-on; usage is metered on data delivered, in API credits. It runs on port 443 with an x-token header, the token from your endpoint URL. Port 10000, the legacy port that metered uncompressed data, was due to sunset on 1 October 2026, so older configs should move to 443. Replay covers "about the last 11 minutes of slots", and QuickNode lists JFK, EWR, FRA, IAD and NRT. Its docs say updates carry a node-local bank_id, never to be compared across connections, which needs yellowstone-grpc-proto 13.0.0 or later. The Enterprise plan adds dedicated clusters and lists SOC 1 and SOC 2 Type 2.

Sources: Solana gRPC docs, subscribeReplayInfo, subscribe, June 2026 plan change, pricing. Checked 28 October 2026.

Chainstack (Yellowstone gRPC Geyser Plugin)

Chainstack sells the Yellowstone gRPC Geyser Plugin as a paid add-on from the Growth plan, on Solana mainnet only, in monthly tiers of 2, 7 or 25 concurrent streams. The Global Node endpoint uses TLS on port 443, and the x-token is the node's existing auth token, so a working RPC endpoint already has it. from_slot holds about the last 100 slots, which Chainstack describes as "for reconnection recovery, not historical backfill"; a Dedicated Node can have a larger buffer and custom limits. The docs publish per-request filter caps, such as 5 account filters, 20 transaction filters and 200 keys per list, so check them against your subscriptions. Chainstack says it reached SOC 2 Type II on 22 December 2025.

Sources: Geyser plugin docs, stream tiers, SOC 2, pricing. Checked 28 October 2026.

Alchemy (Alchemy gRPC)

Alchemy promises "Drop-in Yellowstone compatibility" in four regions: US East, US West, EU Central and Asia-Pacific. from_slot replays "any slot within the last 6000 slots", and Alchemy says each subscription is fanned across multiple upstream nodes. It is priced per TB streamed on Pay as You Go, with no plan prerequisite, and is custom on Enterprise. Alchemy calls it "The fastest and most reliable Yellowstone-compatible gRPC" and links GeyserBench, a benchmark tool on GitHub, though the page shows no results. It says it is SOC 2 Type II certified, with a public Trust Center.

Sources: Solana gRPC page, Yellowstone gRPC docs, pricing, security post. Checked 28 October 2026.

Shyft (Yellowstone gRPC)

Shyft lists six live regions (New York, Ashburn, London, Frankfurt, Amsterdam and Singapore) with Tokyo coming, and backfills up to 150 slots on reconnect. It authenticates with an x-token from the dashboard, or with an IP whitelist if you can't use a token. Its Build, Grow and Accelerate plans are flat monthly fees with "no credit system and no metering on bandwidth", allowing 10, 20 or 50 connections, with more sold in blocks of 10. Dedicated gRPC Nodes have no rate, connection or filter limits, and Shyft claims a "4–20 ms speed advantage over baseline shared nodes". Its gRPC docs also link a public dashboard of lag by region.

Sources: Yellowstone gRPC page, gRPC docs, pricing, dedicated nodes. Checked 28 October 2026.

How to test a provider yourself

A short test on your own server tells you more than any comparison table. Run three checks from the server you will trade from, for hours rather than minutes:

1. Slot arrival. Open streams to two providers from the same machine and record when each one first shows every slot. Both timestamps come from one clock, so there is nothing to synchronise. Compare the median and the p99, at the commitment level you actually use.
2. Missed events. Record every signature a stream delivers for one account, then ask an RPC node for that account's signatures over the same slots. A signature the RPC node has and the stream doesn't is a missed event. A gap in slot numbers is not proof by itself, because leaders skip slots; check those with getBlocks.
3. Reconnects. Cut the connection for a few seconds, then for a minute, and resubscribe with from_slot set to the last slot you saw. See whether the missed signatures arrive, whether duplicates do (dedupe by signature), and what error comes back when the slot is older than the window. SubscribeReplayInfo tells you the first slot a provider can still replay.

A sketch in TypeScript, using Triton's Yellowstone client:

// Two Yellowstone endpoints, one server: slot arrival, missed signatures, reconnects.
// A sketch for testing, not production code. Run as an ES module.
import Client, { CommitmentLevel, SubscribeRequest } from "@triton-one/yellowstone-grpc";
import { Connection, PublicKey } from "@solana/web3.js";
import bs58 from "bs58";

const ACCOUNT = process.env.WATCH_ACCOUNT!; // a program or wallet you care about
const rpc = new Connection(process.env.RPC_URL!, "confirmed");
const endpoints = {
  a: { url: process.env.A_URL!, token: process.env.A_TOKEN },
  b: { url: process.env.B_URL!, token: process.env.B_TOKEN },
};
type Name = keyof typeof endpoints;
const names: Name[] = ["a", "b"];

const firstSeen = new Map<string, Partial<Record<Name, number>>>(); // slot -> first sight per stream
const sigs = { a: new Set<string>(), b: new Set<string>() };
const startSlot: Partial<Record<Name, number>> = {};
const lastSlot: Partial<Record<Name, string>> = {};
const reconnects = { a: 0, b: 0 };

const request = (fromSlot?: string): SubscribeRequest => ({
  slots: { s: { filterByCommitment: false } },
  transactions: {
    t: { vote: false, failed: false, accountInclude: [ACCOUNT], accountExclude: [], accountRequired: [] },
  },
  accounts: {}, transactionsStatus: {}, entry: {}, blocks: {}, blocksMeta: {}, accountsDataSlice: [],
  commitment: CommitmentLevel.CONFIRMED,
  fromSlot, // after a reconnect: resume from the last slot seen, if the provider still has it
});

async function run(name: Name, client: Client, fromSlot?: string) {
  const stream = await client.subscribe();
  let restarting = false;
  const restart = () => {
    if (restarting) return;
    restarting = true;
    reconnects[name]++;
    setTimeout(() => run(name, client, lastSlot[name]), 1_000);
  };
  stream.on("data", (u) => {
    const now = performance.now(); // one clock for both streams
    if (u.slot) {
      const seen = firstSeen.get(u.slot.slot) ?? {};
      seen[name] ??= now;
      firstSeen.set(u.slot.slot, seen);
      startSlot[name] ??= Number(u.slot.slot);
      lastSlot[name] = u.slot.slot;
    }
    const sig = u.transaction?.transaction?.signature;
    if (sig) sigs[name].add(bs58.encode(sig));
  });
  stream.on("error", (e) => { console.error(name, e.message); restart(); });
  stream.on("end", restart);
  stream.write(request(fromSlot));
}

for (const name of names) {
  const { url, token } = endpoints[name];
  const client = new Client(url, token, { grpcMaxDecodingMessageSize: 64 * 1024 * 1024 });
  await client.connect();
  run(name, client);
}

// Every minute: how much later B sees a slot than A, in ms (negative means B was first).
setInterval(() => {
  const d = [...firstSeen.values()]
    .filter((s) => s.a !== undefined && s.b !== undefined)
    .map((s) => s.b! - s.a!)
    .sort((x, y) => x - y);
  const at = (p: number) => d[Math.floor((d.length - 1) * p)]?.toFixed(2);
  console.log("slots", d.length, "median", at(0.5), "p99", at(0.99), "reconnects", reconnects);
}, 60_000);

// Every ten minutes: signatures the RPC node has for ACCOUNT that a stream never delivered.
setInterval(async () => {
  const onChain = await rpc.getSignaturesForAddress(new PublicKey(ACCOUNT), { limit: 1000 });
  for (const name of names) {
    const from = (startSlot[name] ?? Infinity) + 50; // skip the warm-up
    const to = Number(lastSlot[name] ?? 0) - 50; // give confirmation time to land
    const inRange = onChain.filter((s) => !s.err && s.slot > from && s.slot < to);
    const missed = inRange.filter((s) => !sigs[name].has(s.signature));
    console.log(name, "missed", missed.length, "of", inRange.length);
  }
}, 600_000);

On a busy account, 1,000 signatures may cover only a few seconds; page back with before, or watch a quieter account.

FAQ

Will my Yellowstone client work with every provider?

Mostly, yes. Helius calls LaserStream "wire-compatible", Alchemy "Drop-in", and QuickNode "Yellowstone-compatible". When you switch, check the endpoint and port, the credential (an x-token header at most providers, written X-Token by Alchemy; AllenHark takes an allowlisted IP or an x-token API key) and which methods are served: AllenHark, for example, does not serve SubscribeDeshred.

How far back can a stream replay with from_slot?

It ranges from about 100 slots (Chainstack Global Nodes), through 150 slots (Shyft), about 11 minutes (QuickNode) and 6,000 slots (Alchemy), to about 48 hours (AllenHark and Helius) and up to four days through Triton's Fumarole. For anything older, use RPC methods such as getBlock and getTransaction.

Is Yellowstone gRPC ready for Alpenglow?

The protocol is: updates can carry a bank_id that says which candidate block they belong to. AllenHark streams carry it today, and QuickNode and Triton document it. The value is local to each node, so QuickNode and Triton both say never to compare it across connections. Triton's guide lists the minimum client versions to upgrade to.

Do I need dedicated gRPC?

Usually not at first. Shared plans cap streams, connections or accounts per subscription, and dedicated plans lift some or all of those caps; AllenHark Dedicated gRPC has no rate limits and no account limit. Check what else changes: Helius says its Dedicated Nodes have no historical replay and run in a single location, in exchange for no rate limits and no credits.

Is gRPC the fastest way to see Solana data?

No. A gRPC stream reports transactions once a node has executed them, while shreds are the pieces of the leader's block as they travel over Turbine, before any node replays them, so they arrive earlier. See shreds vs gRPC vs RPC WebSockets and gRPC and shreds vs transaction landing. For the RPC side of the stack, read our Solana RPC provider comparison.

Try AllenHark Yellowstone gRPC

Frankfurt or Amsterdam, access by allowlisted IP or x-token API key, bank_id for Alpenglow, and a Dedicated plan with no rate limits. See the gRPC product page, the setup docs, the method reference and pricing.