// Use case
Arbitrage at the
speed of slots.
Solana price discrepancies live and die within a single slot. Subglow delivers pre-parsed swap events from every major DEX in under 5ms — so your arb bot detects and captures opportunities before the next block even confirms.
Why arbitrage needs real-time data
Solana produces a new slot roughly every 400 milliseconds. For arbitrage, that clock is everything. A price discrepancy between Raydium and Jupiter might appear in slot N and vanish by slot N+1 — giving you a window measured in hundreds of milliseconds, not seconds. Traditional RPC polling introduces 200–500ms of latency before your bot even knows a price changed. Add deserialization time and you are looking at stale data that reflects a market state that no longer exists.
The math is unforgiving. If your detection pipeline takes 500ms and the opportunity window is 400ms, you never see it. If your pipeline takes 50ms, you see it but compete with everyone else at that latency tier. At sub-5ms delivery — the level Subglow operates at — you are seeing price movements as they propagate across DEXs, before the majority of bots even begin their polling cycle. That is the difference between capturing a discrepancy and chasing one that already closed.
Real-time gRPC streaming eliminates the poll-wait-parse loop entirely. Instead of asking "did anything change?" thousands of times per second, you receive a continuous feed of every swap, every liquidity change, and every new pool creation the instant it confirms on-chain. Your bot's decision loop starts at the earliest possible moment — and on Solana, that moment is everything.
Types of Solana arbitrage
Cross-DEX arbitrage
The most common form on Solana. SOL/USDC trades at $148.20 on Raydium and $148.45 on Orca in the same slot. Your bot buys low, sells high, and pockets the spread — minus gas and slippage. These discrepancies happen constantly as liquidity shifts across Raydium, Jupiter, Orca, and Meteora, but they close in milliseconds. The bots that win are the bots that see them first.
CEX-DEX arbitrage
Centralized exchanges like Binance and Bybit update prices on their own cadence. When a large sell order hits Binance and pushes SOL down 0.3%, the on-chain price on Raydium may lag by one or two slots. Bridging that gap — buying cheaper on-chain, hedging on the CEX — requires knowing the on-chain price in real-time, not 500ms later when the gap has already been arbitraged away.
Triangular arbitrage
Instead of a direct A→B trade, triangular arb routes through three tokens: SOL→BONK→USDC→SOL. If the combined exchange rates across those three legs yield more SOL than you started with, there is a profit. These routes are computationally intensive to detect because they require accurate, simultaneous pricing across multiple pools — and prices that are even slightly stale produce phantom opportunities that lose money on execution.
Statistical arbitrage
Correlated token pairs (like two SOL liquid staking derivatives) tend to maintain a stable price ratio. When that ratio deviates beyond a statistical threshold, a stat-arb bot takes opposing positions and profits when the ratio mean-reverts. This strategy requires high-frequency price sampling to build reliable statistical models — and low-latency execution to act before the deviation corrects naturally.
The arbitrage data pipeline
A competitive Solana arb bot is not just fast — it is architecturally sound. Every millisecond saved in the data pipeline compounds into higher capture rates and larger average profits. Here is how the pipeline works when built on Subglow.
Stream all swaps across Raydium and Jupiter in real-time
Subscribe to Subglow's filtered gRPC stream for Raydium swaps, Jupiter swaps, and Orca trades. Every event arrives pre-parsed as structured JSON — pool address, input token, output token, amounts, and computed price — with no Borsh deserialization required on your end. Your bot receives only the events that matter, not the full 15,000+ transactions per second that flow through Solana.
Build local orderbook state from swap events
As swap events arrive, your bot updates a local representation of prices across all monitored pools. This in-memory state acts as your real-time view of the market — accurate to the most recent slot, updated continuously, and queryable in microseconds. Because Subglow delivers events in slot order with consistent structure, maintaining this state is straightforward compared to parsing raw transactions.
Detect price discrepancies exceeding gas + slippage threshold
On every state update, your detection engine scans for profitable discrepancies. A raw price difference is not enough — your bot needs to account for Solana transaction fees (~0.000005 SOL), priority fees for competitive inclusion, expected slippage based on pool depth, and Jito tip if using bundle submission. Only opportunities that clear this threshold after all costs are actionable.
Execute atomic swap bundle via Jito for MEV protection
When a profitable opportunity clears your threshold, your bot constructs an atomic transaction bundle — buy on DEX A and sell on DEX B within the same transaction, so partial execution is impossible. Submitting through Jito's block engine provides MEV protection: your bundle is included atomically or not at all, preventing sandwich attacks and ensuring your arb executes as modeled.
Confirm execution and update state
After submission, your bot listens for the confirmation event on the Subglow stream. If the bundle landed, profit is realized and local state updates to reflect the new prices. If it failed — due to someone else capturing the opportunity first — state still updates, and the bot immediately returns to scanning. The entire cycle from detection to confirmation can complete within two to three slots.
Critical data points for arb bots
Arbitrage profitability depends on the quality and granularity of the data feeding your detection engine. Subglow pre-parses every event so you receive exactly the fields you need — no log parsing, no instruction decoding, no guesswork.
| Event | Key fields | Why it matters for arb |
|---|---|---|
| Raydium Swaps | pool, tokenIn, tokenOut, amountIn, amountOut, price impact | Core pricing signal — tells you the effective exchange rate and how deep the pool is at that moment |
| Jupiter Routes | inputMint, outputMint, route path, effective price, slippage | Aggregated route pricing reveals the best available rate across all DEXs simultaneously |
| Pool State Changes | pool, liquidity delta, new reserves, token pair | Liquidity adds or removes shift the price curve — a large withdrawal can create an instant arb opportunity |
| Token / Pool Creates | pool address, token pair, initial liquidity, program | New pools have inefficient pricing by default — the first few minutes of a pool's life produce the widest discrepancies |
Why latency determines profit
Arbitrage on Solana is a zero-sum latency game. The fastest bot captures the spread; everyone else gets nothing. Below is how data delivery speed maps to real-world outcomes for a Solana arb bot running the same detection logic and execution pipeline — the only variable is how fast the bot receives swap data.
| Data delay | Opportunities seen | Avg profit / trade | Method |
|---|---|---|---|
| ~500ms | ~12% | $0.02 | RPC polling (getTransaction loop) |
| ~50ms | ~68% | $0.15 | Raw Yellowstone gRPC + self-parsing |
| <5ms | 95%+ | $0.40+ | Subglow filtered gRPC |
At 500ms delay, your bot is competing for scraps — the few discrepancies wide enough to survive half a second of market activity. At 50ms, you see the majority of opportunities but are still spending precious milliseconds deserializing raw transactions before your detection logic can even run. At sub-5ms with pre-parsed data, your bot receives structured swap events before most competitors have finished their last polling cycle. That speed advantage compounds across thousands of trades per day into significantly higher daily revenue.
Infrastructure for serious arb
Speed is necessary but not sufficient. A production-grade arbitrage bot needs infrastructure that is fast, complete, unrestricted, and close to the validators. Subglow is built for exactly this.
Pre-parsed swap data
Every Raydium, Jupiter, and Orca swap arrives as structured JSON with computed prices, token addresses, and amounts. Zero decode time means your detection engine runs the instant an event arrives — no Borsh deserialization, no instruction layout guessing, no wasted CPU cycles.
Multi-protocol coverage
Cross-DEX arbitrage requires visibility into multiple DEXs simultaneously. Subglow streams Raydium, Jupiter, Orca, and Meteora events through a single gRPC connection. One subscription gives you the full picture of Solana DEX activity — no need to maintain separate data pipelines for each protocol.
Zero rate limits on Pro
Arbitrage bots process thousands of events per second during high-activity periods. Rate limits that throttle your data stream during peak moments are the worst kind of bottleneck — you lose opportunities precisely when there are the most to capture. Pro tier removes all rate limits so your bot never misses an event.
Co-located infrastructure
Subglow runs in Frankfurt and NY4 — the same data centers where Solana validators and Jito relayers operate. Minimal network hops between our servers and your bot means the lowest possible latency from slot confirmation to your detection engine. Geography matters when you are competing at the millisecond level.
Every millisecond is money.
Subglow gives your arb bot the fastest path from on-chain event to actionable signal. Stop competing on stale data.