Arc JSON-RPC

Arc RPC that knows Arc is different.

Standard JSON-RPC for mainnet and testnet, served from our own execution and consensus nodes, plus the arc_ namespace documented down to its error codes. Sub-floor transactions are rejected with an error, and USDC never mixes 18 decimals with 6.

Get an API keyRead the docs

POSTrpc.arcrpc.com/v1/{API_KEY}

request

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "arc_getCertificate",
  "params": ["latest"]
}

responsefinal on commit

{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "height": 21285725,
    "round": 0,
    "block_hash": "0x6414...9a21",
    "signatures": [
      { "address": "0x1e70...e716", "signature": "Xp5u...BA==" },
      { "address": "0x8c2d...41a0", "signature": "q3Lk...wg==" },
      "... 12 in total"
    ]
  }
}
Two surfaces

Everything Ethereum, and everything only Arc needs.

Arc is Reth for execution and Malachite BFT for consensus. We serve the standard JSON-RPC surface as Reth actually answers it, and the methods that exist because Arc is different: the commit certificate, the two USDC interfaces, the blocklist. The same API key authenticates both, on the same URL.

Standard JSON-RPC

JSON-RPC / HTTPS + WSS

https://rpc.arcrpc.com/v1/{API_KEY}

The eth_* set plus the four debug tracers that return data on Reth, all nine trace methods and txpool inspection. If your tooling speaks Ethereum, it speaks this. Below the 20 Gwei floor, eth_sendRawTransaction answers with an error instead of letting the transaction vanish.

Live methods

eth_blockNumbereth_chainIdeth_calleth_estimateGaseth_gasPriceeth_feeHistoryeth_maxPriorityFeePerGaseth_getBalanceeth_getCodeeth_getStorageAteth_getProofeth_getAccounteth_getBlockByNumbereth_getBlockByHasheth_getBlockReceiptseth_getLogseth_getTransactionByHasheth_getTransactionReceipteth_getTransactionCounteth_sendRawTransactioneth_sendRawTransactionSynceth_simulateV1eth_createAccessListeth_subscribeeth_newFiltereth_newBlockFiltereth_getFilterChangesdebug_traceTransactiondebug_traceBlockByNumberdebug_traceBlockByHashdebug_traceCalldebug_getRawBlockdebug_getRawHeaderdebug_getRawReceiptsdebug_getRawTransactiontrace_blocktrace_transactiontrace_calltrace_callManytrace_filtertrace_gettrace_rawTransactiontrace_replayTransactiontrace_replayBlockTransactionstxpool_statustxpool_contenttxpool_contentFromtxpool_inspect

Method matrix

Arc-native methods

Same endpoint

https://rpc.arcrpc.com/v1/{API_KEY}

arc_getVersion and arc_getCertificate, which rpc_modules does not advertise, plus our own methods built on them: USDC balances in all three representations, settlement proofs by transaction hash, and a compliance pre-flight against live blocklist state.

Methods

arc_getVersionarc_getCertificatearcrpc_getUsdcBalancearcrpc_simulateTransferarcrpc_getSettlementProof

Arc namespace docs

Reference

The methods that matter on Arc, with receipts.

Every method below ships with an example round-trip. Expand a row for the exact request and response bodies. Every other method, and what it actually returns on Arc, lives in the method matrix.

Request

{ "jsonrpc": "2.0", "id": 1, "method": "eth_blockNumber", "params": [] }

Response

{ "jsonrpc": "2.0", "id": 1, "result": "0x4040c7" }

Note: 0x43c33c1937564800000 is 20000 USDC at 18 decimals. The ERC-20 balanceOf for the same account returns 20000000000 at 6.

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "eth_getBalance",  "params": ["0x7c4e09b1a3f9c2d14e7b58f0a1c6d23e9b0f44a1", "latest"]}

Response

{ "jsonrpc": "2.0", "id": 1, "result": "0x43c33c1937564800000" }

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "arcrpc_getUsdcBalance",  "params": ["0x7c4e09b1a3f9c2d14e7b58f0a1c6d23e9b0f44a1", "latest"]}

Response

{  "jsonrpc": "2.0",  "id": 1,  "result": {    "native18": "20000000000000000000000",    "erc20_6": "20000000000",    "display": "20000.00 USDC",    "truncated": false,    "blockNumber": 4210887  }}

Note: rpc_modules does not list the arc namespace. Do not feature-detect it that way. We accept "latest" as well as a height; several Arc providers accept a height only. The height is decimal in the response, and the node proxies the call to its consensus layer, so it answers -32004 for an unknown height and -32005 if consensus is unreachable.

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "arc_getCertificate",  "params": ["latest"]}

Response

{  "jsonrpc": "2.0",  "id": 1,  "result": {    "height": 21285725,    "round": 0,    "block_hash": "0x64143fbf272874679e66dbbd15aae3a184c5617a539c8d43a3407befa0039a21",    "signatures": [      { "address": "0x1e703581d2d645d2727208063bfb6f27dabfe716", "signature": "Xp5uGYyU...pmBA==" },      { "address": "0x...", "signature": "..." }    ]  }}

Request

{ "jsonrpc": "2.0", "id": 1, "method": "arc_getVersion", "params": [] }

Response

{  "jsonrpc": "2.0",  "id": 1,  "result": {    "git_version": "v0.8.0",    "git_short_hash": "4be1c2a",    "cargo_version": "0.8.0"  }}

