# rpc edge - full context for LLMs

> Low-latency Solana RPC, Yellowstone gRPC & preprocessed gRPC for trading firms, funds, and quants.
> Last updated: 2026-07-13
> Full-content companion to https://rpcedge.com/llms.txt. Machine-readable pricing: https://rpcedge.com/pricing.md.

rpc edge is a Solana infrastructure provider for traders. We run RPC, Yellowstone gRPC, and preprocessed transaction streams on bare-metal co-located beside Solana stake clusters and the Jito Block Engine - a low-hop path for HFT desks, funds, and quants that need fast state and transaction routing.

## Endpoints
Mainnet only. Key is a UUID. Auth: `?key=` query param, or `x-api-key` / `Authorization: Bearer` header; gRPC via x-api-key metadata. Frankfurt-pinned aliases exist (`frankfurt.<host>`).

- Solana RPC (HTTP + WebSocket (JSON-RPC)): https://rpc.rpcedge.com?key=YOUR_KEY | wss://rpc.rpcedge.com?key=YOUR_KEY
- Yellowstone gRPC (gRPC (Geyser)): grpc.rpcedge.com:443
- Preprocessed gRPC (decoded shreds) (gRPC stream (pre-confirm intent)): gRPC stream - see /decoded-shreds
- Transaction Sender (JSON-RPC / raw HTTP / QUIC): https://relay.rpcedge.com/v1/submit

## Products
### Solana RPC (HTTP · WS)  https://rpcedge.com/solana-rpc
Solana RPC is the JSON-RPC API that applications use to read on-chain state and submit transactions to the network. Over HTTP you make one-shot calls like getAccountInfo and sendTransaction; over WebSocket you subscribe to account, log, and signature updates.
rpc edge runs Solana JSON-RPC over HTTP and WebSocket on infrastructure racked beside Solana stake clusters and the Jito Block Engine. It is the live read-and-write workhorse of your trading stack: account lookups, simulations, subscriptions, and transaction submission.
Where public and shared endpoints add hops, rate limits, and unpredictable latency, our nodes are tuned end to end - kernel, network stack, and RPC layer - so your reads return fast and your writes reach the leader.
- One endpoint, live reads and subscriptions: HTTP JSON-RPC for live reads and simulations, plus WebSocket subscriptions for accounts, logs, slots, blocks, and signatures.
- No credit counting: Plans are scoped to throughput and bandwidth, not opaque per-method credits. Heavy account and history methods are explicitly limited on shared plans.
- Co-located, low-hop: Racked beside stake clusters and the Jito Block Engine, so the distance between you and the cluster stays at the floor the network allows.
- Single-tenant option: On dedicated, your RPC runs on private bare-metal - your tail latency and jitter are yours alone.

### Yellowstone gRPC (GEYSER · gRPC)  https://rpcedge.com/yellowstone-grpc
Yellowstone gRPC is a streaming interface built on Solana's Geyser plugin port. Rather than polling an RPC endpoint, you open one long-lived gRPC stream and the validator pushes accounts, transactions, slots, and blocks as it processes them, filtered server-side.
Yellowstone is the widely-used gRPC implementation of Solana's Geyser plugin interface. Instead of polling an RPC endpoint, you open one long-lived stream, describe what you care about with filters, and updates arrive as the validator processes them.
rpc edge runs Yellowstone gRPC on nodes tuned for high-frequency streaming, co-located with the cluster - so you get live account and transaction state with minimal serialization overhead and proper backpressure under load.
- Accounts, transactions, slots: Multiplex everything you need on one stream - account writes, transactions, slot transitions, and block metadata.
- Server-side filters: Filter by owner program, account key, account inclusion, and more, so you receive only what's relevant - the work happens next to the data.
- Backpressure built in: A streaming protocol that handles flow control properly, so bursts don't silently drop or buffer unboundedly.
- Thousands of accounts, one connection: Subscribe to entire programs without the WebSocket fan-out that buckles past a few hundred subscriptions - one stream covers them all.

