Aurora Mainnet RPC for Wallet Builders

Aurora is an EVM that runs on the NEAR Protocol, with ETH as the gas token. Aurora's docs describe relayers that wrap each EVM transaction into a NEAR transaction, so the JSON-RPC surface looks like Ethereum while the chain underneath does not. Wallet builders still trip on four things: a chain ID too long to type from memory, a gas price that is fixed rather than market-driven, a transfer gas estimate above 21,000, and public URLs that answer eth_chainId but fail on real reads.

This is not a ranking of providers. Use the Aurora Mainnet hub to compare endpoints, then run the checks below on the URL you configure. The Aurora Mainnet providers page lists the keyed options side by side.

Chain ID 1313161554 is mainnet, 1313161555 is testnet

• Aurora mainnet: chain ID 1313161554, hex 0x4e454152. eth_chainId returned 0x4e454152 on every passing URL in every round of our probe, and net_version on mainnet.aurora.dev returned "1313161554". Aurora's network endpoints page lists the same chain ID.
• Aurora testnet: chain ID 1313161555 (0x4e454153), per the same docs page, with https://testnet.aurora.dev as its RPC.
• Ethereum mainnet: chain ID 1. ETH on Aurora is bridged ETH on a separate chain, so it needs its own network entry.

The hex form is easy to misread: 0x4e454152 spells "NEAR" in ASCII, and testnet ends in 53 instead of 52. Compare all ten digits of the decimal ID, not the first few.

Wallet-add fields for mainnet, matching Aurora's start page at aurora.dev/start:

• Network name: Aurora (or Aurora Mainnet)
• Chain ID: 1313161554 (or 0x4e454152 if the form wants hex)
• Currency symbol: ETH
• RPC URL: a JSON-RPC HTTPS endpoint you have already probed, such as https://mainnet.aurora.dev
• Block explorer: https://explorer.aurora.dev

Native gas is ETH with 18 decimals. AURORA is a governance token on the network, not the gas token, so do not put AURORA in the currency symbol field. Call eth_chainId on the exact RPC URL you will ship and expect 0x4e454152. A gateway that returns 0x4e454153 is testnet. A timeout, an HTML error page, an origin error, or a "method does not exist" body is not a working Aurora mainnet RPC.

Public endpoints that passed 8 of 8 rounds

We probed every Aurora mainnet URL on the hub 8 times, about 55 seconds apart, on 2026-10-19 between 02:16 and 02:24 UTC. Each round called eth_chainId, eth_getBalance and eth_blockNumber, with a curl User-Agent on every request. Hosts ran one after another, never in parallel, at no more than 2 requests per second. WebSocket rows got the same three calls over one connection per round. These five HTTPS URLs passed all three calls in 8 of 8 rounds, and the block number they returned moved forward in every round:

Some rows answered with caveats and stay listed:

• https://aurora.drpc.org returned 0x4e454152 in 8 of 8 rounds, but in 3 of 8 rounds eth_getBalance and eth_blockNumber came back as HTTP 400 with JSON-RPC -32601, "the method does not exist/is not available". wss://aurora.drpc.org did the same in 2 of 8 rounds. A wallet that treats -32601 as "unsupported method" will hide balances at random, so add a fallback before you rely on it.
• https://lb.routeme.sh/rpc/evm/1313161554 passed all three calls in 1 of 8 rounds. 18 of its 24 calls returned HTTP 429, JSON-RPC -32029 "public rate limit exceeded", and one timed out. Treat it as low-rate only.

Two rows failed every call in all 8 rounds, and the directory now hides them:

• https://endpoints.omniatech.io/v1/aurora/mainnet/public returned HTTP 521 (origin down) on all 24 calls.
• https://rpc.owlracle.info/aurora/70d38ce1826c4a60bb2a8e05a6c8b20f returned HTTP 401, "Origin mismatch", on all 24 calls. The key in the URL is locked to another site, so it does not work as a public endpoint.

A row on a directory page is a starting point, not proof it serves Aurora mainnet today.

Fees: a flat 0.07 gwei, and transfers estimate 28,000 gas

At about 02:26 UTC, on mainnet.aurora.dev, 1313161554.rpc.thirdweb.com and aurora-mainnet.gateway.tatum.io:

• eth_gasPrice returned 0x42c1d80 (70,000,000 wei, 0.07 gwei) on all three URLs.
• eth_estimateGas for a plain ETH transfer from a funded address to an ordinary address returned 0x6d60 (28,000) on all three, not the 21,000 an Ethereum wallet expects.
• On mainnet.aurora.dev, eth_maxPriorityFeePerGas also returned 0.07 gwei, the latest block carried no baseFeePerGas value, and eth_feeHistory reported a base fee of 0 and tips of 0.
• The same estimate from an address with no ETH returned error code 3, Ok(OutOfFund), instead of a gas number.
• The latest block reported a gas limit of 0x1fffffffffffff and a zero-address miner, so block gas fields say nothing useful about capacity.

We did not send a transfer, so we have no receipt and no measured gasUsed. An estimate is the gas limit a node recommends, not the gas a transfer uses, and Aurora's getting ETH page puts a coin transfer at about 0.0000015 ETH at this gas price. What that means for a wallet:

• Take the gas limit from eth_estimateGas. The nodes we asked returned 28,000 for a plain transfer. We did not test whether a fixed 21,000 limit goes through, so do not copy Ethereum's value into Aurora config.
• Do not build the fee from eth_feeHistory. With a base fee and tips of 0, EIP-1559 math from fee history gives a zero fee. Read eth_gasPrice, or let your wallet library fall back to it.
• Estimate from the real sender. An estimate from an empty address returns OutOfFund, not a number. Show "insufficient ETH for gas" rather than a generic failure.
• Do not show "0" for the fee. A fee of a few millionths of an ETH needs more precision than four decimal places.

