Soneium RPC: A Developer's Guide (Chain ID 1868, OP Stack)

Soneium RPC (chain ID 1868) is the JSON-RPC surface of an OP Stack layer 2 for onchain entertainment. The EVM is familiar; the confirmation model is not. In a 1,000-block sample on October 30, 2026, blocks arrived every 2.00 seconds, the base fee was 0.012 gwei, and the finalized tag trailed the head by 710 blocks, or roughly 24 minutes.

This guide covers the endpoint, fees and the separate L1 data fee, finality, logs, archive reads, block receipts, tracing and the WebSocket path that the official public endpoint does not currently provide.

The Soneium RPC endpoint

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

The proxy slug is soneium. The chain ID is 1868 (0x74c), ETH is the gas token with 18 decimals, and the public explorer is soneium.blockscout.com. The official HTTP endpoint is https://rpc.soneium.org; the network information page lists the mainnet and Minato testnet settings.

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

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

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

curl -sS https://rpc.swiftnodes.io/rpc/soneium?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":"0x74c"}

Soneium is the Sony-affiliated L2 whose documentation frames the network as an onchain entertainment economy. The technical details matter more than the branding: it is an OP Stack L2, so the fee model and finality assumptions follow the OP Stack rather than an independent L1.

What we measured

The measurements were made on October 30, 2026 against the official rpc.soneium.org endpoint, with spot checks through the SwiftNodes soneium route. The block sample covered 1,000 consecutive blocks from 30,102,505 to 30,103,504, running from 2026-10-30T05:56:01Z to 2026-10-30T06:29:19Z.

The constant 2-second cadence is useful for a game or consumer app: a transaction submitted now should be included in a block within a few seconds, unlike a chain that only produces blocks when activity appears. It is not a promise about the sequencer or the finality tag.

Fees: L2 and L1 are separate

The base fee stayed at 12,000,000 wei for the entire sample. eth_gasPrice returned 13,000,000 wei, and eth_maxPriorityFeePerGas returned 1,000,000 wei. A 21,000-gas transfer therefore costs 0.000000273 ETH in L2 execution at that gas price, before the L1 data fee.

The L1 fee is the part that is easy to miss. Soneium's fee documentation describes every transaction as an L2 execution fee plus an L1 security fee. We read a real user transaction in block 30,103,519:

That L1 fee is small because Ethereum gas and the transaction's calldata were favorable at that moment. It is not fixed. Budget both fields, and read l1Fee from the receipt instead of estimating the L1 component from the L2 gas price.

The receipt also carries OP Stack fields such as l1GasUsed, l1GasPrice, l1BaseFeeScalar and l1BlobBaseFeeScalar. Treat the total paid as the L2 gas cost plus l1Fee; do not add a second synthetic data-fee estimate on top.

Finality: do not use latest for irreversible actions

In the snapshot, latest was block 30,103,512, while safe and finalized were both block 30,102,802. The gap was 710 blocks. At 2.00 seconds per block that is 1,420 seconds, or 23 minutes 40 seconds.

const finalized = await client.getBlock({ blockTag: "finalized" });
const receipt = await client.getTransactionReceipt({ hash });
if (receipt.blockNumber <= finalized.number) {
  // safe to treat the result as final for this application
}

For a game or consumer transaction, showing the receipt quickly is reasonable. Releasing an irreversible asset should wait for finalized, or for a product-specific risk policy that is stricter than latest. The exact lag is not constant; it follows the L2's sequencing and Ethereum's finality.

Logs: 1,000 blocks on the public endpoint

eth_getLogs worked over 100 and 1,000 blocks. A 10,000-block request failed with:

block range greater than 1000 max

The official public endpoint therefore caps the block range at 1,000. The SwiftNodes free tier is narrower: 100 blocks per request. A paid key can use the upstream's 1,000-block range.

const MAX_RANGE = 100n; // SwiftNodes free tier
for (let from = start; from <= end; from += MAX_RANGE) {
  const to = from + MAX_RANGE - 1n > end ? end : from + MAX_RANGE - 1n;
  const logs = await client.request({
    method: "eth_getLogs",
    params: [{ fromBlock: `0x${from.toString(16)}`, toBlock: `0x${to.toString(16)}` }],
  });
  // persist blockNumber and logIndex before advancing
}

eth_getBlockReceipts is available and returns the block's receipts, including the OP Stack L1 fields. That is useful for a block-level indexer, but keep a transaction-hash and log-index cursor so retries are idempotent.

Archive state and tracing

The official endpoint returned historical state for an active address at 5,000,000 blocks back. That is evidence that archive state is reachable there, not a guarantee that every provider keeps the same depth. Pin the block in an indexer backfill and test the exact depth you need.

Tracing is the weak point on the public endpoint. debug_traceTransaction and trace_block both returned:

rpc method is not whitelisted

Do not assume a public Soneium endpoint will serve traces. Use a provider that explicitly supports debug_* or trace_*, and test the method against the chain rather than the provider's general EVM claim.