### Preprocessed gRPC (DESHRED · gRPC)  https://rpcedge.com/decoded-shreds
Preprocessed gRPC is a transaction-intent stream produced from decoded shreds before the validator exposes normal processed transaction metadata. It is earlier than processed metadata, but it does not include execution result, logs, account writes, balances, or final status.
Shreds are the fragments validators propagate before a block is assembled. rpc edge reconstructs transaction intent from that layer and streams it over gRPC so latency-sensitive consumers can react before normal processed transaction metadata is available.
The decoding happens server-side, co-located with the cluster, so you receive ready-to-use transaction intent rather than raw bytes. Use Yellowstone gRPC when you need executed account state, logs, balances, or status metadata.
- Earlier transaction intent: Read transaction intent before normal processed metadata is emitted.
- Built for trading filters: Designed for transaction filters that matter to trading systems, not broad archive indexing.
- Decoded server-side: Reassembled and deserialized before they hit your stream, so you can act without handling raw shred reconstruction.
- Delivered over gRPC: Delivered over gRPC as a bounded premium stream alongside Yellowstone gRPC.

### Transaction Sender (JITO · LEADER)  https://rpcedge.com/transaction-sender
A transaction sender is the service that delivers your signed transaction to the validators producing upcoming blocks. Instead of forwarding through general-purpose RPC, it resolves the leader schedule and sends through configured fast paths, including direct TPU and Jito routes where authorized.
Sending a transaction is easy; landing it - fast, in the slot you wanted - is the hard part. rpc edge's transaction sender resolves the current and upcoming leaders from the schedule and uses configured fast paths instead of plain public RPC forwarding.
When you need atomicity, ordering, or to bid for inclusion, approved keys can use private Jito routes. Everything runs co-located with the cluster, so the path from your signed transaction to the producing leader keeps avoidable distance low.
- Direct to the leader: Submit through JSON-RPC compatibility, raw HTTP, or QUIC on relay.rpcedge.com.
- Jito Block Engine path: Use Jito transaction and bundle routes where they are enabled on your key.
- You own the retries: Set maxRetries to 0 and control resubmission within the blockhash window, so you never land a stale action.
- Co-located delivery: Every QUIC packet and bundle submission starts next to the cluster, not a region away.

### Dedicated Nodes (CUSTOM)  https://rpcedge.com/dedicated-nodes
Dedicated nodes are private, single-tenant Solana infrastructure provisioned to one customer rather than shared in a multi-tenant pool. They are racked to your specs in the region closest to your edge, co-located with stake clusters and the Jito Block Engine on request, so tail latency and jitter are not affected by other tenants.
Dedicated nodes are private bare-metal, provisioned to your specs in the region closest to your edge and co-located with Solana stake clusters and the Jito Block Engine on request. Nothing else shares the box, so no other tenant can shift your latency under load.
This is the bespoke tier - RPC, Yellowstone gRPC, preprocessed gRPC, and the transaction sender on infrastructure tuned to your workload, with custom stream routes, direct leader and Jito paths where enabled, and a contractual SLA. Onboarding is hands-on, with a direct line to the infra engineers who built the stack.
- Single-tenant bare-metal: Private nodes provisioned to your specs - no shared CPU, no noisy neighbors, deterministic tail latency.
- Co-located on request: Racked beside stake clusters and the Jito Block Engine, in the region closest to your edge.
- Custom streams + direct Jito: Preprocessed streams, custom routing, and direct Block Engine access where enabled - scoped to your workload.
- SLA + direct support: A contractual uptime SLA and a direct line to the engineers who run the infrastructure.

## Pricing
Metered on bandwidth, paid in USDC on Solana. Trader $249/mo, Desk $499/mo, Custom dedicated. Full tier + feature comparison: https://rpcedge.com/pricing.md and https://rpcedge.com/pricing.

## Solana glossary
### Commitment level
How settled a piece of Solana state is when you read it. The levels, from least to most certain, are processed (a validator executed it), confirmed (a supermajority voted), and finalized (rooted and irreversible). Lower levels are faster but more provisional.

