First public endpoint dropping May 31 — follow us on X for mint details
live @ 87 ms
Edge Benchmark gRPC Contact

Koltra

Sub-block Solana data. Shreds intercepted at the leader, decoded and streamed to your app in real time.

solana realtime global

How it works

Most data providers sit downstream of the validator network – they receive finalized blocks and relay them onward. By then, you're already behind.

Koltra connects to leader validators and intercepts shreds as they're produced, before the block is formed.

STEP 01

Shred interception

Leader validators stream shreds directly to Koltra – before block finalization.

STEP 02

Decode & reconstruct

Raw shreds decoded and reassembled live. No gossip delay, no waiting for finalization.

STEP 03

Stream to your app

Forwarded instantly after reconstruction – via decoded shred stream or gRPC.

Edge

Standard Geyser gRPC and shared RPC providers are downstream by design. They receive finalized blocks through gossip propagation – usually over a second, longer under load.

Running your own validator helps, but even dedicated nodes receive blocks through normal propagation, so delays persist.

Koltra receives shreds directly from leader validators as they are produced. Transactions can be decoded and delivered before block confirmation, under 400 ms always, under 150 ms most of the time.

Benchmark

We compared Koltra to the most common ways to access Solana transactions. The numbers below show real-world transaction discovery latency.

Shared RPCs
1.5-3sec
Slow, crowded endpoints; transactions arrive late.
Yellowstone gRPC
0.6-1.5sec
Shared Geyser gRPC, not stable, no real-time.
Dedicated Nodes
0.3-1.5sec
High cost, lower latency, still sub-optimal for low-latency needs.
Koltra
40-400ms
Real-time transaction streaming, zero-block latency.
Cumulative transaction discovery rate
* % of transactions discovered by time @ 10,000 txns
Koltra
Competitor
1-block limit
PROVIDER
— ms
—
<150ms
average latency
6
global regions
7
enterprise clients

Integration

Already on Yellowstone or Laserstream? Koltra's gRPC endpoint is protocol‑identical – swap the URL and you're done. No new SDKs, no migration cost.

For teams that need every millisecond, shred stream delivers decoded transactions before the block is formed.

Drop-in compatible with Helius Laserstream, Jito Shredstream, Yellowstone gRPC, and others.

Rust
TypeScript
1234567891011121314
use koltra::{ShredStream, ShredStreamConfig};
use std::env;
 
let stream = ShredStream::new(ShredStreamConfig {
    endpoint: env::var("KOLTRA_ENDPOINT")?,
    api_key:  env::var("KOLTRA_API_KEY")?,
});
 
stream.on_transaction(|tx| {
    println!("pre-block: {}", tx.signature);
});
 
stream.connect().await?;
12345678910111213
import { ShredStream } from "@koltra/shredstream";
 
const stream = new ShredStream({
    endpoint: "fra.koltra.xyz",
    apiKey:   "YOUR_API_KEY",
});
 
stream.on("transaction", (tx) => {
    // fires before block finalization
    console.log("pre-block:", tx.signature);
});
 
await stream.connect();
12345678910111213141516171819
use yellowstone_grpc_client::{
    GeyserGrpcClient, CommitmentLevel,
};
 
let mut client = GeyserGrpcClient::connect(
    "https://fra.koltra.xyz",
    Some("YOUR_API_KEY".to_string()),
    None,
).await?;
 
let mut stream = client
    .subscribe_once(
        HashMap::new(),
        Some(CommitmentLevel::Processed),
    ).await?;
 
while let Some(msg) = stream.next().await {
    println!("{:?}", msg?.transaction);
}
123456789101112131415161718
import Client, { CommitmentLevel }
    from "@triton-one/yellowstone-grpc";
 
const client = new Client(
    "fra.koltra.xyz:2053",
    "YOUR_API_KEY"
);
 
const stream = await client.subscribe();
 
stream.on("data", ({ transaction }) => {
    if (transaction)
        console.log(transaction.signature);
});
 
await stream.write({
    transactions: { client: { vote: false } },
    commitment:  CommitmentLevel.PROCESSED,
});

Koltra-enabled gRPC

Real-time gRPC for accounts, transactions, and slots. Fully compatible with existing Yellowstone deployments – get ultra-low-latency updates with zero code changes.

Get started

Koltra is available to a limited number of teams.
Share your email and we’ll reach out when slots open.