Top 8 Arc RPC Providers 2026: Pricing, Archive Access and Trace APIs 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 supplies simulation and debugging on top of an endpoint you bring yourself. Pricing is normalized so you can compare costs directly.

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. Diagnosing this in production takes txpool visibility or trace access. 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. Trace and debug APIs stop being a nice-to-have.

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.
• Trace and debug APIs. Arc's value-transfer rules mean reverts you have never seen on another chain. debug_traceTransaction is how you find out which rule you hit.
• 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 costs the same as an eth_getBalance costs the same as a debug_traceTransaction. Dwellir and Chainstack work this way, and dRPC's Growth plan bills flat per request too. The rate on the pricing page is the rate you pay per call.

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 million compute units and assigns 60 CU to eth_getLogs, which works out at $31.50 per million eth_getLogs. QuickNode charges roughly $0.50 per million credits at its highest self-serve tier and assigns 6 credits to eth_getLogs, or $3.00 per million.

Tenderly Units. A separate weighted system, covered in the Tenderly section below.

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 above all, because dual-emitter USDC tracking makes it the dominant method, with trace and debug close behind for diagnosing the value-transfer reverts Arc introduces.

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

Arc endpoint status. Dwellir's Arc endpoints go live shortly after Arc mainnet release. The pricing and features below are what Arc RPC ships with.

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

Key features:

• 140+ supported networks
• Archive nodes included on all plans
• WebSocket, Trace and Debug APIs on all paid plans
• European infrastructure
• Autoscaling with capped overage rates
• Unlimited Nodes for flat-rate, unmetered billing
• Crypto payment on the Scale tier

Pricing:

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

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 precisely the method carrying the steepest multipliers elsewhere. Archive access on every paid plan also removes the add-on cost that historical settlement queries usually trigger.

Best for: Teams running log-heavy Arc indexing or payment reconciliation where compute-unit multipliers would make the bill unpredictable.

2. 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, WebSockets and Debug API
• 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: log queries and traces consume far more CU than simple reads, so your effective cost per request depends heavily on your method mix. 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.

3. QuickNode

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

Key features:

• Archive data, Trace and Debug 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 roughly 15% off each tier. Credit multipliers apply by method: eth_getLogs costs 6 credits and trace_transaction costs 40, so headline credit counts overstate what a log-heavy or trace-heavy Arc workload actually gets. 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.

4. Chainstack

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

Key features:

• Full and Archive node modes
• Custom arc namespace plus txpool access
• Debug and trace on archive nodes
• 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:

That txpool namespace is more useful on Arc than the feature list suggests. When a transaction vanishes under the 20 Gwei floor, mempool inspection is how you confirm it was dropped rather than stuck. Chainstack bills request units 1:1 without method multipliers, though overage rates are the highest in this comparison, so size your plan to your actual volume.

Best for: Teams that want the arc and txpool namespaces self-serve, or need a specific deployment region for latency or data residency.

5. 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
• Debug and trace on Growth
• Front-running protection
• 99.99% uptime on paid tiers
• Crypto payments

Pricing:

The free tier is the most generous available for Arc development at 210M compute units and 100 RPS, though it routes to public nodes only, which rules out trace and debug work. Growth matches Dwellir's top self-serve throughput at 5,000 RPS. At $6 per million requests with no included allocation, per-request cost sits well above the volume tiers from Dwellir or QuickNode, so dRPC earns its place when you value multi-operator redundancy over unit price.

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

6. 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 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.

7. 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, traces 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 logs and traces 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. RPC at $6 per million puts it at the higher end for plain request serving.

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

8. Tenderly

Tenderly lists Arc Testnet with development tooling, monitoring and Virtual TestNet support. One important caveat: Tenderly's hosted node RPC is not currently enabled for Arc. You bring your own endpoint from another provider and use Tenderly for simulation and debugging on top.

Key features:

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

Pricing: Tenderly bills in Tenderly Units, and the multipliers are steep:

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 see Tenderly's pricing page for current tier allocations.

Arc is the chain where simulation earns its cost. Native value transfers revert for reasons that exist nowhere else: zero-address sends, precompile sends, blocklisted counterparties, sends to self-destructed accounts. Forking Arc state and simulating a payment flow before deploying catches those reverts in development rather than in a failed settlement. Treat Tenderly as a complement to an RPC provider on Arc.

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

Provider Comparison

Cost Per Million Requests

Converting every provider to dollars per million requests is the only way to compare them. The table below uses the cheapest plan each provider offers, so these are best-case rates, and benchmarks on eth_getLogs, the method Arc workloads lean on hardest. Weights are the providers' own published figures.

Alchemy's 60 CU weight on eth_getLogs against a $0.525 per million CU rate is what produces the 16x gap. The headline rate is among the lowest in the table. The effective rate is the highest by a wide margin, and on Arc it lands on the exact method you call most.

Trace and debug methods widen the gap further. Both Alchemy and QuickNode weight them at 40:

Arc makes this more than a theoretical concern. Native value transfers revert for reasons that exist nowhere else, so trace calls are how you diagnose production failures rather than an occasional debugging luxury.

What That Costs at Volume

Applying those eth_getLogs rates to three workload sizes:

These are per-call rates applied to volume. Real plans step at fixed tiers, so at 100M requests a month the realistic Dwellir plan is Growth at $299 with 150M included, and Chainstack's is Business at $499 with 200M included. The shape holds either way: an Arc indexing workload that costs a few hundred dollars a month on per-request billing runs into four figures on compute-unit billing, and the gap scales linearly with volume.

Dwellir's Unlimited Nodes sit below even the per-request rates when your traffic is steady. At 25 RPS for $119 a month, 65M requests works out at $1.83 per million with no overage line at all.

Choosing the Right Provider

Best all-round choice: 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 at 6 credits, while archive and trace on every paid plan cover the compliance queries and revert diagnosis Arc's value-transfer rules force on you. At $1.96 per million eth_getLogs, Dwellir is 1.25x cheaper than the next per-request provider and 16x cheaper than Alchemy on the same method.

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 Tenderly's Virtual TestNets let you fork Arc state and 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 so you are ready the day Arc endpoints go live, 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.