### Co-location
Running your infrastructure physically close to Solana stake clusters and the Jito Block Engine, in the same datacenters, to minimize network hops and distance. Proximity is the cheapest latency there is, and the foundation of low-latency reads and transaction landing.

### Decoded shreds
Transactions reconstructed and decoded straight from the shred propagation layer, before any block is assembled. They give a first-seen, pre-confirmation view of the network - the earliest moment a transaction is observable.

### Dedicated node
A private, single-tenant Solana node provisioned to your specs on bare metal, rather than shared multi-tenant infrastructure. No noisy neighbors means deterministic tail latency and jitter.

### First-seen
The earliest moment you can observe a transaction - while its block is still propagating as shreds, before any validator has rolled it into a confirmed block. It sits below the processed commitment and is the prize that latency-sensitive strategies chase.

### Geyser
Solana's plugin interface that lets account, transaction, slot, and block data flow out of a validator the moment it is processed. Yellowstone is the widely-used gRPC implementation of the Geyser interface.

### gRPC
A high-performance, streaming RPC protocol. On Solana, Geyser-based gRPC (Yellowstone) pushes live updates to you over one long-lived stream with server-side filters, instead of you repeatedly polling a JSON-RPC endpoint.

### Jito Block Engine
Infrastructure that runs an auction for bundles of transactions on Solana. Searchers submit bundles with a tip, and the highest-tipping bundles win inclusion and ordering. It is the mechanism behind competitive MEV on Solana.

### Jito bundle
A set of transactions that execute all-or-nothing, in a specific order, submitted to the Jito Block Engine with a tip. Used when you need atomicity, guaranteed ordering, or to bid for inclusion.

### Leader
The validator responsible for producing the block for a given slot. The leader schedule is known for the whole epoch in advance, so you can send transactions directly to the current and upcoming leaders instead of broadcasting and hoping.

### MEV
Maximal Extractable Value - the profit a participant can capture by influencing the inclusion and ordering of transactions in a block (for example, arbitrage or liquidations). On Solana, MEV is largely contested through the Jito Block Engine.

### Priority fee
A compute-unit price you attach to a transaction. When a leader has more transactions than it can fit, it orders them by priority fee, so a higher fee raises your place in line. It improves odds but does not guarantee inclusion.

### QUIC
The UDP-based transport protocol Solana validators use to accept transactions at the TPU. Sending directly to leaders over QUIC removes RPC-forwarding hops.

### RPC (JSON-RPC)
Remote Procedure Call - the request/response API you use to read Solana state and submit transactions over HTTP, plus WebSocket subscriptions. It is the workhorse for reads, writes, and history.

### Shred
The smallest unit of a Solana block - a network-sized, erasure-coded packet of block data. Leaders split blocks into shreds and propagate them across the cluster through Turbine, so reading shreds lets you see transactions while a block is still in flight.

### Slot
A roughly 400-millisecond window in which a designated leader can produce a block. Solana time is measured in slots, and where you read inside a slot (shred-time vs block-time) decides how early you see state.

### Stake-weighted QoS (SWQoS)
A mechanism that prioritizes transactions arriving over connections backed by stake. During congestion, staked connections get preferential access to a leader, which improves landing rate when the network is saturated.

### TPU
Transaction Processing Unit - the ingress on the current leader that accepts transactions over QUIC. A purpose-built sender delivers straight to the current and upcoming leaders' TPUs, skipping forwarding hops.

### Turbine
Solana's block propagation protocol, which fans shreds out across the validator set in a tree so a large block can reach the whole cluster quickly. It is how a block travels before it is fully assembled.

### Yellowstone gRPC
The widely-used gRPC implementation of Solana's Geyser plugin interface. It streams accounts, transactions, and slots out of a validator in real time with rich server-side filters, scaling far better than fanning out WebSocket subscriptions.

