Top 8 Arc RPC Providers 2026: Pricing and Archive Access Compared

Submit a transaction to Arc with maxFeePerGas below 20 Gwei and it does not fail. It disappears. The mempool drops it silently, no error receipt is produced, and it never appears in a block. Your retry logic sees a pending transaction that will stay pending forever.

That is one of about six ways Arc departs from the EVM you are used to, and most of them land on your RPC layer, not your contracts. Arc's public mainnet goes live today, September 16, 2026, secured by a founding validator cohort that includes BlackRock, DTCC, Visa, Mastercard, ICE, Standard Chartered, Galaxy, Global Payments, MoneyGram, SBI Group and Sumitomo Corporation.

Circle runs a public endpoint of its own, and it works for development. It will not carry a payment system. This comparison covers the seven providers selling managed Arc RPC, plus Tenderly, which pairs an Arc node gateway with simulation and debugging. Pricing is a list-price snapshot from 2026-09-28, normalized to dollars per million calls.

What Makes Arc Different for RPC

Arc pairs a Reth execution layer with Malachite BFT consensus, producing blocks roughly every 0.5 seconds with deterministic finality in under one second. Circle's system overview puts the network at 3,000+ TPS with 20 validators, benchmarked at under 350ms finality. Standard Solidity, Foundry, Hardhat, viem and ethers.js all work unchanged.

The differences that matter sit below that familiar surface.

USDC is the native gas token, with two decimal representations. Per Arc's EVM differences reference, USDC on Arc exposes a native interface at 18 decimals and an ERC-20 interface at 6 decimals, sharing one balance. Raw values are off by a factor of 10^12. A zero balanceOf does not mean the native balance is zero, because the ERC-20 view truncates sub-USDC fractions. Any reconciliation system that reads balances over RPC needs to pick the right interface and stay on it.

Native transfers emit Transfer logs from a system address. Arc ships EIP-7708 ahead of Ethereum, so plain native sends, contract endowments and self-destruct transfers all emit standard ERC-20 Transfer logs from the system emitter at 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE. Tracking USDC movement means watching two emitter addresses, the system emitter and the ERC-20 contract, without double-counting. That makes Arc indexing unusually eth_getLogs heavy, and eth_getLogs is the method compute-unit providers charge the most for.

The 20 Gwei floor drops transactions without a receipt. Arc's gas and fees reference sets the minimum base fee at 20 Gwei and the maximum at 20,000 Gwei. Anything submitted below the floor is dropped by the mempool with no error. There is no txpool namespace on Arc to inspect either, so the only reliable defence is checking maxFeePerGas against the floor before you sign. Receipt polling alone will never show you the transaction.

Value transfers revert in ways they do not elsewhere. Sends to the zero address revert. Sends to precompiles revert. Sends to an already self-destructed account revert. The blocklist is enforced at runtime, so a transfer to or from a blocklisted address reverts and still consumes gas. A common DeFi assumption, that forwarding native value to a contract succeeds, does not hold on Arc.

The debug, trace and txpool namespaces are not enabled. Arc's launch RPC configuration exposes eth_*, net_*, web3_* and rpc_modules, plus the Arc-specific arc_* reads. Calls to debug_*, trace_* and txpool_* return -32601 Method not found. Arc's documented full-provider configuration does not enable them, so this is a chain-level constraint rather than a per-provider feature gap, and no amount of paying up the tier list changes it. Combined with the revert rules above, it means you diagnose a failed Arc transaction with eth_call replayed against the failing block, or with off-chain simulation, rather than with debug_traceTransaction. It also removes the usual escape hatch for the dual-emitter log problem: on Arc, eth_getLogs is not merely the dominant method, it is close to the only one that scales.

Finality is deterministic, but blocks arrive fast. No reorgs, no confirmation windows, no rollback logic. You can fire webhooks and database writes on a single confirmation. The flip side is roughly 172,800 blocks per day, so slow block ingestion falls behind quickly.

Two non-obvious header details. The next block's base fee sits in the parent header's extra_data field as an 8-byte big-endian value, so your provider must return full, unmodified headers. And block timestamps are non-decreasing rather than strictly increasing, because sub-second blocks can share a one-second wall-clock timestamp. Order events by block number, never by timestamp.

What to Look for in an Arc RPC Provider

