Last updated: 4 November 2026 · Prices, Arbitrum method weights, plan limits and network support rechecked on vendor pages and Arbitrum’s docs on 4 November 2026
The best Arbitrum RPC providers in 2026 are Chainstack for overall value, Alchemy for a free tier with its full app tooling and priced Arbitrum trace methods, and QuickNode for the widest Arbitrum network coverage and audits. We ranked eight providers on the weights from our main RPC ranking, priced three Arbitrum workloads on every vendor’s own meter and tested eight free public Arbitrum One endpoints ourselves.
Arbitrum looks like any EVM chain from your code, but two things change the provider choice: a sequencer that orders every transaction, and a split between pre-Nitro and Nitro-era history for tracing. This guide is the Arbitrum cut of our ranking of the 12 best RPC node providers, and our methodology page explains how we collect prices and screenshots.
TL;DR
- Ranking: 1. Chainstack (8.6), 2. Alchemy (8.0), 3. QuickNode (8.0), 4. GetBlock (7.7), 5. dRPC (7.6), 6. Ankr (6.0), 7. Infura (5.9), 8. NOWNodes (4.4).
- One million Arbitrum calls in a typical DeFi app mix cost $2.45 on Chainstack Growth and $4.80 on dRPC Pro, against $12.25 on QuickNode Build, $13.47 on Alchemy pay as you go and $20.00 on Ankr.
- A 10M-request Arbitrum app costs $49 a month on Chainstack or dRPC. A 60M-request arbitrage bot costs $199 on Chainstack Pro and $632 on QuickNode Scale.
- Arbitrum’s own provider table marks only QuickNode and dRPC for all of Arbitrum One, Nova, Sepolia and WebSocket among the eight we ranked.
- Arbitrum’s public RPC has no WebSocket and no uptime, latency or rate-limit guarantee. Its sequencer endpoint accepts only sends, and a successful send means your transaction is already in an L2 block.
- In our test, none of eight free public Arbitrum One endpoints served debug and archive reads together, and three capped or refused a 1,000-block log query.
The Decision Kernel
Pick an Arbitrum provider by what your app does with history and sends. Indexers need cheap logs, archive and the right trace methods, while bots need fast sends and a fallback path. Price your real Arbitrum method mix first, because the same call costs 1 unit on Chainstack, 20 on QuickNode and 200 on Ankr.
- Lowest bill with audits: Chainstack, at 1 request unit per call, 2 for archive, debug and trace, with SOC 2 Type II and ISO 27001.
- Free tier and trace tooling: Alchemy, with 30M compute units a month free and eight priced
arbtrace_*methods on paid usage. - Arbitrum One, Nova and Sepolia from one vendor: QuickNode, with 20 credits per call on every Arbitrum method and the widest audit set.
- Flat monthly price at high volume: GetBlock, whose Limitless Node serves Arbitrum at 150 requests per second for $500 a month with no unit metering.
- Cheapest flat per-request meter: dRPC, at $4.80 per million calls on Pro whatever the method.
- Already on MetaMask tooling: Infura, with Arbitrum One and Sepolia over HTTPS and WebSocket, if a daily quota suits your traffic.
Verdict: Chainstack for most Arbitrum teams, Alchemy while you fit its free tier or need its Arbitrum trace methods, QuickNode when Nova and audits matter. Keep a second provider as a fallback either way.
How We Ranked the Arbitrum RPC Providers
We scored each provider from 1 to 5 on six weighted criteria, doubled for a score out of 10. Weights, reliability, compliance and free tier scores come from our 12-provider RPC ranking. We rescored price, features and network access for Arbitrum, because unit weights, trace methods and Nova or Sepolia support differ by vendor.
- Price per call, 25%: the price of one million Arbitrum calls in a DeFi app mix on each entry plan, from each vendor’s own Arbitrum weights.
- Reliability, 20%: public latency benchmarks, uptime claims, SLAs and support response targets.
- Compliance, 15%: SOC 2, ISO 27001 and other audits stated on the vendor’s own pages.
- Features, 15%: debug, trace and
arbtrace_*methods, dedicated or flat-rate nodes, streaming and data APIs. - Arbitrum access, 15%: Arbitrum One, Nova and Sepolia, WebSocket, archive data and Stylus tracing, from Arbitrum’s provider table and vendor docs.
- Free tier, 10%: how many real Arbitrum calls a team can make before paying.
| Provider | Price (25%) | Reliability (20%) | Compliance (15%) | Features (15%) | Arbitrum access (15%) | Free tier (10%) | Score |
|---|---|---|---|---|---|---|---|
 | 5 | 4 | 5 | 4 | 4 | 3 | 8.6 |
 | 3 | 4 | 4 | 5 | 4 | 5 | 8.0 |
 | 3 | 4 | 5 | 5 | 5 | 2 | 8.0 |
 | 4 | 5 | 4 | 4 | 3 | 2 | 7.7 |
 | 5 | 4 | 2 | 3 | 4 | 4 | 7.6 |
 | 2 | 3 | 4 | 3 | 3 | 4 | 6.0 |
 | 3 | 3 | 1 | 3 | 4 | 4 | 5.9 |
 | 3 | 3 | 1 | 2 | 2 | 1 | 4.4 |