## Comparisons
### rpc edge vs public RPC  https://rpcedge.com/vs/public-rpc
The free public endpoints are a genuinely good starting point - until you put real volume or real money through them. Here is the honest line between public RPC and a co-located trading stack.
Where rpc edge's design leads: Co-located with stake clusters and the Jito Block Engine, with a direct low-hop path to the current leader - public endpoints are generic shared nodes with no proximity guarantee, and proximity is the lever that decides latency. Decoded shreds read first-seen from the propagation layer and aggregated from multiple independent sources, so you act before a block is assembled - public RPC only serves you data at standard commitments, well after the wire. Single-tenant bare-metal on dedicated, so your tail latency is yours alone - public endpoints are shared by the whole ecosystem and will rate-limit or 429 you under load. Flat throughput pricing with included bandwidth in USDC; contractual SLA on Custom/Dedicated. Public RPC is free but offers no uptime guarantee, no support, and no recourse when it throttles you mid-strategy.
Where public RPC is genuinely strong: Free, with zero signup or commitment - the fastest possible way to start reading Solana data. Maintained by the project for the ecosystem, so it is a fair, neutral default for docs, tutorials, and examples. Perfectly adequate for prototyping, low-volume scripts, occasional reads, and non-latency-sensitive devnet/testnet work. Always available as a fallback or sanity check without provisioning anything.

### rpc edge vs Helius  https://rpcedge.com/vs/helius
Helius is the best-known developer platform on Solana, and it earns that. This page is about a narrower question - where the latency-critical trading path should live, and what it should cost.
Where rpc edge's design leads: One co-located bundle: decoded shreds, Yellowstone gRPC, and the transaction sender run from the same box. Helius sells LaserStream and Sender as separate, separately metered products on a globally distributed fleet. Flat plans: $249 Trader / $499 Desk in USDC, cancel anytime. Helius gates mainnet gRPC behind its $499/mo Business plan, meters streaming in credits per MB, and sells TB-scale data add-ons that run from hundreds to thousands of dollars a month on top. Co-location is the thesis: proximity to stake clusters and the Jito Block Engine, not anycast distribution. Helius frames Turbine as location-agnostic and sells global redundancy - a different bet. Benchmarks published raw: our first 1-hour relay run (p50 104ms submit to first-seen, Frankfurt) is public with the full source data, tail latency included. One honest run beats a wall of unsourced speed claims.
Where Helius is genuinely strong: The broadest Solana developer surface: DAS API, enhanced transactions, webhooks - product depth nobody else matches. Frictionless activation: free tier, signup in about 10 seconds, no card - plus USDC auto-billing through the Solana Foundation's audited Subscriptions Program. Sender is available on every plan including free, and LaserStream is a drop-in Yellowstone replacement with 24h historical replay and auto-reconnect. Operates the largest validator on the network by stake, which backs a real staked-connection story, and runs LaserStream across 9 named regions.

### rpc edge vs QuickNode  https://rpcedge.com/vs/quicknode
QuickNode publishes a strong, reproducible read-latency benchmark and holds serious enterprise credentials. We compete on a different axis - the Solana write path and streaming stack it doesn't productize the same way.
Where rpc edge's design leads: Solana-only, co-located, one integration: decoded shreds, Yellowstone gRPC, and the transaction sender from the same box. QuickNode's Solana products ride a shared multichain fleet as marketplace add-ons. The write path is self-serve here: the sender is in every plan at $249 flat. QuickNode's strongest SWQoS sender (Transaction Supercharger) sits behind enterprise contact-sales. Streaming without plan math: on QuickNode, Solana gRPC is bundled only at Scale ($499) and Business ($999), or bolted on for $499/mo on lower tiers. Decoded shreds are not a product they advertise at all. We publish the write path raw: submit to first-seen percentiles, tail included, source data linked. QuickNode's published benchmark covers reads - the shred-to-you and landing numbers stay unpublished.
Where QuickNode is genuinely strong: QuickLee is a genuinely good benchmark: p95 getBalance latency from 5 regions on a public Grafana dashboard, open to third-party audit. We do not contest their read latency. Enterprise trust nobody else in the category matches: SOC 1 + SOC 2 Type II + ISO 27001, recertified in 2026. Free tier with no card, provisioning in minutes, and one of the deepest docs and guides libraries in crypto. Multichain coverage (80+ chains) plus a marketplace of Solana add-ons - Jito bundles, DAS, priority fees, Jupiter APIs - under one account.

