// Buyer's Guide
Best Solana copy trading RPC.
Your copy trading bot is only as fast as its data source. The difference between a 5ms gRPC event and a 1-second RPC poll is the difference between matching the whale's entry and buying at 2x their price. This guide compares every approach — RPC, WebSocket, and gRPC — and every major provider, specifically for copy trading.
Why latency determines your entry price
Copy trading on Solana is a speed game. When a whale buys a Pump.fun token at 5% bonding curve, the price begins moving immediately as other bots and traders pile in. Every millisecond of delay in detecting that trade means a worse entry price for your mirror trade.
Here's what that looks like with real numbers. A whale buys a new token on the bonding curve at 5%. Within 3 seconds, the curve moves to 15% as other buyers arrive. Your entry price depends entirely on when your bot sees the whale's trade:
| Data method | Detection latency | Your entry | Price vs whale |
|---|---|---|---|
| Filtered gRPC (Subglow) | <5ms | ~5.1% curve | ~1.02x |
| Raw gRPC (self-parsed) | ~15-50ms | ~5.5% curve | ~1.10x |
| WebSocket subscription | ~100-200ms | ~7% curve | ~1.40x |
| RPC polling (1s interval) | ~1,000-2,000ms | ~12% curve | ~2.40x |
Bonding curve percentages are illustrative. Actual slippage depends on token demand, curve steepness, and competing bot activity.
RPC vs WebSocket vs gRPC for copy trading
There are three ways to get real-time Solana data. Each has fundamentally different characteristics that determine whether it works for copy trading.
| Feature | JSON-RPC | WebSocket | gRPC (Yellowstone) |
|---|---|---|---|
| Data delivery | Polling (you ask) | Push (notifications) | Push (streaming) |
| Latency | 1-2 seconds | 50-200ms | <5ms (filtered) |
| Wallet filtering | Client-side only | Limited (logsSubscribe) | Server-side (accountInclude) |
| Data format | JSON (raw tx) | JSON (logs only) | Protobuf or pre-parsed JSON |
| Missed events | Between poll intervals | On disconnect | None (persistent stream) |
| Borsh decoding | Required | Required | Required (or use pre-parsed) |
| Connection stability | N/A (stateless) | Drops under load | Persistent with backpressure |
| Copy trading viability | Poor | Moderate | Excellent |
JSON-RPCis the default Solana API. It uses request/response polling — your bot repeatedly asks "what happened since my last check?" The problem for copy trading is the gap between polls. If you poll every second and a whale trade happens 100ms after your last poll, you don't see it for 900ms. On a Pump.fun bonding curve, 900ms is an eternity.
WebSocket is better — the RPC pushes notifications to your bot. But WebSocket on Solana has limitations. The logsSubscribe endpoint gives you log messages, not structured data. You still need a second RPC call to fetch the full transaction. And WebSocket connections drop under load — exactly when you need them most.
gRPC (Yellowstone) streams data directly from the validator's Geyser plugin. No polling, no notification layer, no connection drops. You define filters — which programs, which accounts — and the validator pushes matching events to your bot over a persistent HTTP/2 connection. For copy trading, this is the only approach that delivers data fast enough to match a whale's entry price.
What to look for in a copy trading data provider
Not every gRPC provider is optimized for copy trading. These five criteria separate providers that work for mirror trading from providers built for general-purpose data access.
Sub-5ms slot lag
Slot lag measures how fast events arrive after the validator confirms a slot. For copy trading, sub-5ms is the target — anything above 50ms means you're buying at a worse price than the whale. Ask your provider for their p50 and p99 slot lag numbers.
Pre-parsed output
Raw gRPC gives you binary protobuf with Borsh-encoded data. Decoding this adds latency to your pipeline. Pre-parsed JSON eliminates that step — you get wallet addresses, token mints, and amounts as readable fields, ready for your watchlist matching logic.
Multi-program filtering
Whales trade across Pump.fun, Raydium, and Jupiter. Your copy trading bot needs events from all three on a single stream. Look for providers that support filtering by multiple programs without requiring separate connections.
Wallet-level matching
Yellowstone's accountInclude filter lets you subscribe to transactions involving specific wallet addresses. This is the foundation of copy trading — filtering the firehose down to only your tracked wallets' activity.
Reconnection handling
gRPC connections can drop. A good provider offers stable infrastructure with low disconnect rates. Your client should implement exponential backoff reconnection, but the fewer disconnects you need to handle, the fewer whale trades you miss.
Provider comparison for copy trading
Evaluated through the lens of what matters for copy trading: speed, data format, wallet filtering, and the total cost of getting actionable data to your bot.
| Copy trading need | QuickNode | Chainstack | Helius | Solana Tracker | Subglow |
|---|---|---|---|---|---|
| Wallet event detection | accountInclude filter | accountInclude filter | Custom filter API | accountInclude filter | accountInclude + pre-parsed |
| Wallet address in output | Encoded in protobuf | Encoded in protobuf | Available via SDK | Encoded in protobuf | JSON field (ready to use) |
| Borsh decoding needed | Yes (client-side) | Yes (client-side) | No (SDK handles) | Yes (client-side) | No (server-side) |
| Multi-program stream | Multiple filters on 1 conn | Multiple filters on 1 conn | Multiple subscriptions | Multiple filters on 1 conn | Multiple filters on 1 conn |
| Event types extracted | No (raw bytes) | No (raw bytes) | Yes (Laserstream) | No (raw bytes) | Yes (buy, sell, swap, etc.) |
| Vendor lock-in | No (Yellowstone) | No (Yellowstone) | Yes (custom protocol) | No (Yellowstone) | No (Yellowstone) |
| Starting price | ~$499/mo | ~$399/mo | ~$499/mo | $247/mo | $99/mo |
| Free trial | Limited | Limited | Limited | No | Yes (100 req/day) |
Pricing as of April 2026. Feature availability may vary by tier. Check each provider's current pricing page for the latest.
How copy trading bots consume data
Every copy trading bot follows the same four-stage architecture: detect the whale's trade, match it against your watchlist, execute a mirror trade, and manage the position. The data layer — how you detect the trade — determines the viability of everything that follows.
With filtered gRPC, the detection stage delivers pre-parsed events with wallet addresses, token mints, amounts, and event types. Your watchlist matching becomes a simple Set.has() call instead of a multi-step protobuf → Borsh → account resolution pipeline.
With pre-parsed output, the entire detection + matching pipeline is ~10 lines. With raw gRPC, add ~200 lines of protobuf and Borsh decoding before you reach this point.
Total cost of ownership
The subscription price is only part of the cost. With raw gRPC providers, you also need infrastructure to receive and parse the high-throughput stream, plus engineering time to build and maintain Borsh decoders for every program your copy bot tracks.
| Cost factor | Raw gRPC provider | Subglow |
|---|---|---|
| Subscription | $250-500/mo | $99/mo |
| Parsing infrastructure | $50-150/mo (your servers) | $0 (pre-parsed) |
| Borsh decoder maintenance | Ongoing engineering hours | None |
| Bandwidth | ~2-8 GB/hr (raw firehose) | ~120 MB/hr (filtered) |
| Time to first copy trade | Days-weeks (build parsers) | Hours (plug and play) |
Frequently asked questions
What is the best RPC for Solana copy trading?
For copy trading, gRPC is significantly better than traditional JSON-RPC. Among gRPC providers, Subglow offers the lowest execution latency for copy trading because it delivers pre-parsed JSON with wallet addresses, token mints, and amounts already extracted — eliminating the 15-30ms Borsh deserialization step that adds execution latency with other providers. Starting at $99/mo with flat pricing (no credit metering), it's also the most affordable gRPC option.
Why is gRPC faster than RPC polling for copy trading?
JSON-RPC requires your bot to ask 'what happened?' at fixed intervals (polling). Between polls, trades are invisible. gRPC pushes data to your bot the instant a transaction confirms — sub-5ms delivery vs 1-2 second polling intervals. For copy trading, that 1-second gap means the token price has already moved 50-200% by the time you see the whale's trade.
Can I track specific wallets with Solana gRPC?
Yes. Yellowstone gRPC supports transaction filters with accountInclude, which matches any transaction involving specific accounts. You can subscribe to transactions where a target wallet appears as a signer. With Subglow, the events arrive pre-parsed with the wallet address in a human-readable field, so you can match against your watchlist with a simple string comparison.
How much latency do I need for profitable copy trading?
On Solana, token prices can move 50-200% within seconds of a whale entry. Sub-5ms event delivery (achievable with filtered gRPC) lets your mirror trade land in the same slot window as the original. At 200ms+ latency (typical WebSocket), you're buying 1-2 slots late. At 1-2 second latency (RPC polling), you're often buying at 2x+ the whale's entry price.
Do I need to decode Borsh data for copy trading?
With most gRPC providers (QuickNode, Chainstack, Solana Tracker), yes — you receive raw protobuf with Borsh-encoded instruction data and must decode it yourself. With Subglow, Borsh decoding happens server-side. You receive clean JSON with fields like token, sol_amount, buyer, and bonding_curve_pct ready for your copy trading logic.
Continue reading
Copy Trading Use Case
How Subglow powers real-time wallet tracking with pre-parsed gRPC events.
gRPC Provider Comparison
Full comparison of Yellowstone gRPC providers — pricing, features, output formats.
Yellowstone gRPC Tutorial
Step-by-step guide to connecting, subscribing, and streaming Solana data.
gRPC vs RPC
Detailed protocol comparison for Solana real-time data.
Stop buying at the whale's exit price.
Pre-parsed events. Sub-5ms delivery. Wallet addresses in every event. Start copy trading with faster data today.