Chainstack leads because its flat meter carries into archive and trace at 2 units per call. QuickNode gains a point on Arbitrum access for Nova and Sepolia, while GetBlock and NOWNodes lose points because Arbitrum’s own table marks neither for Sepolia.
What Makes Arbitrum RPC Different
Arbitrum One (chain ID 42161) is an optimistic rollup run by a sequencer that orders transactions before they post to Ethereum. Its sibling Arbitrum Nova (42170) uses the AnyTrust design, and Arbitrum Sepolia (421614) is the testnet, per Arbitrum docs. Arbitrum says its public RPC endpoints support no WebSocket and give no uptime, latency or rate-limit guarantees.
- Two public endpoints:
arb1.arbitrum.io/rpcfor general reads and writes, andarb1-sequencer.arbitrum.io/rpc, which accepts onlyeth_sendRawTransactionandeth_sendRawTransactionConditional. - Sends confirm fast: Arbitrum says a successful send returns only after the sequencer has put the transaction in an L2 block, which it calls a soft confirmation.
- Bounded queue: the sequencer queue holds 1,024 transactions with a 12-second default timeout, and a
context deadline exceedederror means the transaction was not accepted and is safe to retry. - Sequencer feed:
wss://arb1-feed.arbitrum.io/feedstreams ordered transactions for teams that run their own node. - Two trace families: Nitro-era blocks use
debug_trace*, and Chainstack states in its Arbitrum provider comparison thatarbtrace_*covers pre-Nitro blocks only. Indexers that read old history need both.
Verdict: Use a provider for reads, WebSocket and history, and treat the sequencer endpoint as an extra send path, not your only one.
Arbitrum Network Support by Provider
We took each provider’s row from Arbitrum’s own third-party RPC provider table on 4 November 2026 and checked it against vendor docs. QuickNode and dRPC are the only two of the eight ranked providers that Arbitrum marks for Arbitrum One, Nova, Sepolia and WebSocket.
| Provider | Arbitrum One | Nova | Sepolia | WebSocket | Stylus tracing |
|---|---|---|---|---|---|
| Yes | Not marked | Not marked | Yes | Paid plans |
| Yes | Not marked | Yes | Yes | Paid plans |
| Yes | Yes | Yes | Yes | Testnet in free tier |
| Yes | Not marked, listed on its CU page | Not marked | Yes | Not marked |
| Yes | Yes | Yes | Yes | Not marked |
| Yes | Not marked | Not marked | Yes | Paid plans |
| Yes | Not marked | Yes | Yes | On request |
| Yes | Not marked | Not marked | Not marked, paid plans per its pricing | Not marked |
Vendor pages fill some gaps. QuickNode prices Arbitrum Nova at the same 20 credits as Arbitrum One on its Arbitrum credit page, and GetBlock lists Arbitrum Nova at a chain multiplier of 100 against 20 for Arbitrum One on its CU page. Infura’s endpoint list shows Arbitrum Mainnet and Sepolia over HTTPS and WebSocket.
Verdict: For Nova apps, start with QuickNode or dRPC. On GetBlock, budget five times the Arbitrum One units for Nova calls.
Arbitrum RPC Providers at a Glance
The table lines up each provider’s Arbitrum billing unit, free tier and entry plan. Fixed plans include a monthly allowance with overage above it, while Alchemy and Ankr bill pure usage. A credit on one vendor is not a credit on another, so check the unit first.
| Provider | Arbitrum billing unit | Free tier | Entry paid plan |
|---|---|---|---|
| 1 request unit per call, 2 for archive, debug and trace | 3M RU a month, 25 rps | Growth $49, 20M RU, 250 rps |
| Compute units per method, 10 to 60 for common calls | 30M CU a month, 15 rps | Pay as you go, $0.52 per 1M CU |
| 20 credits per Arbitrum call, x2 for trace and debug | 10M credits, one-month trial | Build $49, 80M credits, 50 rps |
| 20 CU per Arbitrum call, x2 for archive and debug | 50K CU a day | Starter $49, 90M CU, 250 rps |
| Flat price per request | 210M CU on public nodes, 100 rps | Pro $49, 10M requests, 300 rps |
| 200 API credits per EVM call | 200M credits a month | Pay as you go, $0.10 per 1M credits |
| 80 credits for most reads, daily quota | 3M credits a day | Developer $50, 15M credits a day |
| 1 request per call | 100,000 requests, one month only | Pro €20, 1M requests |
Verdict: Chainstack and dRPC give the most Arbitrum calls for $49. Chainstack’s free tier gives the most private Arbitrum calls at 3M a month, and Ankr’s 200 credits per call make it the priciest pure meter here.
What One Million Arbitrum Calls Cost
We converted each entry plan into the price of one million Arbitrum calls for three method mixes, using each vendor’s own weights. QuickNode, dRPC, Ankr and NOWNodes charge the same for every mix, while Alchemy, GetBlock and Infura cost more as logs and archive reads grow.
- DeFi app mix: 40%
eth_call, 15% balances, 15% block numbers, 10% receipts, 10% logs, 5% sends and 5% gas estimates. - Arbitrage bot mix: 45%
eth_call, 15% receipts, 10% nonces, 10% balances, 10% sends, 5% gas estimates and 5% blocks. - Indexer mix: 45%
eth_getLogs, 25% blocks, 20% receipts and 10%eth_callover history, at archive rates where vendors charge them.
| Entry plan | DeFi app mix, per 1M | Arbitrage bot mix, per 1M | Indexer mix, per 1M |
|---|---|---|---|
| $2.45 | $2.45 | $4.90 |
| $4.80 | $4.80 | $4.80 |
| €9.00 | €9.00 | €9.00 |
| $10.89 | $10.89 | $21.78 |
| $12.06 | $10.11 | $17.64 |
| $12.25 | $12.25 | $12.25 |
| $13.47 | $12.84 | $20.07 |
| $20.00 | $20.00 | $20.00 |
Alchemy’s app mix averages 25.9 compute units per call and its indexer mix 38.6, because eth_getLogs costs 60. Infura’s app mix averages 108.5 credits, driven by 255 for logs and 300 for gas estimates. Fixed plans only reach these rates when you use the whole allowance.
Verdict: Chainstack is the cheapest meter on app and bot traffic, and dRPC edges it for archive-heavy indexing at a flat $4.80. QuickNode’s flat 20 credits beat Alchemy and GetBlock on indexer reads.
What Three Arbitrum Workloads Cost
We built three Arbitrum traffic patterns, converted each into every vendor’s unit and picked the cheapest public plan that covers the volume and a peak of three times the average rate. Chainstack had the lowest US dollar bill in all three workloads, from $49 for the app to $499 for the archive indexer.
| Provider | Arbitrum DeFi app, 10M | Arbitrum arbitrage bot, 60M | Arbitrum indexer backfill, 100M |
|---|---|---|---|
| $49 (Growth) | $199 (Pro) | $499 (Business) |
| $135 (Pay as you go) | $771 (Pay as you go) | $2,007 (Pay as you go) |
| $123 (Build) | $632 (Scale) | $999 (Business) |
| $199 (Advanced) | $579 (Pro) | $1,539 (Premium) |
| $49 (Pro) | $277 (Scale) | $517 (Scale) |
| $200 (Pay as you go) | $1,200 (Pay as you go) | $2,000 (Pay as you go) |
| $225 (Team) | Enterprise quote | Enterprise quote |
| €90 (Pro Plus) | €400 (Business Plus) | €500 (Enterprise) |
- Arbitrum DeFi app, 10M requests: the app mix with a peak of 12 requests per second.
- Arbitrum arbitrage bot, 60M requests: the bot mix with a peak of 69 requests per second.
- Arbitrum indexer backfill, 100M requests: the indexer mix over history with a peak of 116 requests per second.
Plan limits moved several answers. The bot needs 1.2B GetBlock CU, which lands on Pro at $499 plus $80 of overage, but GetBlock’s Limitless Node covers the same bot at 150 requests per second for a flat $500. Infura’s daily quota rules out its public plans for the bot and the indexer, and QuickNode Build’s 50 requests per second pushed the bot to Scale.
Verdict: For Arbitrum apps and bots, Chainstack and dRPC cost the least. For a steady high-rate bot, price GetBlock’s flat Limitless Node against any metered plan.
Free Public Arbitrum Endpoints, Tested
We tested eight free public Arbitrum One endpoints on 4 November 2026 from one cloud server. We timed 7 eth_blockNumber calls each, ran a 1,000-block USDC eth_getLogs query, read an old balance and tried debug and arbtrace calls. Only Tenderly served both the 1,000-block log query and the archive read, and it was the slowest endpoint at a 982ms median.
| Endpoint | Median latency | 1,000-block eth_getLogs | Archive at block 30M | debug trace |
|---|---|---|---|---|
| arb1.arbitrum.io/rpc | 170 ms | 4,802 logs returned | No, missing trie node | Not available |
| arbitrum.drpc.org | 133 ms | Refused on free plan | No | Served |
| arbitrum-one-rpc.publicnode.com | 215 ms | 403, personal token required | 403, token required | Not available |
| arbitrum.gateway.tenderly.co | 982 ms | 5,019 logs returned | Yes | HTTP 429 |
| arb-pokt.nodies.app | 192 ms | 50-block cap | Yes | Paid plans only |
| 1rpc.io/arb | 167 ms | 50-block cap | No, missing trie node | Not allowed |
| arbitrum.meowrpc.com | 412 ms | Method not supported | HTTP 429 | HTTP 429 |
| rpc.ankr.com/arbitrum | No answer | n/a | n/a | n/a |
Our medians come from one server and seven calls, so treat them as a snapshot. OpenChainBench, which probes keyless Arbitrum endpoints every minute from three regions and is linked from Arbitrum’s docs, showed dRPC fastest at a 44ms p50 on 4 November 2026. dRPC’s public node was also the only one in our test to serve a debug trace.
Verdict: Use public endpoints for prototypes and as a last fallback only. Put production reads, logs, traces and WebSocket subscriptions on a paid provider.
1. Chainstack
- Plans: Developer free (3M RU, 25 rps), Growth $49 (20M, 250 rps), Pro $199 (80M, 400 rps), Business $499 (200M, 600 rps), Enterprise $990 (400M). Overage runs $15, $12.50, $10 and $5 per 1M RU on the paid tiers, and annual billing saves 16%.
- Meter: 1 RU per full-node call and 2 RU for archive, debug and trace calls on Global Nodes, per its request unit rules. Trader Nodes bill every call at 1 RU but do not serve archive state.
- Arbitrum depth: archive data and the Debug and Trace API on paid plans, Stylus tracing on paid plans per Arbitrum’s table, and dedicated nodes billed on compute rather than requests.
- Weaknesses: Arbitrum’s table does not mark Chainstack for Nova or Sepolia, and Growth overage costs six times the included rate.
Verdict: Chainstack scores 8.6. It had the lowest US dollar bill in all three workloads and pairs that with SOC 2 Type II and ISO 27001. See its entry in our full RPC ranking.
2. Alchemy
- Plans: Free (30M CU a month, 15 rps), Pay as you go at $0.52 per 1M CU from 300 rps, and Enterprise, per its pricing page. Debug and Trace APIs are not on Free.
- Meter: 10 CU for
eth_blockNumber, 20 for balances and receipts, 26 foreth_call, 40 for sends and 60 foreth_getLogs, per its compute unit table. - Free tier in Arbitrum terms: about 1.16M calls a month in our app mix at 15 requests per second, fewer raw calls than Chainstack’s 3M but with Alchemy’s data APIs included.
- Weaknesses: $13.47 per million app calls and $20.07 per million indexer calls on pay as you go, and no Nova mark in Arbitrum’s table.
Verdict: Alchemy scores 8.0. Pick it to launch on the free tier or when its Arbitrum trace methods and app tooling save engineering time. See its entry in our full RPC ranking.
3. QuickNode
- Plans: Build $49 (80M credits, 50 rps), Accelerate $249 (450M, 125 rps), Scale $499 (950M, 250 rps) and Business $999 (2B, 500 rps), per its pricing page. Overage runs $0.62 to $0.50 per 1M credits, and annual billing is about 30% off.
- Meter: 20 credits per Arbitrum call per its Arbitrum credit page, or $12.25 per million calls on Build. Some competitor pages still quote 10 credits, which is the rate QuickNode lists for other chains.
- Audits: SOC 1 Type 2, SOC 2 Type 2 and ISO 27001 on its Enterprise plan listing.
- Weaknesses: Build caps throughput at 50 requests per second, and our arbitrage bot needed Scale at $632.
Verdict: QuickNode scores 8.0. Pick it when Nova support, audits and Streams matter more than price. See its entry in our full RPC ranking.
4. GetBlock
- Shared plans: Starter $49 (90M CU, 250 rps), Growth $99 (185M), Advanced $199 (385M), Scale $349 (700M), Pro $499 (1B CU, 800 rps, $0.40 per 1M overage) and Premium $699 (1.6B, $0.35), per its pricing page. Free gives 50K CU a day.
- Limitless Node: Arbitrum full node at 25, 50, 150 or 300 requests per second for $150, $300, $500 or $1,000 a month, and archive at 15, 30, 50 or 100 requests per second for the same prices.
- Meter: chain multiplier 20 for Arbitrum and 100 for Arbitrum Nova, per its CU rules.
- Weaknesses: archive doubling put our indexer at $1,539 on shared plans, and Arbitrum’s table marks GetBlock for Arbitrum One and WebSocket only.
Verdict: GetBlock scores 7.7. Pick it for steady high-rate traffic on a flat bill, or when uptime leads the brief. See its entry in our full RPC ranking.
5. dRPC
- Plans: Free on public nodes (210M CU, 100 rps), Pro $49 (10M multi-chain requests, 300 rps), Scale $199 (47M, 600 rps) and Enterprise from $990, per its pricing page. Overage and pay as you go cost $6 per 1M requests.
- Arbitrum access: Arbitrum One, Nova and Sepolia with HTTPS, WSS and archive, per its Arbitrum chain page and Arbitrum’s table.
- Flat meter: $4.80 per million calls on Pro and $4.23 on Scale whatever the method, so log-heavy and trace-heavy work costs the same as reads.
- Weaknesses: no audit report on its own pages, and its free public node refused our 1,000-block log query.
Verdict: dRPC scores 7.6. Pick it for the cheapest flat meter and broad Arbitrum network access when audit paperwork is not required. See its entry in our full RPC ranking.
6. Ankr
- Plans: Public, Freemium (200M credits a month) and Premium pay as you go or Deal, per its service plans. Premium allows up to about 1,500 requests per second per endpoint.
- Arbitrum depth: trace and debug on Premium only, WebSocket on Premium, and Stylus tracing on paid plans per Arbitrum’s table.
- Weaknesses: the highest per-call meter here, a $1,200 bill for our arbitrage bot, and its public Arbitrum endpoint did not answer our keyless test.
Verdict: Ankr scores 6.0. It fits bursty, low-volume Arbitrum apps that need a high rate ceiling on prepaid credits. See its entry in our full RPC ranking.
7. Infura
- Plans: Core free (3M credits a day, 500 credits per second), Developer $50 (15M a day, 4,000 per second, Debug and Trace API) and Team $225 (75M a day), per its pricing page.
- Meter: 80 credits for
eth_calland most reads, 255 foreth_getLogs, 300 for gas estimates and 1,000 fordebug_traceTransaction, per its credit cost table. - Weaknesses: requests stop once the daily quota is used, our 10M-request app already needed Team at $225, and there is no SOC 2 or ISO 27001 report on its pages.
Verdict: Infura scores 5.9. It suits teams already on Consensys and MetaMask tooling with steady, modest daily Arbitrum traffic. See its entry in our full RPC ranking.
8. NOWNodes
- Plans: Start free (100,000 requests, 15 rps, five networks, one month only), Pro €20 (1M), Pro Plus €90 (10M), Business €200 (30M), Business Plus €300 (50M) and Enterprise €500 (100M), per its pricing page.
- Arbitrum tools: its Arbitrum page lists WSS, Blockbook and Debug tools, and WebSocket is on paid plans only.
- Weaknesses: Arbitrum’s table marks it for Arbitrum One only, no audits on its pages, and NOWNodes says having no rate limit is not a throughput guarantee.
Verdict: NOWNodes scores 4.4. It fits small teams that want simple request counting in euros across many chains. See its entry in our full RPC ranking.
Providers We Left Out
Arbitrum’s table lists more than 20 providers, including Allnodes, Dwellir, Tenderly, Validation Cloud and BlockPI, but they are not in our main ranking yet. Helius, Tatum and Lava appear in our RPC node provider ranking, but Helius is Solana only, and we kept this guide to the eight providers whose Arbitrum pricing we verified on 4 November 2026.
Running your own Arbitrum node is the other route, with the sequencer feed for ordered transactions. You then own storage, upgrades and pre-Nitro history. Our RPC provider pricing guide shows where a managed plan stops being cheaper.
Final Ranking
Chainstack wins on Arbitrum because it pairs the lowest meter with archive, debug and trace at 2 units per call and audits on one plan. Alchemy and QuickNode trade price for tooling and reach, and dRPC offers a flat price without audits. For other chains, see our Ethereum RPC ranking and Base RPC ranking.
Verdict: Run production Arbitrum traffic on Chainstack, or Alchemy while you fit its free tier, and keep QuickNode or dRPC as the fallback. Add the sequencer endpoint as a second send path for bots.
How to Set Up an Arbitrum RPC Fallback
Two providers behind one client cover outages, rate limits and the odd lagging node. In ethers v6, a FallbackProvider sends each read to the highest-priority healthy endpoint and fails over when it stalls. Put your cheapest provider first and a second vendor behind it.
import { FallbackProvider, JsonRpcProvider } from "ethers";
const arb = { chainId: 42161, name: "arbitrum" };
const reads = new FallbackProvider([
{ provider: new JsonRpcProvider(process.env.PRIMARY_ARB_URL, arb, { staticNetwork: true }), priority: 1, weight: 2, stallTimeout: 400 },
{ provider: new JsonRpcProvider(process.env.BACKUP_ARB_URL, arb, { staticNetwork: true }), priority: 2, weight: 1, stallTimeout: 800 },
], arb, { quorum: 1 });For sends, try your provider first and fall back to Arbitrum’s sequencer endpoint. Retry only on transient errors such as context deadline exceeded or a dropped connection, which Arbitrum says are safe to retry, and never on nonce too low or a revert.
const SEQ = new JsonRpcProvider("https://arb1-sequencer.arbitrum.io/rpc", arb, { staticNetwork: true });
const PRIMARY = new JsonRpcProvider(process.env.PRIMARY_ARB_URL, arb, { staticNetwork: true });
async function send(signedTx, tries = 3) {
for (const p of [PRIMARY, SEQ]) {
for (let i = 0; i < tries; i++) {
try { return await p.broadcastTransaction(signedTx); }
catch (e) {
const msg = String(e?.message || e);
if (/nonce too low|revert|insufficient funds/i.test(msg)) throw e;
await new Promise(r => setTimeout(r, 250 * 2 ** i));
}
}
}
throw new Error("all send paths failed");
}To check what a provider serves before you sign up, run the same three probes we used: a log query across 1,000 blocks, a balance read at an old block, and a debug trace on a recent block.
curl -s -H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"eth_getBalance","params":["0x0000000000000000000000000000000000000000","0x1c9c380"]}' \
"$ARB_RPC_URL"Frequently Asked Questions
What is the best Arbitrum RPC provider in 2026?
On our weighted scorecard, Chainstack is the best Arbitrum RPC provider at 8.6 out of 10. It bills 1 request unit per call and 2 for archive, debug and trace, and states SOC 2 Type II and ISO 27001. Alchemy and QuickNode follow at 8.0, with Alchemy ahead on its free tier.
What is the cheapest Arbitrum RPC provider?
Chainstack had the lowest US dollar bill in all three of our Arbitrum workloads: $49 for a 10M-request app, $199 for a 60M-request arbitrage bot and $499 for a 100M-request archive indexer. dRPC matched it at $49 for the app and is the cheapest flat meter at $4.80 per million calls.
Is the public Arbitrum RPC endpoint good enough for production?
No. Arbitrum’s docs say its public RPC endpoints give no uptime, latency or rate-limit guarantees and support no WebSocket. In our test, arb1.arbitrum.io answered in a 170ms median and returned 1,000 blocks of logs, but it served no archive reads, debug traces or arbtrace calls.
Which providers support Arbitrum Nova?
Among the eight providers we ranked, Arbitrum’s own provider table marks QuickNode and dRPC for Arbitrum Nova. QuickNode prices Nova calls at 20 credits, the same as Arbitrum One. GetBlock lists Nova on its compute unit page at a chain multiplier of 100, five times its Arbitrum One rate.
What is the Arbitrum sequencer endpoint used for?
The sequencer endpoint, arb1-sequencer.arbitrum.io/rpc, is a direct send path that accepts only eth_sendRawTransaction and eth_sendRawTransactionConditional. A successful response means the transaction is already in an L2 block. A context deadline exceeded error means it was not accepted and can be retried safely.
How many API credits does an Arbitrum call cost on QuickNode?
QuickNode charges 20 API credits for every Arbitrum and Arbitrum Nova method, with a 2x multiplier for trace, debug and arbtrace calls and 4x for arbtrace replay methods. On the $49 Build plan with 80M credits, that is $12.25 per million calls. Some third-party pages still quote 10 credits.