### rpc edge vs Triton  https://rpcedge.com/vs/triton
Triton One wrote the Yellowstone gRPC standard the whole ecosystem runs on - including us. That deserves respect. It also means your client code is portable, and portability cuts both ways.
Where rpc edge's design leads: No prepay to try it: a vetted 15-day trial with no card. Triton requires a $125 non-refundable, prepaid deposit before service activates - there is no free trial. One opinionated bundle instead of a suite: decoded shreds + Yellowstone gRPC + transaction sender at $249 flat. Triton sells a sprawling catalog (Cloudbreak, Superbank, Fumarole, Vixen, Shield, Metis) that enterprises love and small desks have to navigate. A productized, self-serve sender: Triton sunset its Cascade marketplace, and SWQoS delivery is now granted on request through support rather than sold as a product. Named trading co-location where they aren't: Triton's Pro Trading Centers are Amsterdam and Tokyo. We are live co-located in Frankfurt, with the benchmark to show for it.
Where Triton is genuinely strong: They authored the standard: Yellowstone gRPC, Old Faithful, Vixen - the open-source stack most providers (including rpc edge) build on. Nobody has deeper protocol credibility. Radically transparent pay-as-you-go pricing with no tier-gated throttling - a genuine attack on credit black boxes, published openly. Serious production pedigree: bare metal across 3 continents, 99.99% uptime claims, and customers like Jupiter, Wintermute, Kamino, Phantom, and the Solana Foundation itself. Their shred routing races DoubleZero Edge, Jito ShredStream, Turbine, and their own leaders in parallel - a sophisticated multi-source read path.

### rpc edge vs Shyft  https://rpcedge.com/vs/shyft
Shyft is the budget pick for unmetered gRPC and pre-indexed DeFi data, and it's good at that. But Shyft is read-only - a trader on Shyft still needs a second vendor to land transactions. That seam is our whole product.
Where rpc edge's design leads: The write path exists here: a co-located transaction sender in every plan. Shyft has no transaction sender and no SWQoS write path - streaming a shred on Shyft still leaves you shopping for a way to land the trade. One box, one loop: decoded shreds and gRPC feed a sender in the same rack, so the see-decide-land loop never crosses a vendor boundary. You can trial the actual streaming: our 15-day vetted alpha includes gRPC and decoded shreds, no card. Shyft's free tier has no gRPC at all - the stream is paywalled at $199/mo. Complete stream data: our Yellowstone gRPC carries full transaction metadata. Shyft's RabbitStream trades completeness for speed - no meta, no logs, no final execution status - so users end up running both streams.
Where Shyft is genuinely strong: Genuinely aggressive pricing: unmetered gRPC bandwidth with no egress charges from $199/mo - a real cost ceiling for high-throughput readers. SuperIndexer is a moat: pre-indexed token, NFT, and DeFi position data that saves teams from building their own indexer. We don't compete with it. Free RPC tier with no card and no KYC, plus crypto payments accepted. Wide read-side surface: 7 named gRPC regions, decoded shreds via RabbitStream, GraphQL and parsing APIs, and a well-forked open-source example library.

### rpc edge vs Nozomi  https://rpcedge.com/vs/nozomi
Nozomi is a serious transaction sender with a fair pricing model - you tip only when you land. But it's write-only. Your bot still buys its eyes somewhere else, and the loop between the two vendors is where latency hides.
Where rpc edge's design leads: Read and write from the same box: decoded shreds and Yellowstone gRPC feed the sender in one rack. Nozomi ships the write half only - the see-decide-land loop crosses vendor and network boundaries before your transaction ever leaves. No application form: the 15-day vetted trial issues access without a Typeform queue, and paid plans are self-serve in USDC. Predictable cost under volume: flat $249 / $499 plans instead of per-transaction tips that scale linearly with your send rate and spike with tip-floor competition. Our proof is raw and reproducible: the published Frankfurt run includes full percentile tables and tail latency. Nozomi's 'fastest' claim is self-reported, and the only public head-to-head (run by a competitor) placed it second.
Where Nozomi is genuinely strong: Pay-only-on-landing is honest risk-reversal: no subscription, no landing means no tip. For low-volume or bursty senders this can be very cheap. Real scale, shown live: a public dashboard streaming per-region landed volume and latency percentiles - proof-as-product that few competitors match. 9 bare-metal regions with custom hardware, staked connections, and Jito bundle routing, plus MEV-protect key options. Default presence in trading stacks: wired into the community relayer-adapter SDKs, so bots reach it out of the box.

