HyperStreams: the Solana gRPC stream rebuilt for latency
HyperStreams is NoLimitNodes’ ultra low-latency Solana gRPC stream, a drop-in replacement for your existing stream: same interface, new endpoint, no code changes. It does not run on a Solana node. It is a purpose-built binary fed by ultra low latency shreds from several providers. $250 a month, included in Max and Enterprise.
- Same interface, new endpoint, no code changes
- A purpose-built binary, not a Solana node
- Fed by ultra low latency shreds from several providers
The whole migrationone line
"grpc.mainnet.solana.nolimitnodes.com:443""YOUR_HYPERSTREAMS_ENDPOINT"Same interface. No code changes.
$250 a monthor included in Max
Max, $300/mo, includes it, with HyperShreds and higher limits than Ultra. Enterprise includes it too.
- 1Start. A gRPC stream on a node: shreds come in, pass through a full Solana node and its plugin interface, and leave through a gRPC server.
- 2Strip. We rewrote the Solana validator and the gRPC layer and stripped out everything the stream does not need.
- 3Rebuild. What is left is one purpose-built binary, built for one thing: gRPC performance.
Why HyperStreams is fast: it was rebuilt, not tuned
Four rules the whole stack is built on.
- 01
Rewritten, not tuned.
We rewrote the Solana validator and the gRPC layer, stripped everything out, and rebuilt it for one thing: gRPC performance.
- 02
Every millisecond not required is eliminated.
If a stage is not needed to deliver a gRPC update, it is not in the path.
- 03
Every low-level optimization that can be done is being done.
The work is at the lowest level, and it does not stop at launch.
- 04
Every hardware optimization that can be made will be made.
The fastest enterprise-grade CPUs we can buy, from well-connected providers, and then everything beyond that.
Not a node. A binary built for one job.
A typical gRPC stream is served from inside a full Solana node, through its Geyser plugin interface. HyperStreams is not. We rewrote the validator and the gRPC layer and rebuilt them as one purpose-built binary, so nothing in the path exists for any reason except to deliver your updates.
| Topic | A gRPC stream on a node | HyperStreams |
|---|---|---|
| What runs it | A full Solana node, reached through its Geyser plugin interface | A purpose-built binary. Not a node. |
| Built for | Everything a node does | One thing: gRPC performance |
| Fed by | What the node receives from the network | Ultra low latency shreds from several providers (HyperShreds) |
| Interface | Yellowstone gRPC | The same interface |
| To switch | Nothing to do | Change the endpoint. No code changes. |
| Tuning | General purpose | Every low-level and hardware optimization that can be made |
The left column describes a typical gRPC stream served from a Solana node through the Geyser plugin interface, which is how Yellowstone gRPC works.
Ultra low latency, end to end
The speed is not one trick. It is every stage in a row: shreds in, one binary, your server. Switch the last stretch and watch what changes.
Over the public internet, the last stretch crosses networks we do not run.
- 1Shreds in. Fed by HyperShreds: ultra low latency shreds from several providers.
- 2One binary. A purpose-built binary turns them into gRPC updates. There is no node in the path.
- 3Your server. Anywhere, over the public internet. Or a VPS with us, reached over our private network, so the path is ultra low latency end to end.
The shreds come from HyperShreds. Want the whole path on one network? Run your bot on a VPS with us and HyperStreams reaches it over our private network.
The fastest silicon we can buy
We buy the fastest enterprise-grade CPUs we can get, from well-connected providers, and we do not stop there: every hardware optimization that can be made will be made.
- CPUs
- The fastest enterprise-grade CPUs we can buy
- Hosted by
- Well-connected providers
- Fed by
- HyperShreds: ultra low latency shreds from several providers
- Your side
- A private network to any VPS you run with us
- Next
- Every hardware optimization that can be made will be made
The people behind HyperStreams
The team behind HyperStreams includes some of the smartest people in the world, with backgrounds at top computer science research institutions like the University of Toronto.
Low-level performance work is what they do.
Same interface. New endpoint.
One line changes. Your subscriptions, filters, handlers and reconnect logic stay exactly as they are.
const client = new Client("grpc.mainnet.solana.nolimitnodes.com:443", "YOUR_API_KEY", {const client = new Client("YOUR_HYPERSTREAMS_ENDPOINT", "YOUR_API_KEY", { grpcMaxDecodingMessageSize: 64 * 1024 * 1024,});
await client.connect();const stream = await client.subscribe();
// your subscriptions and handlers stay exactly as they arechannel = grpc.secure_channel("grpc.mainnet.solana.nolimitnodes.com:443", credentials=combined_creds)channel = grpc.secure_channel("YOUR_HYPERSTREAMS_ENDPOINT", credentials=combined_creds)stub = geyser_pb2_grpc.GeyserStub(channel)
# your subscriptions and handlers stay exactly as they areNew to the interface? The Yellowstone gRPC overview and client setup cover it.
Do not take our word for it: race it
Point one subscription at the endpoint you use today and one at HyperStreams, run this for a minute on the server you trade from, and it prints which endpoint delivered each slot update first. One clock times both.
// slot_race.mts: which of two gRPC endpoints delivers each slot update first?// npm i @triton-one/yellowstone-grpc, set NLN_API_KEY and HYPERSTREAMS_ENDPOINT, then: npx tsx slot_race.mts [seconds]import Client, { CommitmentLevel } from "@triton-one/yellowstone-grpc";
const ENDPOINTS: Record<string, string> = { current: process.env.CURRENT_ENDPOINT ?? "grpc.mainnet.solana.nolimitnodes.com:443", hyperstreams: process.env.HYPERSTREAMS_ENDPOINT ?? "", // the endpoint we give you};const TOKEN = process.env.NLN_API_KEY;const SECONDS = Number(process.argv[2] ?? 60);if (!ENDPOINTS.hyperstreams) throw new Error("Set HYPERSTREAMS_ENDPOINT to the endpoint we gave you");
const seen = new Map<string, Record<string, bigint>>(); // "slot:status" -> endpoint -> first arrival, nsconst updates: Record<string, number> = {};
for (const [name, url] of Object.entries(ENDPOINTS)) { updates[name] = 0; const client = new Client(url, TOKEN, { grpcMaxDecodingMessageSize: 64 * 1024 * 1024 }); await client.connect(); const stream = await client.subscribe(); stream.on("data", (update) => { const now = process.hrtime.bigint(); if (!update.slot) return; const key = `${update.slot.slot}:${update.slot.status}`; const arrivals = seen.get(key) ?? {}; arrivals[name] ??= now; seen.set(key, arrivals); updates[name]++; }); stream.write({ slots: { race: {} }, commitment: CommitmentLevel.PROCESSED, accounts: {}, transactions: {}, transactionsStatus: {}, blocks: {}, blocksMeta: {}, entry: {}, accountsDataSlice: [], });}
await new Promise((done) => setTimeout(done, SECONDS * 1000));
const [a, b] = Object.keys(ENDPOINTS);const both = [...seen.values()].filter((v) => v[a] !== undefined && v[b] !== undefined);console.log("slot updates received:", updates);console.log("slot updates seen on both endpoints:", both.length);for (const [first, second] of [[a, b], [b, a]]) { const lead = both.filter((v) => v[first] < v[second]).map((v) => Number(v[second] - v[first]) / 1e6).sort((x, y) => x - y); if (lead.length) { const p95 = lead[Math.min(lead.length - 1, Math.floor(lead.length * 0.95))]; console.log(`${first} first on ${Math.round((100 * lead.length) / both.length)}% of them: median ${lead[lead.length >> 1].toFixed(2)} ms ahead, 95th percentile ${p95.toFixed(2)} ms`); }}process.exit(0);npm i @triton-one/yellowstone-grpcexport NLN_API_KEY=your_keyexport HYPERSTREAMS_ENDPOINT=your_endpointnpx tsx slot_race.mts 60slot updates received: { current: …, hyperstreams: … }slot updates seen on both endpoints: …hyperstreams first on …% of them: median … ms ahead, 95th percentile … ms- Both endpoints stream the same slot updates at the same commitment, so each update is matched by its slot and status.
- Run it on the server you will trade from. Latency depends on where that server sits.
- The counts tell you if an endpoint is not delivering before you read anything into the rest.
Included in Max and Enterprise. $250 a month on Pro and Ultra
HyperStreams uses your plan’s gRPC streams, so you get the same number of streams on either endpoint.
HyperStreams is $250/mo on Pro and Ultra. Max and Enterprise include it.
Pro
2 gRPC streams
Pro $49/mo + HyperStreams
$299/mo
Ultra
10 gRPC streams
Ultra $199/mo + HyperStreams
$449/mo
Max
15 gRPC streams
HyperStreams included
$300/mo
Enterprise
20 gRPC streams
HyperStreams included
$500/mo
Move to HyperStreams in three steps
- 1
Get HyperStreams
Take Max or Enterprise, or add HyperStreams to Pro or Ultra for $250 a month.
- 2
Take the endpoint we give you
We switch HyperStreams on for your account and give you its endpoint.
- 3
Change one line
Point your existing client at the new endpoint. Same interface, no code changes.
HyperStreams: questions
Not here? Email [email protected] or talk to sales.
What is HyperStreams?
HyperStreams is NoLimitNodes’ ultra low-latency Solana gRPC stream. It is a drop-in replacement for your existing gRPC stream: same interface, new endpoint, no code changes. Under the hood it is a purpose-built binary rather than a Solana node, fed by ultra low latency shreds from several providers. It costs $250 a month, and Max and Enterprise include it.
Is HyperStreams a Solana node?
No. We rewrote the Solana validator and the gRPC layer, stripped everything out, and rebuilt it as one purpose-built binary for one thing: gRPC performance. A typical gRPC stream is served from inside a full Solana node through its plugin interface. HyperStreams is not.
How is HyperStreams different from a standard Yellowstone gRPC stream?
The interface is the same. What runs behind it is not. A standard stream is served from a full Solana node through the Geyser plugin interface. HyperStreams is a purpose-built binary, fed by ultra low latency shreds, tuned at the lowest level, and run on the fastest enterprise-grade CPUs we can buy.
Is it really a drop-in replacement?
That is the design: same interface, new endpoint, no code changes. You change the endpoint in your client and keep your subscriptions, filters and handlers. Run the race script on this page to compare the two endpoints on your own traffic.
What feeds HyperStreams?
Ultra low latency shreds from several providers, delivered by HyperShreds. HyperShreds is also a product you can buy for your own servers, for $250 a month or included in Max and Enterprise.
How fast is HyperStreams?
We do not publish a single number, because latency depends on where your server sits and the route to it. HyperStreams is built so that every millisecond not required is eliminated. Measure it yourself: the script on this page prints which of two endpoints delivered each slot update first, from your own machine.
What hardware does HyperStreams run on?
The fastest enterprise-grade CPUs we can buy, from well-connected providers. Every hardware optimization that can be made will be made.
Does it work with a VPS I run with you?
Yes. If you have a VPS with us, HyperStreams reaches it over our private network, so the path is ultra low latency end to end.
How much does HyperStreams cost?
$250 a month, or $2,500 a year with two months free. Max ($300 a month) and Enterprise ($500 a month) include it. On Pro and Ultra you add it for $250 a month.
How many streams can I run on HyperStreams?
The same number as your plan’s gRPC streams: 2 on Pro, 10 on Ultra, 15 on Max and 20 on Enterprise. HyperStreams streams count toward that limit, so you can run them on either endpoint.
Can I use HyperStreams with HyperShreds?
Yes. They are separate products. HyperShreds sends raw shreds to a server you control. HyperStreams turns shreds into a gRPC stream for your application. Max and Enterprise include both.
Who builds HyperStreams?
A team that includes some of the smartest people in the world, with backgrounds at top computer science research institutions like the University of Toronto. Low-level performance work is what they do.
How do I start?
Take Max or Enterprise, or add HyperStreams to Pro or Ultra for $250 a month. We switch it on for your account and give you the endpoint. Then point your existing client at it.
$250 a month. Included in Max.
Same interface, new endpoint. Every millisecond not required, eliminated. $2,500 a year if you pay yearly.
Questions first? Email [email protected] or talk to sales.