• Log query capacity. Dual-emitter USDC tracking makes eth_getLogs your dominant method. Check both the block-range cap and what the provider charges per log query.
• Archive access. Arc is aimed at institutions running settlement and reconciliation. Querying historical state at an arbitrary block height is a compliance requirement on a settlement chain.
• Archive depth, not trace tiers. Because Arc enables no debug_* or trace_* namespace, a provider's trace tier buys you nothing here. What matters is how far back its archive nodes let you replay state with eth_call.
• WebSocket support. eth_subscribe is WebSocket-only on Arc. Polling at 0.5 second block times is wasteful and lossy.
• Pricing transparency. Providers that bill in compute units apply multipliers where complex methods cost many times a simple read. On a log-heavy chain, that gap compounds.
• Uptime commitments. Settlement traffic does not tolerate a maintenance window. A 99.9% SLA permits 8.7 hours of downtime a year; 99.99% cuts that to 52 minutes.
• Compliance documentation. If your counterparties are the institutions running Arc's validators, SOC 2 and ISO 27001 reports become part of vendor qualification.

How to Compare Arc Pricing Across Unit Systems

Every provider in this comparison publishes a headline rate, and almost none of them are directly comparable. Three billing models are in play.

Per-request billing. One API response equals one billable request. An eth_getLogs spanning thousands of blocks costs the same as a single eth_getBalance. Dwellir, Chainstack and Pinax work this way, and dRPC's Growth plan bills a flat rate per request too. Dwellir's Developer plan works out to $1.96 per 1M calls included, with overage at $2-5 per 1M. Chainstack Growth is $2.45 per 1M included and $15 per 1M overage, and bills 2 request units for reads 127 or more blocks behind the tip, which on Arc is about one minute of history. Pinax charges $6.00 per 1M requests, and its Pro plan includes $200 of usage for $49, which works out to $1.47 per 1M until the allowance runs out.

Compute units and API credits. Each method carries a weight. The provider charges per million units, not per million requests, so your effective cost per call is the headline rate multiplied by that method's weight.

• Alchemy charges $0.525 per 1M CU. On Arc that is $31.50 per 1M eth_getLogs, $13.65 per 1M eth_call, $10.50 per 1M eth_getTransactionReceipt and $21.00 per 1M eth_sendRawTransaction.
• QuickNode assigns a flat 20 credits to every Arc call, which is $10.00 per 1M calls at Business's overage rate and $12.40 at Build's.
• dRPC assigns 20 CU to every method, a flat $6.00 per 1M calls.

Tenderly Units. A separate weighted system with no published dollar rate, covered in the Tenderly section below.

Method by method, in dollars per 1M calls at each plan's included rate:

Pinax, Dwellir and Chainstack overage runs $6.00, $2-5 and $5-20 per 1M respectively. On Chainstack, an eth_getLogs whose fromBlock is 127 or more blocks behind the tip bills as archive, $4.90 per 1M on Growth.

The monthly totals later in this post use an Arc indexing mix: 50% eth_getLogs over small, recent ranges on the two USDC emitters, 20% eth_call, 15% eth_getTransactionReceipt, 10% eth_blockNumber and 5% eth_sendRawTransaction, all on recent blocks, with no debug or trace because Arc does not enable them. On that mix an Arc call averages 41.2 CU on Alchemy, so 1M calls cost $21.63 and the free 30M CU covers about 728K calls. On QuickNode every call is 20 credits, so Build's 80M credits cover 4M calls and Business's 2B credits cover 100M calls at $999.

The weights are the whole story, and they live in documentation rather than on pricing pages. To compare anything, convert every provider to the same denominator: dollars per million requests, for the methods you actually call. On Arc that means eth_getLogs almost to the exclusion of everything else, because dual-emitter USDC tracking makes it the dominant method and the absent trace namespace removes the alternatives.

Weighted billing is a defensible model. An eth_getLogs over a wide block range genuinely costs a provider more to serve than an eth_blockNumber, and weights let providers price for that. The problem is comparability: headline rates imply a similarity that the weights remove.

1. Dwellir

Dwellir prices Arc on a 1:1 model. One API response counts as one credit, whatever the method. An eth_getBalance and an eth_getLogs query spanning a wide block range cost exactly the same.

Key features:

• 150+ supported networks
• Blocks, receipts and logs available back to genesis on the shared Arc endpoint
• WebSocket support on all paid plans
• European infrastructure
• Autoscaling with capped overage rates
• Unlimited Nodes for flat-rate, unmetered billing on the same endpoint URL and key
• Crypto payments accepted on every paid plan

