See the trade before replay

TxStream sends decoded transactions from shreds, first in 99.8% of matched races vs Yellowstone gRPC
99.8%

TxStream first against Yellowstone gRPC in matched races, one benchmark run

5.02 ms

Median lead over Yellowstone gRPC when TxStream arrives first

~95%

Transaction-status accuracy of real-time simulation

64

Max transactions per message on the batch stream, sent without waiting to fill

One request format,
three ways to take it

Decoded transactions with filters, an opt-in simulated outcome, or batches for volume. Same request format, same endpoint

Decoded transactions, filtered on our side

RPC Fast reconstructs, recovers, deshreds, decodes and filters in one path, before replay metadata is available. You filter by vote status, signature and included, excluded or required accounts before data crosses the network. Lookup-table addresses arrive when resolved, and the alt_resolution field marks full or partial resolution.

TxStream docs

Vote, signature and account filters

Lookup tables when available, full or partial

signatures_only for timing workloads

Real-time simulation, opt-in

Add simulation_config and each matching transaction comes with a simulation result: predicted status, plus an error when it fails. If capacity or bank state runs short, the status says no outcome is available. Switch on the details you need: compute units, logs, account and token balance deltas, CPI instructions, return data. Status matches the actual execution in approximately 95% of cases. Streams without simulation stay on the immediate path.

Simulation docs

 ~95% on transaction status

Pick only the details you need

791 µs median cost, full payload

Batches for high throughput

The batch stream sends up to 64 matching transactions per message as soon as they are available, without waiting for the batch to fill. Fewer protobuf and gRPC messages for high-volume consumers; the single stream stays the pick for the lowest per-transaction delay.

Batch docs

SubscribeTransactionBatches

Order kept within and across batches

Same filters and simulation

Who arrives first, with the method

Arrival races from one 3-minute run on August 25, 2026: one observer, local receive clock, one account filter, only signatures both streams delivered

TxStream vs Yellowstone gRPC

First on 99.8%

Median lead 5.02 ms, 17.08 ms at p95. 103,073 shared transactions.

TxStream vs ShredStream gRPC

Neck and neck

ShredStream first on 50.9%, TxStream on 49.1% of 58,688 shared transactions. ShredStream's median lead: 30 µs.

Cost of simulation

+791 µs median

Median

p90

Full payload

791 µs

1.62 ms

Signatures only

832 µs

1.72 ms

Matched-signature comparison: simulation on against the same stream without it.

›

Coverage in this run: TxStream 99.9%, Yellowstone gRPC 100.0%, ShredStream 56.9% because the benchmark collector does not resolve lookup tables. Coverage describes this run and filter, not a general availability guarantee.

Who TxStream is built for

Take decoded transactions to skip building a shred decoder. Add simulation when a wasted transaction costs more than the added microseconds
Decoded transactions

HFT bot developers, trading platforms, wallets tracking pending transactions, analytics and copy-trading platforms. No shreds to decode, no transactions to reconstruct.

Real-time simulation

MEV searchers, arbitrage and liquidation bots, market makers and risk engines. Fewer wasted transactions and false positives before block inclusion.

TxStream next to the other feeds

Need confirmed metadata, account updates or blocks? That is Yellowstone gRPC.

Per feed
TxStream
ShredStream gRPC
Yellowstone gRPC
Source
TxStream
Validator shreds, before replay
ShredStream gRPC
Validator shreds
Yellowstone gRPC
Geyser, after replay
What arrives
TxStream
Compact decoded transaction
ShredStream gRPC
Solana Entry stream
Yellowstone gRPC
Accounts, slots, transactions, blocks, entries
Filtering
TxStream
Server-side: vote, signature, accounts
ShredStream gRPC
Client-side only
Yellowstone gRPC
Server-side, AND / OR
Lookup tables
TxStream
Resolved when available
ShredStream gRPC
Your code resolves them
Yellowstone gRPC
Replay-derived
Simulation
TxStream
Opt-in, ~95% on tx status
ShredStream gRPC
No
Yellowstone gRPC
No
Built for
TxStream
HFT, trading bots, real-time simulation
ShredStream gRPC
Custom low-level pipelines
Yellowstone gRPC
Indexers, analytics, alerting
Plan
TxStream
Aperture, 25 streams
ShredStream gRPC
Aperture, 10 streams
Yellowstone gRPC
Stream 10, Aperture 25

TxStream is on the Aperture plan

$499 a month, up to 25 TxStream streams. Start free on the Solana API first, no card
Per plan
Focus
$45 a month
Stream
$249 a month
Aperture
$499 a month
RPC rate limit
Start
15 req/s
Focus
50 req/s
Stream
150 req/s
Aperture
500 req/s
Aperture TxStream
Start
Focus
Stream
Aperture
25 streams
ShredStream gRPC
Start
Focus
Stream
Aperture
10 streams
Yellowstone gRPC
Start
Focus
Stream
10 streams
Aperture
25 streams
Support, first answer
Start
Community
Focus
Email, 24h
Stream
Email, 12h
Aperture
Priority chat, 8h

Support times are the first answer during support chat hours; outside them requests go best effort.

What TxStream does not do

Worth knowing before you plan the integration.

TxStream is an early feed: a streamed transaction can still fail, never confirm or land on a fork
The pre-execution stream has no confirmed balances, inner instructions, rewards, execution status or final program logs
Lookup-table addresses arrive when resolved: your code must tolerate unresolved ones
Simulation adds latency, and its results are predictions that can differ from the final execution
With simulation on, the single stream can deliver out of order (index keeps the original order); a batch waits for its slowest simulation
Reconnect after transport failures: the official Rust client does it with exponential backoff

See the transaction before replay

Start free. TxStream opens on Aperture with up to 25 streams.

Aperture TxStream FAQ

TxStream vs Yellowstone gRPC: what is the difference?

TxStream is built from validator shreds and sends decoded transactions before replay metadata is available. Yellowstone gRPC comes from the Geyser interface after validator processing and carries confirmed execution metadata, account updates and blocks. Use TxStream for arrival time, Yellowstone gRPC for confirmed state.

Can I simulate Solana transactions inside a gRPC stream?

Yes, as an option: simulation is off until you add simulation_config to the request and pick the details you need: compute units, logs, account and token deltas, inner instructions, return data. Transaction-status accuracy is approximately 95% compared with actual execution results.

Can I get Solana transactions in batches over gRPC?

Yes. SubscribeTransactionBatches sends up to 64 matching transactions per batch, without waiting for the batch to fill, so you get fewer gRPC messages. For the lowest per-transaction delay, use SubscribeTransactions. Filters, signatures_only and simulation work in both.

How do I connect to the TxStream gRPC endpoint?

Point the official Rust client, dysnix/aperture-grpc-client, at aperture-txstream.rpcfast.com:443 with your token in X-Token. It handles keepalives and reconnection; simulation needs client 0.6.1 or later. For a quick test, grpcurl with the official txstream.proto works too.

How much does Aperture TxStream cost?

$499 a month on the Aperture plan, with up to 25 TxStream streams, 10 ShredStream gRPC streams and 25 Yellowstone gRPC streams. The shared infrastructure runs in Frankfurt, Equinix FR13.

We use cookies to personalize your experience