World Chain RPC: A Developer's Guide (Chain ID 480, OP Stack)

World Chain RPC (chain ID 480) is the JSON-RPC surface of a human-first OP Stack L2. The EVM is ordinary; the live chain parameters are not. We measured 2.00-second blocks, a 280,000,000 gas limit, a 500,000 wei base fee, a 100-block eth_getLogs cap on the public endpoints, and a finalized tag 663 blocks behind latest. The human-first features — priority blockspace and a gas allowance for verified humans — sit above the EVM, not inside the JSON-RPC fields.

This guide covers the endpoint, fees, finality, logs, archive depth, diagnostics and the places where World Chain differs from a generic OP Stack copy.

The World Chain RPC endpoint

https://rpc.swiftnodes.io/rpc/worldchain?key=YOUR_API_KEY
wss://rpc.swiftnodes.io/ws/worldchain?key=YOUR_API_KEY

The proxy slug is worldchain. The chain ID is 480 (0x1e0), gas is ETH with 18 decimals, and the explorer is worldscan.org. The official public RPC is https://worldchain-mainnet.g.alchemy.com/public; the official network-information page is here.

import { createPublicClient, defineChain, http } from "viem";

const worldchain = defineChain({
  id: 480,
  name: "World Chain",
  nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 },
  rpcUrls: {
    default: { http: ["https://rpc.swiftnodes.io/rpc/worldchain?key=YOUR_API_KEY"] },
  },
});

const client = createPublicClient({ chain: worldchain, transport: http() });
const chainId = await client.getChainId(); // 480

curl -sS https://rpc.swiftnodes.io/rpc/worldchain?key=YOUR_API_KEY \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# {"jsonrpc":"2.0","id":1,"result":"0x1e0"}

World Chain is part of the Superchain and uses the OP Stack; the EVM-equivalence page lists the OP Stack parameters. Gas is ETH, not WLD. WLD is the Worldcoin token used elsewhere in the ecosystem; a wallet still needs ETH for L2 execution and the L1 data fee.

What we measured

Calls were made on October 27, 2026 through the SwiftNodes endpoint, the official Alchemy public endpoint, and dRPC. The block sample covers 100 consecutive blocks ending at 36,874,659.

The live gas limit is 280M, and the docs disagree

The block header returned gasLimit: "0x10b07600", which is 280,000,000 gas. The official Alchemy endpoint returned the same value. The network-information page lists 80,000,000, and the EVM-equivalence page lists 30,000,000.

This is not a rounding difference. A transaction that budgets against 30M or 80M is planning for a limit the live chain does not currently use. Read eth_getBlockByNumber("latest") and use its gasLimit at runtime. If you need a stable planning number, read several recent blocks and take the minimum.

The sample blocks used about 1.09% of the live limit. The chain was producing an average of 11.99 transactions per block, with no empty blocks in the 100-block window. The gas limit is not the thing limiting activity at the moment.

Human-first features sit above the EVM

World Chain's unique-features documentation describes Priority Blockspace for Humans (PBH) and a gas allowance for verified humans. PBH is designed to reserve part of the block for transactions from World ID-verified humans, so ordinary users are not competing with bots for every inclusion slot. The gas allowance is described as a stipend funded initially by the World Foundation.

Those are protocol and wallet-level features, not extra JSON-RPC methods. A standard eth_estimateGas or eth_sendRawTransaction call has no human-status field. We measured a normal base fee and a normal gas price on the public RPC. Do not write code that assumes a verified user's transaction is free or automatically prioritized at the RPC layer. If you are building a World App mini app, use the World ID and MiniKit path for the human flow, and keep a normal ETH balance path for the transaction itself.

The overview is the right starting point for the product primitives. This guide stays on the RPC surface.

Blocks are 2.00 seconds; finality is batched

Every adjacent pair in the 100-block sample was exactly 2 seconds apart. The minimum and maximum were both 2. There were no repeated timestamps and no empty blocks.

Finality is not instant. In one snapshot:

The pending tag was one block ahead of latest. Across 16 blocks — 32 seconds at the measured block time — the safe and finalized heights did not move while latest advanced. OP Stack finality updates in batches, so do not expect the tags to advance on every block.