Pricing:

For workloads where request volume is unpredictable, Dwellir also sells Unlimited Nodes: one endpoint with the meter switched off, priced on throughput.

A dedicated Arc node cluster lists at $4,300 per month, with unlimited RPS and responses.

The 1:1 model matters more on Arc than on a general-purpose chain. A wallet or payment reconciliation service on Arc spends most of its request budget on eth_getLogs against two emitter addresses, and that is the method carrying the steepest multipliers elsewhere: 60 CU on Alchemy, or $31.50 per 1M log queries.

Considerations: Dwellir runs Arc as full nodes on the shared endpoint, not archive. Blocks, receipts and logs are available back to genesis, so eth_getLogs backfills work from block 0, but state reads such as eth_call and eth_getBalance at old blocks are pruned. Alchemy, QuickNode, Chainstack, dRPC and Pinax advertise archive on Arc. As on every Arc provider, debug_*, trace_* and txpool_* return -32601 Method not found.

Best for: Teams running log-heavy Arc indexing or payment reconciliation where compute-unit multipliers would make the bill unpredictable. Teams that need historical state reads should pair Dwellir with an archive provider.

2. Chainstack

Chainstack has supported Arc testnet as a self-serve Global Node since July 2026, with mainnet available at launch. It exposes the eth, net, web3 and rpc namespaces alongside Arc's custom arc namespace, matching what Arc enables at the chain level.

Key features:

• Full and Archive node modes
• Custom arc namespace access
• Dedicated Nodes across 8 regions including Frankfurt, London, Tokyo and Singapore
• Unlimited Node add-on from $149/month at 25 RPS
• Self-Hosted deployment option
• 1:1 request unit billing

Pricing:

Chainstack bills request units without method multipliers, which puts it in the same directly comparable bracket as Dwellir. A request under 127 blocks behind the tip costs 1 RU and 127 or more blocks behind costs 2 RU; at Arc's 0.5 second blocks that boundary is about one minute old, so backfills and historical reads bill double. Its overage rates are the highest among the per-request providers here, so size your plan to your actual volume. The regional spread is the real differentiator: eight dedicated-node regions is more placement control than most providers offer self-serve, and on a settlement chain data residency is often a procurement question rather than a latency one.

Best for: Teams that need a specific deployment region for latency or data residency, or want 1:1 billing with a self-hosted deployment option.

3. dRPC

dRPC routes Arc traffic across multiple independent node operators behind an AI-driven load balancer, listing Arc with both archive and premium tiers.

Key features:

• 130+ chains across 225 networks
• Multi-provider routing with automatic failover
• Archive and premium Arc nodes
• Front-running protection
• 99.99% uptime on paid tiers
• Crypto payments

Pricing:

The free tier is the most generous available for Arc development: every method costs 20 CU, so 210M compute units cover about 10.5M calls at 100 RPS, and the keyless arc.drpc.org endpoint answered on 2026-09-28. It routes to public nodes only, which rules out archive-depth queries and carries no uptime commitment. Growth matches Dwellir's top self-serve throughput at 5,000 RPS. At $6.00 per 1M calls with no included allocation, dRPC sits above the included rates at Pinax, Dwellir and Chainstack and below QuickNode's $10.00-12.40 per 1M Arc calls, so it earns its place when you value multi-operator redundancy and no monthly commitment.

Best for: Teams that want no single-operator dependency for Arc, and would rather pay per request than commit to a monthly tier.

4. Blockdaemon

Blockdaemon announced Arc support during the public testnet and targets institutional deployments.

Key features:

• ISO 27001, SOC 1 Type 1 and SOC 2 Type II certified
• 60+ protocols with $10B+ in assets under management
• MPC-protected custody architecture
• Full-lifecycle managed node automation
• HTTP and WebSocket Arc endpoints

Pricing: Not published. Blockdaemon's API pricing page lists compute-unit tiers (Free at 3M CU, Starter up to 65M, Growth up to 365M) without monthly prices, and lists the RPC API under custom solutions, so there is no effective price per 1M Arc calls to compare. Blockdaemon quotes per engagement through sales.

If your Arc integration sits inside a bank, a custodian or a regulated payments business, Blockdaemon's certification set and custody architecture are the point, and the absence of a pricing page is normal for that buyer. For everyone else, the lack of a self-serve tier and published rates makes it hard to evaluate against the providers above. There is no free tier to test with.