### rpc edge vs bloXroute  https://rpcedge.com/vs/bloxroute
bloXroute sells real landing-rate infrastructure to funded trading firms, and its benchmarks show it winning races. The honest difference is shape and price: an unbundled, fiat-billed pro stack versus one co-located endpoint at $249.
Where rpc edge's design leads: One price, one pipe: decoded shreds + Yellowstone gRPC + sender for $249 flat. bloXroute unbundles the same loop into separate line items that stack toward and past $1,250/mo before the first bundle tier. Physically co-located, not overlay-routed: our stack sits in one rack beside stake and the Jito Block Engine. bloXroute's edge is its BDN overlay on rented bare metal - strong engineering, different physics. Drop-in surfaces: standard Solana JSON-RPC and Yellowstone gRPC, so switching is an endpoint change. The Trader API is a proprietary surface you integrate through their SDKs. Crypto-native billing and a real trial: USDC, no card, 15 vetted days. bloXroute's paid tiers are portal and invoice billed with no advertised crypto payment path.
Where bloXroute is genuinely strong: Published landing-rate benchmarks where it beat Nozomi, Jito Direct, and NextBlock head-to-head (its own methodology, but published with numbers). Sophisticated MEV handling: front-running protection with leader-aware scoring that delays or skips risky slot leaders, routing across Jito, Paladin, and its own channels. A permanent free tier for transaction submission - you can send through bloXroute today at zero base cost, paying only tips and fees. Institutional depth: eight chains, four maintained SDKs, and years of infrastructure operation with market-maker backers.

## Guides
### DoubleZero IBRL vs Public Internet: What One Hour of Paired Sends Showed  https://rpcedge.com/blog/dz-ibrl-vs-public-1h-2026-07-13
Leader-paced A/B from Frankfurt: for every eligible Solana leader with DoubleZero TPU open, one tx over IBRL and one over the public Internet. Same host, same relay, same slot trigger. Placement over vanity RTT.

### SubscribeDeshred versus processed gRPC: What the Lifecycle Race Showed  https://rpcedge.com/blog/deshred-vs-processed-2026-07-11
55,424 matched Pump AMM signatures on mainnet from Frankfurt: pre-execution deshred vs processed Yellowstone gRPC. Same filter, same public TLS endpoint. First-seen is almost always deshred.

### ShredStream Alternatives: The Solana Shred-Source Landscape in 2026  https://rpcedge.com/blog/shredstream-alternatives
Jito ShredStream is free and everywhere, DoubleZero Edge is publishing 28ms-faster p95 numbers, and commercial feeds like Shreder sell decoded shreds by the month. An honest map of the options - and what it costs to run each one.

### Migrating from Syndica ChainStream to Yellowstone gRPC  https://rpcedge.com/blog/migrating-from-syndica-chainstream
Syndica retired its RPC and ChainStream APIs on Feb 14, 2026 and told users to migrate to Yellowstone gRPC. What actually changes, how the subscriptions map, and how to land the migration on a co-located endpoint.

### QUIC Transaction Relay: The First 1-Hour Mainnet Run  https://rpcedge.com/blog/quic-relay-1h-2026-06-30
2,202 transactions through the co-located QUIC relay on Yellowstone TPU in Frankfurt. Observation rate 96.3%. Submit-to-deshred p50 104 ms. ACK is health, not landing.

### Best Solana RPC for HFT & Trading Bots: A Latency-First Comparison  https://rpcedge.com/blog/best-solana-rpc-for-hft
For latency-sensitive trading, the best Solana RPC is the one racked beside stake and Jito. Here's the decision framework and an honest read on the players.

