Solana token-launch trading with Aperture TxStream and concurrent delivery

Written by:

Olha Diachuk

6

min read

Date:

November 20, 2026

Updated on:

November 20, 2026

An anonymous Solana trading team uses RPC Fast to detect token launches, feed its trading logic, and submit response transactions through concurrent delivery routes. Its challenge is keeping the path from an incoming event to a trading decision short while maintaining enough execution data and recorded evidence to verify what happened afterward.

The system runs on customer-owned bare metal in the same Frankfurt data center as its RPC Fast endpoint. Aperture TxStream supplies early transaction data, Yellowstone supplies execution observations, and Solana RPC supports checks and reconciliation outside the immediate trading path.

Need an infrastructure solution for your trading bot?

Contact RPC Fast

About the client: Token launches and bonding-curve trading

The team operates an automated strategy focused on sniping new token launches and trading along bonding curves. RPC Fast is its main provider for streaming, RPC access, and transaction delivery.

The customer owns the trading application, local state, strategy logic, and recording infrastructure. Its server runs Linux on an AMD Ryzen 9 9900X with 12 cores, 24 threads, and 96 GB RAM, hosted by CherryServers in Frankfurt.

That hardware runs the trading system; it is not presented as a customer-operated Solana RPC node. The deployment combines the team’s own application infrastructure with RPC Fast’s managed services.

The challenge: Act early and verify afterward

The team’s priorities extend beyond receiving a fast feed:

  • Low and predictable latency;
  • Complete delivery within the subscribed scope;
  • Fast recovery after reconnects;
  • Clear status information during issues;
  • Research data that reflects what the trading system observed.

A single transaction feed does not serve every purpose equally. Early transaction visibility helps the strategy react; execution observations establish what ran; finalized data supports reconciliation.

The architecture assigns those responsibilities to separate inputs. It also keeps synchronous RPC confirmation outside the CREATE-to-BUY path: the app does not require an RPC confirmation response before progressing through that latency-sensitive sequence. 

Production architecture: Distinct roles for each feed

The customer describes the core execution path as:

The data from the RPC Fast feeds, with the lowest possible latency, gave the client’s app plenty of time to decide and deliver their txs. Here are the other components, explained:

Component Role in this deployment Architectural consequence
TxStream Primary real-time feed, one message per transaction Feeds launch detection and early trading decisions
Yellowstone at processed commitment Live execution observations Updates the application with observed execution data
Yellowstone at finalized commitment Reconciliation against final on-chain state Separates immediate observations from final checks
Solana RPC Startup checks, background refresh, transaction lookups, subsequent reconciliation Supports application correctness without requiring synchronous confirmation on the immediate path
Beam and additional delivery integrations Concurrent transaction submission Avoids dependence on one delivery route
Customer-managed recordings Research and backtesting Preserves the inputs available to the live system

As developers of RPC Fast, we enjoy seeing such purposeful use of our products, powering the app with efficient trading logic.

So, the whole architecture will look like this:

The role of TxStream and its connections with the app

The client’s side app consumes TxStream in non-batch mode, receiving one transaction per gRPC message. Thus, it offers access to a decoded transaction feed reconstructed from shreds, before normal validator replay metadata is available. 

This leaves a separate responsibility inside the trading application: interpreting transaction instructions and extracting the information its strategy needs. Receiving decoded transaction structures does not remove the need for application-specific interpretation.

Our anonymous customer does not use TxStream’s optional real-time simulation. Shredstream is available in its standalone comparison and probe tooling, but it is not an input to the current trading runtime.

The case therefore shows a specific use of Aperture: early transaction delivery feeding local strategy logic.

Check Aperture pricing plan

Yellowstone and RPC support execution checks

Yellowstone supplies the live execution observations. Its finalized stream supports subsequent checks against final on-chain state.

RPC serves startup checks, background refresh, and reconciliation through methods including getTransaction and getSignatureStatuses. The client does not use WebSocket methods, high-cost account queries, or getProgramAccountsPaginated in this setup.

The operational distinction is timing: verification remains part of the system, but synchronous RPC confirmation is not a prerequisite on the CREATE-to-BUY path. A fast decision and a reconciled trading record are separate responsibilities.

Benefits of app co-location with its data source

The customer places its trading server in the same data center as the RPC Fast endpoint to keep the network-to-decision path short and stable.

That placement addresses one part of the latency budget. Transaction interpretation, strategy evaluation, signing, delivery, and on-chain execution remain separate stages.

For this deployment, the benefit is architectural: the team controls its application hardware and places it close to our service supplying its live inputs. 

Are there any best delivery providers for snipping project?