Best for: Regulated institutions that need node infrastructure and custody from a single vendor with a full certification package.

5. Pinax

Pinax appears in Arc's docs as a data indexer, but it also offers Arc RPC with archive support alongside Firehose and Substreams streaming.

Key features:

• Arc RPC with archive support
• Firehose streaming for blocks, transactions, logs and state changes
• Substreams for parallelized indexing
• WebSocket streaming
• Usage-based billing across all products

Pricing:

Firehose is the interesting piece for Arc. Streaming full block data including every log sidesteps the dual-emitter eth_getLogs problem entirely, because you process every Transfer event as it streams. At 172,800 blocks per day, that is roughly 5.2M blocks a month, or about $9 in block processing before egress. For plain RPC, Pinax bills $6.00 per 1M requests on full-archive nodes with no per-chain surcharge. Pro's $200 usage allowance for $49 covers about 33.3M calls, which is $1.47 per 1M and the lowest entry-plan rate in this comparison; past the allowance every call is $6.00 per 1M. WebSocket messages bill separately at $0.50 per 10K.

Best for: Teams building Arc analytics or indexing pipelines where streaming full block data beats querying it, especially for USDC transfer reconciliation.

6. Tenderly

Tenderly lists Arc mainnet and testnet with node RPC, development tooling, monitoring and Virtual TestNet support. The mainnet gateway at arc.gateway.tenderly.co (HTTPS and WSS) answered with Arc's chain ID on 2026-09-28.

Key features:

• Transaction simulation and execution traces
• Virtual TestNets forking Arc state
• Real-time alerting and monitoring
• Debugger with full call-stack inspection

Pricing: Sales-led. Tenderly Free has no API access, and Tenderly Console is quoted per contract, with no public dollar prices on 2026-09-28. Usage is measured in Tenderly Units, and the multipliers are steep:

Effective $/1M calls: not published, so Tenderly cannot be placed on the same scale as the other providers. At 400 TU per simulation, a monthly allocation disappears fast if you simulate in a loop. Budget Tenderly against your simulation count, not your request count, and get allocations from Tenderly sales.

Arc is the chain where simulation earns its cost, and the missing debug_* and trace_* namespaces are the reason. Native value transfers revert for causes that exist nowhere else: zero-address sends, precompile sends, blocklisted counterparties, sends to self-destructed accounts. With no on-chain trace to inspect after the fact, forking Arc state and simulating a payment flow before you deploy is the practical way to find out which rule you hit. Treat Tenderly as a simulation layer first; its Arc RPC has no published price to budget against.

Best for: Development and QA teams simulating Arc payment flows against the chain's value-transfer rules before production deployment.

7. QuickNode

QuickNode is a preferred infrastructure provider for Arc and has been publicly onboarding teams ahead of the mainnet launch.

Key features:

• Archive data on all paid plans
• Streams for push-based data delivery
• Webhooks, Key-Value Store and SQL Explorer
• SOC 2 Type II certified and ISO 27001
• SOC 1 Type 2 and DORA reports on Enterprise
• Crypto top-ups on paid plans

Pricing:

Annual billing cuts about 15% off Accelerate, Scale and Business, and brings Build to $34 per month. QuickNode charges a flat 20 credits for every Arc call, eth_getLogs included, so the credit totals on the pricing page overstate Arc request capacity 20 times. QuickNode Streams suit Arc well: push delivery beats polling at 0.5 second block times. The compliance package is the most complete of the self-serve providers, which matters if your Arc counterparties are regulated institutions.

Best for: Teams that need event-driven delivery through Streams plus formal compliance reports, and can model their credit consumption accurately.

8. Alchemy

Alchemy is an Arc partner listed in Circle's docs as both a node provider and a data indexer, which is a genuine advantage if you want RPC and indexed data from one vendor.

Key features:

• 100+ supported networks
• Archive nodes and WebSockets
• Data APIs for token balances, transfers and transaction history
• Webhooks for streaming Arc events
• Wallet APIs and gasless transaction orchestration
• Increased eth_getLogs ranges on Enterprise

Pricing:

Alchemy's Data APIs are the strongest argument here. Arc's dual-emitter Transfer events are exactly the problem a managed token-transfer API solves, and building that indexing yourself against raw eth_getLogs is real work. The trade-off is the compute-unit model: eth_getLogs costs 60 CU, or $31.50 per 1M log queries, and the log-heavy Arc mix averages 41.2 CU per call, or $21.63 per 1M calls. The Enterprise tier's increased eth_getLogs ranges are worth asking about if you are backfilling Arc history.