### Stake-Weighted QoS (SWQoS) on Solana, Explained  https://rpcedge.com/blog/stake-weighted-qos-explained
SWQoS lets validators hand out ingest bandwidth in proportion to stake, so staked connections land while public endpoints get throttled under load.

### Solana RPC Methods: A Practical Reference  https://rpcedge.com/blog/solana-rpc-methods-reference
The Solana JSON-RPC methods you'll actually use, what each one does, where they bite, and when to reach for gRPC or shreds instead.

### Solana Geyser Plugins, Explained  https://rpcedge.com/blog/solana-geyser-plugins-explained
Geyser is the plugin interface that lets account, transaction, and slot data flow out of a validator as it is processed. Here is how it works.

### Copy-Trading on Solana: The Infrastructure Behind It  https://rpcedge.com/blog/solana-copy-trading-infrastructure
Copy-trading bots watch a target wallet and mirror its trades. The hard part isn't the logic, it's seeing the trade and landing yours before the edge is gone.

### Solana Arbitrage Bot Infrastructure: What You Actually Need  https://rpcedge.com/blog/solana-arbitrage-bot-infrastructure
An arbitrage bot is mostly infrastructure, not strategy. Here's the ingest, decode, and execution stack a Solana arbitrage bot actually needs.

### rpc edge vs Helius vs Triton: Solana Infrastructure, Compared  https://rpcedge.com/blog/rpc-edge-vs-helius-vs-triton
Three strong Solana providers, three different centers of gravity. A fair head-to-head for teams choosing infrastructure for trading and HFT.

### Jito on Solana: Bundles, Tips, and MEV Explained  https://rpcedge.com/blog/jito-and-mev-on-solana
How the Jito Block Engine, bundles, tips, and the auction work, and how MEV is contested on Solana, for searchers and trading teams.

### Best Solana RPC Providers in 2026: A Buyer's Comparison  https://rpcedge.com/blog/best-solana-rpc-providers
There is no single best Solana RPC provider, only the right one for your job. Here is the framework to pick yours, and an honest read on the main players.

### Why Solana Transactions Fail (and How to Land Them)  https://rpcedge.com/blog/why-solana-transactions-fail
Most Solana transactions don't fail on-chain, they vanish before they arrive. Here's why they drop and how to land them.

### Solana Commitment Levels: Processed vs Confirmed vs Finalized  https://rpcedge.com/blog/solana-commitment-levels-explained
A plain reference to Solana's commitment levels, what each one guarantees, and which to pick for reads, writes, settlement, and HFT signal.

### How to Choose a Solana RPC Provider (2026 Guide)  https://rpcedge.com/blog/how-to-choose-a-solana-rpc-provider
A buyer's guide for HFT desks, funds, and serious bot builders. The criteria that decide your edge, the red flags that drain your budget.

### Building an HFT Data Pipeline on Solana: A Reference Architecture  https://rpcedge.com/blog/building-an-hft-data-pipeline-on-solana
From shred ingestion to landed transaction - a reference architecture for low-latency Solana trading, and where the milliseconds actually hide.

### Landing Transactions on Solana: Leader Paths and the Jito Block Engine  https://rpcedge.com/blog/transaction-sender-jito-leader-paths
Sending a Solana transaction is easy; landing it fast, in the slot you wanted, is the hard part. How the leader schedule, the TPU, and Jito fit together.

### Reading Decoded Transactions Before Confirmation  https://rpcedge.com/blog/reading-decoded-transactions-before-confirmation
"First-seen" means acting on a transaction while it's still propagating - before any node calls it confirmed. What that state is, and how to use it safely.

### Yellowstone gRPC vs Standard RPC, Explained  https://rpcedge.com/blog/yellowstone-grpc-vs-standard-rpc
Polling RPC asks the node "anything new?" on a loop. Geyser-based gRPC pushes updates the instant they happen. How the two models differ - and when to use each.