The team uses RPC Fast Beam sender across its configured delivery routes – Astralane, bloXroute, Nozomi, other paths, and Jito.

We use concurrent delivery rather than depending on a single provider. I would not name one provider as consistently best.

—CTO, anonymous trading team.

The customer uses Beam’s fastest mode and does not use its provider score feed. Both HTTP and persistent QUIC are integrated; the team has no controlled comparison establishing that one consistently performs better.

Beam supports HTTP and QUIC submission, with provider-specific routing. Here, concurrent delivery is the customer’s application-level choice, rather than evidence that Beam automatically selects a winning route. 

Data quality and structure for the bot

The customer records its streaming data independently. Each recording retains:

  • Original protobuf messages;
  • Receive timestamps;
  • Source and session identifiers;
  • Sequence information.

Messages are stored in compressed, time-partitioned segments with checksums and separate derived indexes. Older segments move to network storage.

This preserves more than transaction contents. Receive timestamps and sequence information help the team examine what information was available when the bot made a decision.

The resulting research dataset remains bounded by subscription filters and observed coverage. It is not a complete blockchain or wallet history. Historical research also uses other archival providers, so those lookups should not be attributed entirely to RPC Fast.

Why recorded arrival information matters

A final on-chain record answers what happened. A timestamped stream recording helps answer what the app knew when it acted.

For example, when reviewing a launch decision, the team has the original received messages and their timing to compare with the bot’s actual behavior. That supports investigation of differences between a historical strategy replay and live decisions.

Using the same source feeds improves comparability; it does not reproduce every condition of live execution. The distinction matters when interpreting backtest results: observed market inputs and achieved transaction execution are separate parts of the outcome.

Reliability: Monitor delivery quality, not only connectivity

The system runs 24/7 and continuously compares its streams with each other and with independent data. The team tracks delivery gaps, reconnects, and ordering.

This makes data quality an explicit operational concern. An open connection is insufficient evidence that the application received every expected event in the expected sequence.

The customer reports satisfaction with support and no negative experience with RPC or streaming services. Those statements reflect the interview; no observation period or measured uptime percentage was supplied.

Consolidating streaming, RPC, and part of transaction delivery with RPC Fast simplifies the team’s operations and monitoring. Independent comparisons remain part of its verification process.

Results: The customer’s perspective

The team reports the following satisfaction with the latency numbers:

Our median latency from trigger to finalized transaction is usually about 40-50ms.

—CTO, anonymous trading team.

The other benefits are a consistent result of carefully crafted architecture:

  • Early transaction inputs for token-launch trading.
  • A short, co-located path between the endpoint and trading application.
  • Concurrent submission across configured routes.
  • Production-feed recordings for research and comparison with actual decisions.
  • One primary provider for streaming, RPC, and transaction-delivery services.

When your workload needs a different infrastructure profile

This case study pairs customer-owned application hardware with RPC Fast’s managed endpoints. As traffic grows, the next step depends on what becomes constrained: service limits, node resources, or deployment requirements.

RPC Fast offers two options for these workloads: an Enterprise plan for custom limits, features, service combinations, and fallback arrangements; and dedicated nodes for isolated resources and node-level customization. 

These options also work together—for example, dedicated infrastructure with an Enterprise fallback service.

Enterprise plan Dedicated nodes
Core difference Tailors the service scope to your workload Allocates node infrastructure to your workload
Best fit Custom request or stream limits, additional features, or a specific service mix Sustained heavy queries, resource isolation, or custom plugins
What to define Required limits, included services, and fallback capacity Hardware capacity, node configuration, location, and redundancy
Main consideration Confirm the agreed limits and infrastructure scope Size resources for peak demand and plan failover

Dedicated-node configurations support custom plugins and data streams, with infrastructure sized around the workload. An Enterprise does not, by itself, ensure dedicated hardware; specify isolation explicitly when required.

If the existing endpoints meet your latency targets but request or subscription limits constrain growth, discuss Enterprise. If you need isolated capacity, custom Geyser plugins, or control over node configuration, evaluate dedicated nodes.

Build the trading path around distinct responsibilities

This project is a good example of a team that owns its strategy engine and prioritizes early transaction visibility, local processing, and multiple delivery routes. Its design separates acting on an event from observing execution, reconciling final state, and researching the decision afterward.

RPC Fast supplies the managed streaming, RPC, and delivery services. The customer retains responsibility for strategy logic, application state, recording, and cross-source verification.

Discuss your streaming requirements, endpoint location, and TX-delivery configs with RPC Fast

Contact us
Table of Content

See. Predict. Land.

See it first

99.97%

Predict the result

95%

Land the trade

330 ms

Get my endpoint

Ask in Telegram for the free $499 trial

We use cookies to personalize your experience