Finality: safe and finalized match latest

During the check, timestamps across the last 10,000 blocks spanned 5,942 seconds, about 0.59 seconds per block. Over the 8 probe rounds, about 650 blocks went by in roughly seven minutes. The latest block's timestamp was 2 seconds older than our clock.

At about 02:25 UTC, on mainnet.aurora.dev, we read latest, then safe, then finalized, about 0.6 seconds apart:

• eth_getBlockByNumber("safe") returned a block 1 block ahead of the latest we had just read.
• eth_getBlockByNumber("finalized") returned a block 3 blocks ahead of it.

In other words, all three tags pointed at the chain head within the time it took to send the next request. For a wallet:

• latest is fine for balances on screen.
• Waiting for safe or finalized does not add minutes on Aurora the way it does on OP Stack chains, so do not copy an L2 confirmation timer.
• Still poll for the receipt rather than assuming inclusion from a returned hash.

Add Aurora to MetaMask or Rabby

These are the values we checked on 2026-10-19, not values copied from a list:

• eth_chainId returned 0x4e454152 (1313161554) on every passing URL in the table above.
• Aurora's docs list chain ID 1313161554 and https://mainnet.aurora.dev as the RPC, and aurora.dev/start lists ETH as the symbol and https://explorer.aurora.dev as the explorer. https://aurorascan.dev redirected to https://explorer.aurora.dev/ when we checked.

MetaMask: follow the MetaMask custom RPC guide. Check 'Additional networks' first. To add it by hand, open 'Networks', choose 'Add a custom network', and enter the five fields from the chain ID section with a URL from the passed table. MetaMask does not verify that a custom network is what it claims to be, so the probe is your check.

Rabby: follow the Rabby custom network guide. Check the network list before you add a custom entry. If you add it by hand, enter chain ID 1313161554 and an RPC URL that returned 0x4e454152 in your own probe.

Dapps: for wallet_addEthereumChain, send chainId: "0x4e454152", chainName: "Aurora", nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }, rpcUrls with your probed HTTPS endpoint, and blockExplorerUrls: ["https://explorer.aurora.dev"]. For wallet_switchEthereumChain, send only { chainId: "0x4e454152" }, and call wallet_addEthereumChain if MetaMask returns error 4902.

Wallet-add gotchas that show up in QA

1. A mistyped chain ID: 1313161554 and 1313161555 differ in the last digit. Paste it, then compare the hex 0x4e454152 against eth_chainId.
2. AURORA as the currency symbol: gas is paid in ETH. AURORA is a token, so show it as a token balance.
3. ETH symbol on several networks: Ethereum, Aurora and many L2s all show ETH. Show the network name next to the balance.
4. A hardcoded 21,000 gas limit: the plain transfer estimate was 28,000 on every URL we asked, so read the limit from eth_estimateGas instead of assuming the Ethereum value.
5. A zero fee from eth_feeHistory: it reported base fee 0 and tips 0 while eth_gasPrice returned 0.07 gwei.
6. Rows that answer eth_chainId but not reads: one gateway returned the right chain ID every round and -32601 on balance reads in some rounds. Probe the calls you actually make, not only the chain ID.

Public vs dedicated for wallet traffic

Public endpoints are fine for:

• Local development and wallet QA
• Low-volume eth_chainId and eth_blockNumber probes
• One-off scripts and docs examples

They are a poor primary path when you:

• Run production wallet RPC for many users (balance, nonce, fee estimate, send, receipt polls)
• Need wide eth_getLogs ranges or historical state
• Depend on WebSocket subscriptions
• Cannot absorb shared-node rate limits during a token launch or market spike

Probe the candidate URL before you call it ready:

1. eth_chainId returns 0x4e454152.
2. The latest block advances when you poll twice 2 seconds apart, and its timestamp is within a few seconds of wall-clock time.
3. A plain transfer eth_estimateGas from a funded address returns a number (28,000 in our check), not an error.
4. eth_getBalance on an address you care about returns a value, not a rate-limit or -32601 method error.
5. eth_gasPrice returns a non-zero value, and your fee code uses it when fee history reports zero.
6. A burst of 20 to 50 quick requests does not return HTTP 429 or a JSON-RPC rate-limit error at the volume you expect per client.

For production wallet traffic, compare the rows on the same hub for method coverage, archive access, and quota. The providers page lists the keyed options for Aurora mainnet.

A cheaper URL that fails the probe above is not a savings. The public vs paid guide covers when a shared endpoint stops being enough, and the pricing calculator estimates monthly cost for a given request mix. Log-heavy indexers should also read the eth_getLogs caps guide, and the dead public endpoints guide explains why listed URLs stop answering.

Practical split for a wallet stack

• User-facing Aurora network row: chain ID 1313161554 / 0x4e454152, ETH symbol with the network name shown, an explorer you opened, an RPC you probed today.
• Testnet row, if you need it: Aurora testnet, chain ID 1313161555, a separate config key, never reused as the mainnet RPC.
• Fee estimation: eth_estimateGas from the real sender plus eth_gasPrice, no fixed 21,000 limit, shown with enough precision.
• Confirmations: safe and finalized tracked latest in our check, so a short receipt poll is enough. Do not reuse an OP Stack wait.
• Backend / indexer: a dedicated or keyed endpoint with the eth_getLogs range and archive depth you need. Do not share the browser wallet's public URL.

Ship the hub comparison and the probe first. A network called "Aurora" in a dropdown does not replace eth_chainId returning 0x4e454152.