Use finalized as the hard-finality anchor for withdrawals, accounting and irreversible side effects. Use latest for reads that can tolerate a reorg. If you are indexing, the general rules are in how old the finalized tag is across 62 chains and how to handle chain reorgs.

Fees: a tiny base fee plus a separate L1 charge

The base fee was 500,000 wei (0.0005 gwei) in every sampled block. eth_gasPrice returned 1,500,000 wei (0.0015 gwei), and eth_maxPriorityFeePerGas returned 1,000,000 wei (0.001 gwei). eth_feeHistory returned the same 500,000 wei base fee and a 1,000,000 wei reward at all three percentiles.

A sampled plain ETH transfer used 21,000 L2 gas at an effective gas price of 1,500,000 wei. The L2 cost was:

21,000 × 1,500,000 wei = 31,500,000,000 wei
                       = 0.0000000315 ETH

The receipt also carried l1Fee: 0x2c68370e (745,027,342 wei), making the total:

31,500,000,000 + 745,027,342 = 32,245,027,342 wei
                              = 0.000000032245 ETH

The L1 fee was about 2.3% of that transfer's total. The World Chain fees page notes that the L1 fee can be higher than the L2 fee; in this sample it was not. The ratio depends on the transaction's calldata and the L1 gas price at the time. Read the receipt fields l1Fee, l1GasPrice and l1GasUsed instead of assuming a fixed split.

eth_estimateGas returned 24,338 for a plain transfer from an empty address, while the sampled transfer used 21,000. The estimate includes headroom; budget the estimate, not the 21,000 floor. For contract calls, estimate against the real sender and calldata.

Public endpoints are core-EVM-only

The public Alchemy endpoint rejected several methods with HTTP 401 and the error:

Only core evm requests are allowed.

On the public Alchemy endpoint that included eth_getBlockReceipts, debug_traceTransaction, trace_transaction, txpool_status, optimism_syncStatus, optimism_rollupConfig and optimism_outputAtBlock. Through the SwiftNodes route, eth_getBlockReceipts reached the same upstream restriction and optimism_rollupConfig returned method is not available.

What still works:

• eth_getTransactionReceipt for each transaction.
• eth_getLogs with a block hash or a range.
• eth_getProof at a pinned historical block. A latest proof can race the chain and return no state found for block number ...; pin the block number.
• eth_getBlockByNumber, eth_getBlockByHash and the standard read methods.

If you need block-level receipts, traces or OP Stack admin data, test the exact method on your paid provider. Do not assume every OP Stack chain exposes the optimism_* namespace through its public RPC.

Logs: 100 blocks on the public endpoints

The free SwiftNodes tier allows 100 blocks per eth_getLogs request. A 1,000-block attempt returned:

The free plan allows eth_getLogs over at most 100 blocks per request (this one spans 1000).

The response points at Starter at $49/month for larger ranges.

The public Alchemy endpoint has the same 100-block span limit and returns this cap message:

You can make eth_getLogs requests with up to a 100 block range.

The dRPC free endpoint at https://worldchain.drpc.org accepted 100 blocks and rejected 1,000 with:

{"code": 35, "message": "ranges over 10000 blocks are not supported on free plan"}

That error text is misleading: the request spanned 1,000 blocks, not 10,000. Treat the public endpoint caps as provider-specific and start at 100. The blockHash form worked on both SwiftNodes and Alchemy.

const CHUNK = 100n;
for (let from = start; from <= latest; from += CHUNK) {
  const to = from + CHUNK - 1n > latest ? latest : from + CHUNK - 1n;
  const logs = await client.getLogs({ address, fromBlock: from, toBlock: to });
}

For the wider pattern, see how eth_getLogs range caps bite.

Archive and proofs

Block 1 state was available on both the SwiftNodes route and the Alchemy public endpoint. eth_getBalance for 0x000000000000000000000000000000000000dEaD returned 0x0, and eth_getCode for 0x0000000000000000000000000000000000000001 returned 0x. Balances at 1,000,000 and 10,000,000 blocks back also answered.