### What Are Solana Shreds? The Fastest Way to Read On-Chain Data  https://rpcedge.com/blog/what-are-solana-shreds
Standard RPC shows you transactions after a block is confirmed. Shreds show them while it's still propagating - the foundation of low-latency Solana trading.

### Why RPC Polling Can't Keep Up With HFT on Solana  https://rpcedge.com/blog/why-rpc-polling-cant-keep-up
Polling a Solana RPC node asks the same question on a loop and pays in latency. Where the milliseconds go - and the architecture that removes them.

## FAQ
### What is rpc edge?
rpc edge is a Solana infrastructure provider built for traders. We run RPC, Yellowstone gRPC, preprocessed transaction streams, and an ultra-fast transaction sender on bare-metal co-located beside Solana stake clusters and the Jito Block Engine. It is built for HFT desks, funds, and quant traders who need fast network state and fast transaction routing.

### What latency should I expect from rpc edge?
Our nodes are co-located beside Solana stake clusters and the Jito Block Engine to minimize hops and distance. Exact P50/P95 figures depend on your region and workload, so we benchmark them with you during onboarding rather than quote a single hero number.

### What is Yellowstone gRPC and why use it over standard RPC?
Yellowstone gRPC is a Geyser-based streaming interface for Solana. Geyser is the validator's plugin port for live data, so Yellowstone pushes accounts, slots, and transactions to you the moment the validator processes them, instead of you polling an RPC endpoint. For trading systems it removes polling lag and serialization overhead, so you react to state as it changes.

### What is preprocessed gRPC?
Preprocessed gRPC is a transaction-intent stream built from decoded shreds. It can arrive before normal processed transaction metadata, but it does not include execution result, logs, account writes, balances, or final status metadata.

### How does the Ultra-Fast Transaction Sender land transactions faster?
It accepts signed transactions through JSON-RPC compatibility, raw HTTP, or QUIC, then applies route policy and fans out through configured fast paths. Jito transaction and bundle routes are private access for approved keys.

### What's the difference between shared and dedicated nodes?
Trader and Desk run on performance-tuned multi-tenant infrastructure with included monthly bandwidth. Custom provisions private, single-tenant bare-metal nodes to your specs, co-located on request, with a contractual SLA - so your tail latency and jitter are yours alone. It's built for HFT desks, funds, and quants.

### Does rpc edge have a free tier?
No. rpc edge is paid from day one so the infrastructure stays fast for active desks. Self-serve starts at app.rpcedge.com/signup - first month is 50% off Trader or Desk when you pay with USDC. Qualified teams can request 24h testing access or a limited 15-day Trader trial via the docs testing-access page or Telegram.

### How is rpc edge pricing structured?
Two self-serve tiers: Trader at $249/mo and Desk at $499/mo, billed monthly or prepaid through Solana Pay in USDC on Solana. Each includes monthly bandwidth (4 TB Trader, 10 TB Desk). Beyond the allowance, usage is limited rather than surprise-invoiced - talk to us if you need more headroom or Custom. Prepaid plans stay active for the paid term; renew before expiry to keep service. Custom infrastructure is scoped per engagement. Cards are planned.

### Which setup do I need for an HFT or arbitrage bot?
Most trading teams run Desk or Custom: Yellowstone gRPC plus preprocessed gRPC for early transaction intent, and the Transaction Sender for fast landing. Funds with strict latency budgets take Custom dedicated nodes for co-location and single-tenant bare-metal.

### How do I get started with rpc edge?
Open app.rpcedge.com/signup, create an account with a magic link, choose Trader or Desk, pay in USDC on Solana, then create an API key and point your client at your scoped endpoint. For Custom, talk to the infra team and we will scope a dedicated node in the region closest to your edge.

## Company
rpc edge by Polaris Labs. Docs: https://docs.rpcedge.com. Telegram: https://t.me/rpcedge. Email: rpcedge@gmail.com.
- Terms of Service: https://rpcedge.com/terms
- Privacy Policy: https://rpcedge.com/privacy
- Cookie Policy: https://rpcedge.com/cookies
- Acceptable Use Policy: https://rpcedge.com/acceptable-use
- Imprint: https://rpcedge.com/imprint