An Arbitrum RPC provider gives a trading bot or terminal a route to read contract state, follow logs and broadcast signed transactions. The practical differences are live WebSocket feeds, historical state, trace access, transaction routing, dedicated capacity and how each service meters usage. This comparison is based on each provider's official documentation and published features, checked in November 2026; we have not tested the tools hands-on.
Which one to pick
- Need one account for live reads, historical data and transaction broadcasts: QuickNode, with archive access, Streams and transaction tooling for Arbitrum.
- Need an optimized signed-transaction path: Chainstack, with private routing for Arbitrum One submissions.
- Need RPC alongside simulation and indexed data: Alchemy, which combines node access with transaction simulation and token APIs.
- Need conventional Ethereum-compatible access and daily credit budgeting: Infura, with HTTP, WebSocket and archive support for Arbitrum.
- Need cryptographic verification of RPC responses: Ankr, with its attested-node Verifiable RPC option for Arbitrum.
- Need configurable infrastructure: GetBlock for shared, flat-rate Limitless or dedicated nodes; consider Tatum for live subscriptions and dRPC for gateway-style access.
Compare Arbitrum RPC features for active trading
| Tool | Type or Best for | Trading-relevant access | Price |
|---|---|---|---|
| QuickNode | Full-featured trading infrastructure | HTTPS/WSS, archive, debug/trace, Streams and Smart Transactions | 1-month trial; Build $49/mo monthly |
| Alchemy | RPC, simulation and data APIs | HTTP/WSS, archive, trace/debug on paid plans, transaction simulation | 30M free CU/mo; $0.525/M CU PAYG |
| Infura | Standard JSON-RPC connectivity | HTTPS/WSS, archive reads and daily credit quotas | Free 3M daily credits; paid quotas |
| Chainstack | Optimized transaction submission | WSS, private submission path, archive and debug/trace on Growth+ | Free Developer; paid from $40/mo annual billing |
| Ankr | Per-request billing and verifiable RPC | EVM HTTPS, paid WSS and signed Verifiable RPC responses | Free quota; $0.00002 per standard EVM HTTPS request |
| Tatum | RPC gateway and event subscriptions | WSS block headers, pending hashes and logs; trace/debug methods | 100K lifetime free credits; dedicated 10 RPS key $99/mo |
| dRPC | Public endpoints and usage-based gateway | Public HTTP; paid WSS, archive and debug/trace | Free 50M CU/mo; PAYG $6/M requests; Pro $49/mo |
| GetBlock | Shared, flat-rate or dedicated Arbitrum nodes | JSON-RPC/WSS, archive and optional dedicated-node failover | Free; shared from $49/mo; Limitless from $150/mo; dedicated from $1,300/mo |
The tools
QuickNode
Arbitrum data and transaction infrastructure
QuickNode provides managed endpoints for Arbitrum One and Arbitrum Sepolia, with JSON-RPC over HTTPS and WebSockets. Its Arbitrum offering includes full historical state, debug_traceTransaction, trace methods, Streams for historical backfills and real-time data, and Webhooks for address and event notifications. It also documents Smart Transactions and transaction broadcasting. Pricing starts with a one-month free trial, followed by Build at $49 monthly or $34 per month with annual billing. API credit consumption varies by method.
Choose it when you want reads, event monitoring, historical queries and transaction delivery under one provider account.
Watch out for method-weighted credits and WebSocket response-size limits. Large responses may need ordinary HTTP requests instead.
Alchemy
RPC with simulation and data APIs
Alchemy offers a public Arbitrum mainnet endpoint for basic access and private API-key endpoints for application workloads. Its platform combines standard node connectivity with Smart WebSockets, transaction simulation, token and transfer APIs, and debugging and trace functionality on eligible paid plans. The free allowance is 30 million compute units monthly, while PAYG costs $0.525 per million CUs.
Choose it when your trading application needs contract reads, simulation and indexed data from the same platform.
Watch out for method-dependent CU costs; trace/debug access requires PAYG or Enterprise, not the free tier.
Infura
Conventional Ethereum-compatible RPC
Infura's Network APIs provide Arbitrum One and Arbitrum Sepolia endpoints over HTTPS and WebSockets. Archive access is also documented for Arbitrum, making the service suitable for applications that need historical contract state alongside ordinary balance, block and transaction queries. Its billing model assigns credits to individual operations. New accounts receive 3 million daily credits on the free tier, with Developer and Team plans offering larger daily allocations and higher throughput allowances.
Choose it when your infrastructure already uses Infura or you want a familiar API-key-based Ethereum development workflow.
Watch out for daily credit use: subscription setup and incoming WebSocket events consume credits. Connections disconnect when the quota is exhausted.
Chainstack
Managed RPC with optimized submission
Chainstack's Arbitrum Global Nodes provide geo-balanced connectivity through a managed endpoint. Its particularly relevant trading feature is optimized submission: signed mainnet transactions sent through eth_sendRawTransaction use a private routing path intended to reduce inclusion delays. The free Developer plan includes 3 million monthly request units, a 25 RPS limit and WebSockets. Archive data and Debug & Trace APIs start with Growth. Paid plans start at $40 per month on annual billing, while dedicated infrastructure is available on higher tiers.
Choose it when transaction submission and a managed regional endpoint matter alongside ordinary RPC access.
Watch out for fallback behavior: if the optimized path fails, submission falls back to the standard node route.
Ankr
Metered RPC with response verification
Ankr exposes standard Arbitrum JSON-RPC through its rpc.ankr.com endpoint family, alongside an Advanced API for enriched blockchain information. Standard EVM HTTPS requests cost $0.00002 each under its published PAYG pricing. WebSocket subscriptions and notifications have separate usage accounting and require Premium access. Every Premium API key can use Arbitrum Verifiable RPC; each response is signed by an attested Intel TDX node and can be verified by the application.
Choose it when transparent per-request billing or cryptographically verifiable contract and balance reads are important.
Watch out for WebSocket access requires a paid plan, and Verifiable RPC costs three times the standard EVM request rate.
Tatum
RPC gateway with live Arbitrum subscriptions
Tatum's Smart Gateway routes requests through an intelligent balancing layer that selects a healthy node. Its Arbitrum One documentation lists standard JSON-RPC, transaction submission, historical queries and debug/trace methods. An October 2026 update introduced WebSocket subscriptions for new block headers, pending transaction hashes and filtered contract logs. Standard RPC methods cost 2 credits, eth_call costs 5, and debug or trace methods cost 50. The free account includes 100,000 lifetime credits; a dedicated 10 RPS API key costs $99 monthly.
Choose it when you want gateway-managed connectivity and native event subscriptions alongside ordinary RPC calls.
Watch out for the limited free allowance; pending transaction notifications are not confirmations. Production subscriptions need reconnection and missed-event recovery.
dRPC
Usage-priced Arbitrum RPC gateway
dRPC documents public Arbitrum HTTPS and WSS endpoints alongside account-based access to premium nodes. Its billing uses compute units, with 50 million monthly CUs on the free plan, PAYG at $6 per million requests and Pro at $49 monthly. Premium plans provide archive access, debug and trace methods, and WebSocket functionality.
Choose it when you want a usage-priced gateway and the option to move from public access to premium infrastructure.
Watch out for the free plan's limits: its pricing matrix excludes archive, debug, trace and WebSocket access. Confirm account permissions before relying on a published public WSS URL.
GetBlock
Configurable shared and dedicated nodes
GetBlock operates Arbitrum Nitro full and archive nodes for mainnet and Sepolia, with JSON-RPC and WebSocket connectivity. Its free endpoint includes 50,000 daily compute units. Shared Arbitrum access starts at $49 monthly, while its flat-rate Limitless option starts at $150. Dedicated full nodes start at $1,300 monthly, with archive configurations starting at $2,100. Dedicated deployments offer regional placement and optional RPC failover.
Choose it when you need configurable node capacity, archive infrastructure or a dedicated deployment for an exchange or trading system.
Watch out for the higher monthly commitment of dedicated infrastructure compared with shared access. Check the selected node's RPS tier, archive configuration and add-on costs before deployment.
How to set up an Arbitrum RPC for a trading bot
- Confirm the network. Use Arbitrum One mainnet with chain ID 42161 for live trading. Arbitrum Sepolia uses chain ID 421614 for testing. Confirm that your endpoint belongs to the intended network before sending transactions.
- Map your RPC requirements. Use eth_call for pool state, token balances and contract quotes. Use eth_getLogs for historical event retrieval, eth_subscribe for live headers and contract events, and eth_sendRawTransaction to broadcast signed transactions. Add archive access when your strategy needs historical state, and trace methods when investigating execution failures.
- Select the right endpoint and plan. Create a provider account and provision a private Arbitrum endpoint. Check whether your plan includes WSS, archive access, trace/debug methods and the required request throughput. Keep authenticated endpoints on your backend rather than exposing API credentials in a public frontend.
- Benchmark your actual request mix. Run the same contract reads, log queries, receipt lookups and controlled test broadcasts against the shortlisted providers from your bot's deployment region. Record P50 and P95 response times, block-head lag, errors, HTTP 429 responses and WebSocket recovery behaviour. A simple block-number query alone does not represent a trading workload.
- Build a reliable event listener. Subscribe to newHeads and filtered contract logs over WSS. Persist the last processed block and identify events using their transaction hash and log index. If the connection drops, reconnect and retrieve missed events with eth_getLogs. Deduplicate recovered events and handle removed logs when a reorganization invalidates earlier notifications.
- Separate signing, reading and broadcasting. Keep private keys in your own signing environment. Check balances, allowances, quote data and gas estimates before signing. Submit the signed transaction through eth_sendRawTransaction, retain its transaction hash and monitor its receipt. Configure a second provider for read failover and handle ambiguous broadcast responses without creating unintended duplicate transactions.
- Handle pending transactions carefully. Provider-specific pending hash notifications are not a complete view of sequencer ordering. If your strategy depends on sequencer-level information, treat the sequencer feed as a separate infrastructure requirement.
Worked example (illustrative): A bot monitors 12 liquidity pools through filtered log subscriptions and calls eth_call to check the affected pool before signing a swap. If it makes 50,000 standard EVM HTTPS requests through Ankr in a month, the published $0.00002 rate implies $1 in request charges. WebSocket notifications, enhanced APIs and Verifiable RPC usage are accounted for separately, while a second endpoint provides an independent source for state and receipt checks.
Protect the execution path
RPC connectivity does not guarantee transaction inclusion, execution price or protection against adverse transaction ordering. Keep the signer separate from provider credentials, enforce trade-size and slippage limits, and verify important contract addresses against trusted project documentation. Monitor head lag, provider errors and unexpected state differences, and stop automated execution when your infrastructure no longer meets its safety thresholds.
Frequently asked questions
Which Arbitrum RPC should I use for a trading bot?
QuickNode provides a broad combination of live feeds, historical access and transaction tooling. Chainstack is worth considering when its documented optimized submission path is central to your architecture, while GetBlock offers configurable dedicated infrastructure.
Does Arbitrum use ETH or ARB for gas?
Arbitrum One uses ETH to pay transaction fees. ARB is the network's governance token, so a wallet needs ETH for gas even when trading ARB-denominated assets.
Does Arbitrum have a public mempool?
Arbitrum does not expose an Ethereum-style public mempool. The sequencer feed is separate from ordinary JSON-RPC WebSocket subscriptions, and provider-specific pending transaction notifications should not be treated as a complete view of incoming transactions.
Do I need an archive RPC for live trading?
Not necessarily. Current-state reads and live event monitoring can use an ordinary full node. Archive access becomes relevant when querying historical balances, storage, contract-call results or reconstructing older pool states.
Can WebSockets replace regular RPC polling?
They can handle continuous block and contract-event notifications, reducing the need for repeated polling. They do not eliminate HTTP queries: applications still need historical log retrieval and recovery after connection interruptions or chain reorganizations.
Does a premium RPC guarantee faster or successful swaps?
No. Dedicated capacity affects RPC throughput, not sequencer ordering, liquidity or contract execution. Sequencer ordering, gas parameters, liquidity and trade conditions remain relevant.
Sources
Show all 18 sources
- QuickNode Arbitrum infrastructure
- QuickNode pricing
- Alchemy Arbitrum RPC
- Alchemy pricing and plan features
- Infura supported endpoints
- Infura credit pricing
- Chainstack Arbitrum RPC and submission
- Chainstack pricing
- Ankr Arbitrum API documentation
- Ankr RPC pricing
- Ankr Verifiable RPC for Arbitrum
- Tatum Arbitrum RPC reference
- Tatum Arbitrum WebSocket update
- Tatum pricing
- dRPC Arbitrum API documentation
- dRPC plans and billing
- GetBlock Arbitrum RPC infrastructure
- GetBlock infrastructure pricing