Best for: Teams that want Arc RPC and managed USDC transfer indexing from one platform, and would rather not hand-roll dual-emitter event tracking.

Provider Comparison

No Trace column appears here because Arc enables no trace namespace for anyone to sell. Tenderly remains the route to execution traces, via off-chain re-execution rather than an RPC method.

Effective Price per Million Calls

One denominator for every provider: dollars per 1M Arc calls under the log-heavy indexing mix, at the entry paid plan and at the best self-serve rate, with overage alongside.

Alchemy's 60 CU weight on eth_getLogs against a $0.525 per 1M CU rate is what puts it last. The headline rate is among the lowest in the table; the effective rate is the highest, and on Arc it lands on the method you call most.

On most chains the next comparison would be trace and debug weights, where Alchemy and QuickNode both charge 40 units a call and the spread widens considerably. Arc does not enable those namespaces, so those multipliers never fire. That cuts both ways: there is no trace bill to model, but there is also no cheaper method to shift diagnostic load onto when a payment reverts.

What That Costs at Volume

Plans step at fixed tiers, so monthly bills differ from the per-million rates. Same log-heavy Arc mix, list prices.

At 10M requests, Dwellir's $49 ties Pinax and Chainstack, and dRPC's free tier covers about 10.5M calls on public nodes. At 50M, Pinax is the lowest metered plan at $149 against Dwellir's $174, because Pro's included usage covers the first 33.3M calls; Dwellir's Unlimited Node is $119 if average traffic stays under 25 RPS and $479 for the 100 RPS tier. At 100M, Dwellir Growth at $299 is the lowest published price here; Pinax and Chainstack reach $449. An Arc indexing workload that costs a few hundred dollars a month on per-request billing runs into four figures on Alchemy's compute units, and the gap scales linearly with volume.

Choosing the Right Provider

Best for log-heavy indexing on recent state: Dwellir. The 1:1 model removes conversion risk on the chain where conversion risk is highest. Arc's dual-emitter Transfer events push your workload toward eth_getLogs, which Alchemy weights at 60 CU and QuickNode bills at 20 credits like every Arc call, and Dwellir serves logs and receipts back to genesis. At $1.96 per 1M calls on Developer, Dwellir's eth_getLogs rate is 16 times lower than Alchemy's, and Growth at $299 is the lowest published price here for 100M calls a month. Pinax Pro is lower at $1.47 per 1M within its included usage and $149 at 50M calls. The caveat is archive: the shared endpoint runs full nodes, so if you need historical state reads, Chainstack or Pinax combine archive with per-request billing.

Best for managed USDC indexing: Alchemy. If you would rather not build dual-emitter transfer tracking yourself, Alchemy's Data APIs and webhooks solve exactly that problem, and it is an Arc partner listed in Circle's own docs for both RPC and indexing. You pay for it in compute units, but you save engineering time.

Best for regulated deployments: Blockdaemon or QuickNode. If your Arc counterparties are the institutions validating the chain, certification packages become procurement requirements. Blockdaemon carries ISO 27001, SOC 1 Type 1 and SOC 2 Type II with MPC custody. QuickNode offers SOC 2 Type II and ISO 27001 self-serve, with SOC 1 Type 2 and DORA reports on Enterprise.

Best for development: dRPC, plus Tenderly for simulation. dRPC's 210M compute units at 100 RPS is the largest free allocation for Arc, and with no trace_* namespace on the chain, Tenderly's Virtual TestNets are the practical way to find out which value-transfer rule your contract violates before it costs you a settlement.

Getting Started

Arc mainnet is live as of today. Before you commit to a provider, run two checks with your own workload: measure eth_getLogs latency against the system emitter at 0xffffFFFfFFffffffffffffffFfFFFfffFFFfFFfE across a realistic block range, and confirm your provider returns the parent header's extra_data field intact so you can read the next block's base fee. Both are Arc-specific, and both are cheap to verify on a free tier today.

And set maxFeePerGas to at least 20 Gwei on every transaction you submit. The transaction you never hear about again is the one that went in below the floor.

Building on Arc? Create a Dwellir account and start querying Arc on the free tier today, or talk to the Dwellir team about throughput and archive requirements for stablecoin settlement workloads.

For comparisons on other networks, see Top Tempo RPC Providers and Best RPC Node Providers of 2026.