Note: Block range limit scales with plan: 100k on Pro, 500k on Scale.

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "eth_getLogs",  "params": [{    "address": "0x3600000000000000000000000000000000000000",    "fromBlock": "0x4040c0",    "toBlock": "0x4040c7"  }]}

Response

{  "jsonrpc": "2.0",  "id": 1,  "result": [{    "address": "0x3600000000000000000000000000000000000000",    "blockNumber": "0x4040c7",    "logIndex": "0x7",    "topics": ["0xddf252ad...", "0x...7c4e09b1", "0x...2d91c3f0"],    "data": "0x...4a817c800"  }]}

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "debug_traceTransaction",  "params": ["0x9f2c...a41e", { "tracer": "callTracer" }]}

Response

{  "jsonrpc": "2.0",  "id": 1,  "result": {    "type": "CALL",    "from": "0x7c4e...09b1",    "to": "0x3600000000000000000000000000000000000000",    "gasUsed": "0xb3c1",    "output": "0x0000...0001"  }}

Request

{  "jsonrpc": "2.0",  "id": 1,  "method": "eth_sendRawTransaction",  "params": ["0x02f8b0..."]}

Response

{  "jsonrpc": "2.0",  "id": 1,  "error": {    "code": -32000,    "message": "maxFeePerGas 12 gwei is below the Arc base fee floor of 20 gwei; the network would drop this transaction without a receipt"  }}
Quickstart

First response in under five minutes.

No new client library. viem, ethers, web3.py and Foundry work as-is. Put the key in the URL and point them at the endpoint.

  1. Get an API key

    One key authenticates JSON-RPC on both networks, the transfer feed, settlement proofs and, on Scale, the gRPC streams.

  2. Point your client at the endpoint

    Mainnet at rpc.arcrpc.com/v1/{key}, testnet at rpc-testnet.arcrpc.com/v1/{key}, over HTTPS or WebSocket.

  3. Read, then broadcast

    eth_call and eth_getLogs for state; eth_sendRawTransaction when you are ready to write, with maxFeePerGas at or above 20 Gwei.

Timed from key creation to the first JSON-RPC response.

Method matrix 

# latest Arc blockcurl https://rpc.arcrpc.com/v1/YOUR_KEY \  -H 'content-type: application/json' \  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}' # USDC balance, all three representationscurl https://rpc.arcrpc.com/v1/YOUR_KEY \  -H 'content-type: application/json' \  -d '{"jsonrpc":"2.0","id":2,"method":"arcrpc_getUsdcBalance",       "params":["0x7c4e09b1a3f9c2d14e7b58f0a1c6d23e9b0f44a1","latest"]}'
The numbers that matter

Three numbers generic EVM gets wrong.

Native USDC decimals, the base fee floor and the block time. Each one is published by Arc, and each one breaks an integration that assumes Ethereum defaults. Latency figures go here when they are measured, not before.

0

Native USDC decimals, not 6

0 Gwei

Base fee floor, below it a tx vanishes

0.0 s

Block time, so archive starts a minute back

per docs.arc.io, as of 2026-09-16

One platform

The rest of the platform

Real-time streams

Every USDC movement, reconciled across both emitters, pushed as the block commits over gRPC, WebSocket or webhooks. The push counterpart to RPC's point reads.

Explore the streams

Settlement proofs

The commit certificate behind any transaction, cached and indexed by hash, with a verifier that runs offline. Finality you check, not finality you trust.

Explore proofs

Read the chain. Prove the settlement.

One API key covers JSON-RPC on both networks, the transfer feed and settlement proofs. Scale adds gRPC streaming and warehouse sinks.

Get an API keyRead the docs
FAQ

Common questions

An RPC and data provider built for Arc, Circle's Layer-1 for stablecoin settlement. One API key covers JSON-RPC on mainnet 5042 and testnet 5042002, the unified USDC transfer feed, settlement proofs, gRPC streams and warehouse sinks.

Get an API key and put it in the URL: https://rpc.arcrpc.com/v1/{API_KEY} for mainnet, rpc-testnet.arcrpc.com for testnet. Any EVM library works unchanged. For streams, point a gRPC client at grpc.arcrpc.com:443 and send the key as x-api-key metadata.

Standard JSON-RPC is served well by many Arc providers. The differences are in Arc's own behaviour. When we tested public mainnet endpoints in September 2026, providers disagreed on whether arc_getCertificate accepts "latest", several pruned old state, and only one served debug and trace alongside full history. None of the providers we surveyed de-duplicates the two USDC emitters with Memo and CCTP attached, and none serves commit certificates by transaction hash. That is the product.

No. Standard JSON-RPC stays standard. Change the URL and the key; your client keeps working. The Arc-native methods are additions, not replacements.

Arc keeps one USDC balance behind two interfaces. Native USDC, which eth_getBalance returns, has 18 decimals. The ERC-20 interface at 0x3600...0000 has 6. Mixing them is off by 10^12. arcrpc_getUsdcBalance returns both plus the display value so nobody has to remember which is which.

Arc drops any transaction whose maxFeePerGas is below the 20 Gwei base fee floor. It never enters a block, never produces a receipt and never returns an error. We reject it at the endpoint with a message that says so.

No, and no provider can. Arc disables pending-transaction visibility at the protocol level and returns -32001, and arc-node hides pending data by default. The upside is that nobody can watch or front-run your transaction before it lands.

No. Archive is on every plan and billed at the same rate as a call against the tip. At half-second blocks the usual 127-block archive boundary is about a minute old, so charging a multiplier would tax ordinary reconciliation.