WebSocket: SwiftNodes has it, the public endpoint does not

Soneium's network-information page says WebSocket is not yet available, and wss://rpc.soneium.org returned HTTP 405 in our test. The SwiftNodes route is different:

const ws = new WebSocket("wss://rpc.swiftnodes.io/ws/soneium?key=YOUR_API_KEY");
ws.onopen = () => ws.send(JSON.stringify({
  jsonrpc: "2.0", id: 1, method: "eth_subscribe", params: ["newHeads"],
}));
ws.onmessage = (event) => {
  const message = JSON.parse(event.data);
  if (message.method === "eth_subscription") {
    // persist the head; blocks arrive every ~2 seconds
  }
};

The subscription was accepted and delivered a newHeads notification in our test. Treat the WebSocket as a low-latency notification path, not as a durable queue: reconnect, read the last stored block number, and backfill with eth_getLogs in 100-block chunks on the free tier or 1,000-block chunks on a paid plan.

Soneium-specific gotchas

ETH is the gas token. Soneium is an L2, but users still need ETH for gas and for the L1 data fee. A game that sponsors transactions must fund the account or use an account-abstraction paymaster; the token used inside the game is not automatically the gas token.

Budget the L1 fee separately. A cheap L2 execution estimate can still be wrong if Ethereum calldata costs rise. Read l1Fee from the receipt and keep the L2 and L1 components visible in your accounting.

Use finalized for settlement. The finalized tag was about 24 minutes behind latest in our snapshot. A receipt is inclusion; it is not the same as finality.

Do not query a 10,000-block log range. The public endpoint rejects anything above 1,000 blocks. The free SwiftNodes tier rejects anything above 100.

The official public endpoint does not expose tracing or WebSocket. Use a provider that does, and verify the method on Soneium rather than assuming it works because it works on Ethereum.

Production checklist

• Use https://rpc.swiftnodes.io/rpc/soneium?key=YOUR_API_KEY for HTTP and wss://rpc.swiftnodes.io/ws/soneium?key=YOUR_API_KEY for WebSocket.
• Confirm chain ID 1868 before signing; do not trust a cached network label.
• Read the latest base fee and set maxFeePerGas above it; the observed priority was 0.001 gwei.
• Budget L2 gas and l1Fee; do not treat the L2 estimate as the total.
• Chunk eth_getLogs at 100 blocks on the free tier, 1,000 on a paid plan.
• Wait for finalized before an irreversible asset release.
• Test debug_traceTransaction against a provider that explicitly enables tracing.
• For WebSocket, reconnect with a last-block cursor and backfill the gap.

FAQ

What is the Soneium chain ID?

1868 (0x74c). Soneium is an OP Stack layer 2 that settles to Ethereum, and ETH is the native gas token with 18 decimals.

What is the Soneium RPC endpoint?

https://rpc.swiftnodes.io/rpc/soneium?key=YOUR_API_KEY for HTTP and wss://rpc.swiftnodes.io/ws/soneium?key=YOUR_API_KEY for WebSocket. The official public HTTP endpoint is https://rpc.soneium.org; the proxy slug is soneium.

What is the Soneium block time?

A 1,000-block sample on October 30, 2026 had exactly 2.00-second blocks, from block 30,102,505 to 30,103,504. The cadence was constant in that sample, not demand-driven.

What is the Soneium base fee?

Every sampled block carried a 12,000,000 wei base fee, or 0.012 gwei. eth_gasPrice returned 0.013 gwei and eth_maxPriorityFeePerGas returned 1,000,000 wei (0.001 gwei).

Does Soneium have an L1 data fee?

Yes. Soneium is an OP Stack L2, so a transaction has an L2 execution fee and a separate L1 data fee. In one sampled user transaction the L2 fee was 0.0000020674181 ETH and l1Fee was 0.000000036111602067 ETH; the L1 portion changes with Ethereum gas and calldata.

What is the eth_getLogs block range limit?

The official public endpoint accepts at most 1,000 blocks per request. A 10,000-block request returned block range greater than 1000 max. The SwiftNodes free tier allows 100 blocks; use a paid key for wider ranges.

How long does Soneium finality take?

In our snapshot latest was block 30,103,512 while safe and finalized were both 30,102,802. The finalized tag lagged the head by 710 blocks, or about 23 minutes 40 seconds at 2.00-second blocks.

Does the official Soneium endpoint support WebSocket?

The official docs list WebSocket as not yet available, and wss://rpc.soneium.org returned HTTP 405. SwiftNodes accepts eth_subscribe over wss://rpc.swiftnodes.io/ws/soneium and delivered newHeads in our test.

Soneium's execution layer is ordinary EVM; the fees and finality are OP Stack. Measure both rather than copying an Ethereum or generic L2 configuration.

The Soneium endpoint and measured method support are on the Soneium RPC page. For request budgets, see the rate-limit guide; for log queries and fee history, see eth_getLogs and eth_feeHistory. Start free with 250,000 requests a month if you want to test this against your own app.