That is better than a pruned full node, but it is not a capacity guarantee. Historical reads belong on an archive route when you are backfilling at volume, and they should be pinned to a block number. eth_getProof works at a pinned block; we used a block 10 behind the head and got the account proof and storage proof.

For the general decision, see full node vs archive node.

WebSocket and Multicall3

One eth_subscribe call with ["newHeads"] delivered a header in 686 ms:

wss://rpc.swiftnodes.io/ws/worldchain?key=YOUR_API_KEY

At a 2-second block time, a WebSocket subscription is a reasonable default for bots and indexers. Keep a polling fallback for reconnect gaps. The chain produces blocks continuously; you will not get long idle windows.

Multicall3 is deployed at the canonical address 0xcA11bde05977b3631167028862bE2a173976CA11. eth_call to 0x42cbb15c returned the latest block number, so batch reads work. Batch the same block number across calls when you need a consistent snapshot; the Multicall3 cheat sheet has the call shapes.

A production checklist

• Read gasLimit from the latest block; the published 30M and 80M figures did not match the live 280M.
• Use ETH for gas. A World ID verification is not an ETH balance.
• Budget eth_estimateGas, not 21,000. A plain transfer estimated at 24,338 gas.
• Add the receipt's l1Fee to the L2 cost. L1 and L2 are separate charges.
• Use finalized for irreversible actions; safe trailed by about 5 minutes and finalized by about 22 minutes in our snapshot.
• Chunk eth_getLogs at 100 blocks on the public endpoints. Do not trust a provider's error text to describe its real cap.
• Use per-transaction receipts; eth_getBlockReceipts is blocked on the public Alchemy endpoint and through the same upstream route.
• Pin eth_getProof and historical state reads to a block; archive data is present, but capacity is not guaranteed.
• Treat optimism_*, debug_*, trace_* and txpool_* as unavailable on the public endpoint until your provider proves otherwise.
• Do not assume PBH or the human gas allowance changes the result of eth_estimateGas or eth_getBalance.

FAQ

What is the World Chain ID?

480 (0x1e0). Gas is ETH with 18 decimals; WLD is not the gas token.

What is the World Chain RPC endpoint?

https://rpc.swiftnodes.io/rpc/worldchain?key=YOUR_API_KEY for HTTP and wss://rpc.swiftnodes.io/ws/worldchain?key=YOUR_API_KEY for WebSocket. The official public endpoint is https://worldchain-mainnet.g.alchemy.com/public.

Why is the live gas limit different from the docs?

The network-information page says 80M and the EVM-equivalence page says 30M; the live block header returned 280M on both endpoints. Read the block header.

Why does eth_getBlockReceipts fail?

The public endpoint returns 401 Only core evm requests are allowed. Use eth_getTransactionReceipt per transaction.

How long does finality take?

Safe trailed latest by 159 blocks (318 seconds) and finalized by 663 blocks (1,326 seconds) in our snapshot at 2.00-second blocks.

What is the eth_getLogs limit?

100 blocks on the public Alchemy endpoint and on the SwiftNodes free tier. dRPC's free endpoint also rejected 1,000 blocks, with a misleading 10,000-block error.

Is World Chain gas free for verified humans?

World Chain's docs describe PBH and a gas allowance for verified humans, but the public RPC still quotes and charges gas. The human path is a World ID/MiniKit/wallet flow, not a field in the standard EVM calls.

Summary

• World Chain is an OP Stack L2 with chain ID 480 and 2.00-second blocks.
• The live gas limit was 280,000,000, not the 30M or 80M figures on two documentation pages.
• The base fee was 0.0005 gwei; a sampled 21,000-gas transfer cost 0.0000000322 ETH including the L1 fee.
• Safe trailed by about 5 minutes and finalized by about 22 minutes; use finalized for hard finality.
• The public endpoints cap eth_getLogs at 100 blocks and reject block receipts, traces, txpool and optimism_* methods.
• Archive state at block 1 works on both tested endpoints; pin historical reads and use archive routing for volume.
• PBH and the human gas allowance are protocol and wallet features, not extra JSON-RPC fields.

World Chain endpoints, method support and chain details are on our World Chain RPC page. Start free with 250,000 requests per month; no card required.