Arbitrum vs Optimism RPC: which L2 for production

A practical comparison of Ethereum’s two largest optimistic rollup ecosystems, covering architecture, transaction flow, performance, RPC infrastructure, and developer tooling for teams deploying production applications at scale.

TL;DR

A production application on Ethereum scaling infrastructure is rarely limited by smart contract design or backend architecture. These layers have become increasingly standardized. The more consequential choices are structural, and they get locked in early — including which L2 to build on.

This is where the choice between Arbitrum and Optimism becomes important to understand. Both are mature optimistic rollups and fully EVM-compatible, but differences in their infrastructure, sequencing, fees, and tooling decide where early meaningful usage is most likely to emerge.

The real difference extends beyond the protocol. It shows up in how each ecosystem channels early adoption, how liquidity concentrates, and how applications scale. Over time, these “small” infrastructure decisions compound — shaping your app’s growth and user adoption.

Prerequisite

• Basic understanding of Ethereum
• No prior experience with Layer 2s required

What is an L2?

Rollups are Layer 2 scaling solutions that increase the transactions per second (TPS) on Ethereum without proportionally increasing gas costs. Rather than executing all transactions directly on Ethereum mainnet, Layer 2 networks process transactions off-chain, bundle them into batches, and periodically publish transaction data and state commitments back to Ethereum.

There are two types of rollup:

• Optimistic rollups: assume transactions are valid by default unless challenged with a fraud proof
• Zero-knowledge rollups: prove correctness upfront using cryptographic validity proofs. Learn more about zkEVM and zkRollups

All users on L2s pay a single gas fee that is composed of:

• L2 execution cost: for compute, storage, and EVM gas. It is much cheaper than L1 because it is not being executed by every Ethereum validator
• L1 data cost: for posting transaction data and state roots to Ethereum
• Sequencer fee

When Ethereum gas prices increase, overall L2 fees increase as well. Upgrades like Fusaka help offset these costs by increasing blob capacity and reducing the cost of posting data to Ethereum.

📖 The Ethereum Fusaka upgrade bundles multiple EIPs to improve rollup scalability by increasing blob capacity and improving data availability. For a deeper breakdown, explore the Ethereum Fusaka Upgrade article.

This is what makes Ethereum scalable without giving up security. Layer 2s focus on increasing TPS, while Ethereum Layer 1 focuses on security and data availability.

Arbitrum vs Optimism

Arbitrum and Optimism are among the largest Layer 2 ecosystems today, both built using optimistic rollup technology.

Network metrics

Optimism is built on one of the largest growing ecosystems of chains through the Superchain, providing shared standards and interoperability from day one, while inheriting Ethereum’s security and liquidity alongside operational flexibility.

Arbitrum provides a custom execution layer for the programmable economy, enabling scalable Ethereum apps with lower costs, faster settlement, and flexible onchain design space through Orbit.

Arbitrum One has processed over 2.7 billion transactions, while Optimism has processed 1.2 billion transactions since its inception.

As of June 22, 2026, Optimism leads in cumulative unique addresses with approximately 406.5 million distinct addresses, while Arbitrum has approximately 84.9 million distinct addresses.

While revenue is competitive between the two networks, Arbitrum leads in cumulative revenue with approximately $139.1 million generated over time, compared to approximately $117.7 million for Optimism.

Both networks are L2Beat Stage 1, meaning fraud proofs are permissionless and third parties can challenge invalid state roots without team permission.

Although both platforms use optimistic rollups, they each offer distinct features catering to various needs within the Ethereum ecosystem.

Architecture

🤔 Already familiar with both? Jump straight to the Which is the better L2? section below to choose the right one for your production app.

Optimism is built around a simple principle: stay as close to Ethereum as possible.

• OP Stack nodes: a modular set of services. op-reth handles EVM execution, op-node reconstructs L2 state from Ethereum data, op-batcher handles data availability by posting transaction batches to L1 (or alternative DA), and op-proposer submits L2 state roots to L1
• Modular architecture: execution, sequencing, data availability, and proving are separated into independent components
• Superchain vision: multiple OP Stack chains share standards, infrastructure, and interoperability guarantees

The result is a rollup ecosystem optimized for Ethereum compatibility, shared standards, and long-term interoperability.

For a more modular, flexible architecture, op-geth is deprecated. op-reth, purpose-built for the OP Stack, provides faster sync times, lower hardware and memory costs, and higher transaction throughput (TPS) without the garbage-collection overhead of Go.

Arbitrum prioritizes efficient verification on Ethereum.

• Nitro node (arb-node): a single integrated node that handles execution, sequencing feed processing, L2 state management, and RPC interfaces
• Validators: monitor state transitions and can challenge invalid execution through fraud proofs
• Sequencer: orders transactions and produces L2 blocks before settlement on Ethereum
• Interactive fraud proofs: disputes are narrowed down to a single instruction before Ethereum verifies the result
• WASM-based proving: Nitro compiles the state transition function into WebAssembly for efficient verification
• Orbit ecosystem: developers can launch custom L2s and L3s while inheriting Arbitrum’s settlement and fraud-proof infrastructure

The result is a rollup ecosystem optimized for verification efficiency, scalability, and customization.

Transaction lifecycle

Production apps require dependable RPC infrastructure. A dedicated provider such as Chainstack gives developers consistent transaction submission, lower latency, and better observability than public endpoints, making it easier to track transactions throughout their lifecycle on both Arbitrum and Optimism.

OP Mainnet

• User submits to op-reth via JSON-RPC → sequencer picks up and orders
• L2 block created (soft finality, ~2 seconds)
• op-batcher posts L2 transaction data to Ethereum Batch Inbox
• op-proposer posts state root to OptimismPortal
• 7-day Cannon fault proof window
• Ethereum-finalized state → hard finality

Arbitrum One

• User submits via sequencer RPC → sequencer orders and executes the transaction
• eth_sendRawTransaction returns only after the block is created (soft finality, ~1–2 seconds)
• Sequencer batches and compresses transactions → posts to Ethereum
• 7-day BOLD challenge window
• Ethereum-finalized state → hard finality

Both networks deliver sub-2-second soft confirmation and 7-day withdrawal periods. For most application logic, soft confirmation is sufficient. For withdrawal and bridge flows, the 7-day window is the binding constraint on both chains.

Transaction fees

For many users, transaction fees are one of the most important metrics when choosing a Layer 2.

Optimism has prioritized simplicity through a single-round fault-proof architecture. In the rare event of a dispute, this can result in higher L1 verification costs because more computation is settled directly on the base layer.

Arbitrum’s multi-round interactive dispute protocol narrows disagreements step-by-step, requiring less computation to be executed on Ethereum. This approach helps keep verification costs low and contributes to Arbitrum’s long-term gas efficiency.

That said, the introduction of EIP-4844 has reduced data availability costs for both networks, bringing transaction fees much closer together than in previous years. For everyday activities such as token transfers, swaps, and DeFi interactions, users will find both networks inexpensive to use.

Fees are no longer the primary differentiator between the two chains. Ecosystem depth, liquidity, and infrastructure tooling are the relevant decision factors.

RPC infrastructure

Arbitrum and Optimism both expose Ethereum-compatible JSON-RPC interfaces, which means applications interact with them in the same way as Ethereum L1.

Arbitrum

Arbitrum exposes a fully Ethereum-compatible JSON-RPC interface. Under the hood, Nitro integrates execution, state management, sequencing, and JSON-RPC into a single node implementation. Production RPC through Chainstack provides access to Arbitrum One with JSON-RPC methods, WebSocket connectivity, archive infrastructure, and Stylus tracing. Arbitrum RPC is available on both Mainnet and Sepolia.

Chain ID: 42161

Mainnet: https://arbitrum-mainnet.core.chainstack.com

Testnet: https://arbitrum-sepolia.core.chainstack.com

Since Arbitrum exposes the standard Ethereum JSON-RPC interface, common methods work exactly as they do on Ethereum. For example, you can retrieve the latest block number using eth_blockNumber:

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify(
  {jsonrpc: '2.0', method: 'eth_blockNumber', id: 1}
  )
};

fetch('https://arbitrum-sepolia.core.chainstack.com/<KEY>', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

Production applications often rely on WebSocket connections for real-time updates such as new blocks, pending transactions, and contract events. Chainstack provides dedicated WebSocket endpoints for Arbitrum:

wss://arbitrum-mainnet.core.chainstack.com

⚠️ The public Arbitrum RPC URLs do not support WebSocket connections. If your application requires subscriptions such as eth_subscribe or real-time event streaming, consider using a dedicated provider such as Chainstack.

The following example subscribes to newly produced blocks using eth_subscribe:

const WebSocket = require('ws');

const webSocket = new WebSocket('wss://arbitrum-mainnet.core.chainstack.com/<KEY>');

async function subscribeToNewBlocks() {

  const request = {
    id: 1,
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['newHeads'],
  };

  const onOpen = (event) => {
    webSocket.send(JSON.stringify(request));
  };

  const onMessage = (event) => {
    const response = JSON.parse(event.data);
    console.log(response);
  };

  try {
    webSocket.addEventListener('open', onOpen);
    webSocket.addEventListener('message', onMessage);
  } catch (error) {
    console.error(error);
  }
}

subscribeToNewBlocks();

Archive-enabled infrastructure also supports advanced debugging (use debug_* for post-Nitro blocks) and tracing (arbtrace_* for pre-Nitro blocks) methods, such as Stylus tracking using the native stylusTracer. This tracer is for debugging Stylus contracts by tracing calls between the WasmVM and EVM, allowing developers to fully understand their Stylus transactions. stylusTracer is currently available on Arbitrum One mainnet.

const url =
  "https://arbitrum-mainnet.core.chainstack.com/<KEY>";

const payload = {
  method: "debug_traceTransaction",
  params: [
    "0x3c9329b765d88c03d18f87dc1f2b5138c89d9a415d5c73dc7827b87aca176c8e",
    {
      tracer: "stylusTracer"
    }
  ],
  id: 1,
  jsonrpc: "2.0"
};

async function traceTransaction() {
  try {
    const res = await fetch(url, {
      method: "POST",
      headers: {
        "Content-Type": "application/json"
      },
      body: JSON.stringify(payload)
    });

    const data = await res.json();
    console.log(data);
  } catch (err) {
    console.error(err);
  }
}

traceTransaction();

Transactions are submitted to the Arbitrum sequencer through the standard eth_sendRawTransaction RPC method. The following example sends a signed transaction to the sequencer:

curl https://arbitrum-mainnet.core.chainstack.com/<KEY> \
-H "Content-Type: application/json" \
-d '{
    "jsonrpc":"2.0",
    "method":"eth_sendRawTransaction",
    "params":["0xsigned_tx"],
    "id":1
}'

Once the sequencer accepts the transaction and includes it in an L2 block, the RPC request returns immediately. This provides soft confirmation within approximately 1 to 2 seconds, while Ethereum finality is reached after the challenge period.

For a complete reference covering supported endpoints, authentication, archive access, WebSocket connectivity, and advanced RPC methods, see the Chainstack Arbitrum documentation.

Optimism

Optimism exposes the same Ethereum-compatible JSON-RPC interface that developers use on Ethereum, allowing existing tooling and applications to work without modification. Within the OP Stack architecture, both Global and Trader nodes run op-reth to execute transactions and serve RPC requests. Production RPC through Chainstack provides access to Optimism Mainnet and Sepolia, with support for archive workloads and WebSocket connectivity for production applications.

Chain ID: 10

Mainnet: https://optimism-mainnet.core.chainstack.com

Testnet: https://optimism-sepolia.core.chainstack.com

Since Optimism implements the Ethereum JSON-RPC specification, common workflows such as reading chain state, subscribing to new blocks, and submitting transactions use the same RPC methods as Ethereum.

const options = {
  method: 'POST',
  headers: {'Content-Type': 'application/json'},
  body: JSON.stringify({jsonrpc: '2.0', method: 'eth_blockNumber', id: 1})
};

fetch('https://optimism-mainnet.core.chainstack.com/<KEY>', options)
  .then(res => res.json())
  .then(res => console.log(res))
  .catch(err => console.error(err));

Subscribe to Optimism WebSocket connections for real-time updates:

wss://optimism-sepolia.core.chainstack.com

⚠️ Public Optimism RPC endpoints are intended for basic JSON-RPC access and are rate limited. Applications that rely on eth_subscribe, event streaming, or other WebSocket features should use a dedicated RPC provider such as Chainstack.

Subscribe to real-time Optimism event logs using eth_subscribe:

const WebSocket = require('ws');

const webSocket = new WebSocket('wss://optimism-sepolia.core.chainstack.com/<KEY>');

async function subscribeToNewBlocks() {

  const request = {
    id: 1,
    jsonrpc: '2.0',
    method: 'eth_subscribe',
    params: ['newHeads'],
  };

  const onOpen = (event) => {
    webSocket.send(JSON.stringify(request));
  };

  const onMessage = (event) => {
    const response = JSON.parse(event.data);
    console.log(response);
  };

  try {
    webSocket.addEventListener('open', onOpen);
    webSocket.addEventListener('message', onMessage);
  } catch (error) {
    console.error(error);
  }
}

subscribeToNewBlocks();

To enable debug and trace APIs on your Optimism node, deploy a global node with the debug & trace APIs enabled.

Like Ethereum, transactions are submitted using the standard eth_sendRawTransaction RPC method. The request is forwarded to the Optimism sequencer, which orders and executes the transaction before including it in an L2 block.

curl https://optimism-sepolia.core.chainstack.com/<KEY> \
-H "Content-Type: application/json" \
-d '{
    "jsonrpc":"2.0",
    "method":"eth_sendRawTransaction",
    "params":["0xsigned_tx"],
    "id":1
}'

Like Arbitrum, transactions are accepted by the sequencer first and only later posted to Ethereum for finalization after the challenge window.

Explore the Chainstack Optimism documentation for a complete reference of supported RPC methods, endpoints, authentication, and archive features.

Although both networks expose identical JSON-RPC methods, their RPC behavior differs at the infrastructure level. This difference affects how providers scale infrastructure, but not how developers interact with the API.

Ecosystem

The ecosystem surrounding a rollup often matters as much as the underlying technology. Liquidity, users, developer tooling, and application distribution all influence where new products gain traction.

Arbitrum and Optimism approach ecosystem growth differently. Arbitrum focuses on deep liquidity and application-specific expansion through Orbit. Optimism focuses on cross-chain interoperability and infrastructure standardization across multiple OP Stack chains through the Superchain.

Superchain

Optimism’s ecosystem extends beyond OP Mainnet through the Superchain, a network of chains built on the OP Stack. The goal is to create a shared infrastructure layer where applications, assets, and users can move between chains using common standards.

The Superchain includes OP Mainnet, Unichain, World Chain, Zora, Ink, Soneium, and other OP Stack deployments. Together, these networks process more than 16 million daily transactions, making the Superchain one of the largest Ethereum-aligned ecosystems by activity.

As Superchain interoperability matures, participating chains gain access to shared messaging, common standards, and increasingly seamless asset movement. For developers, this creates a larger addressable user base without requiring entirely different infrastructure stacks for each deployment.

Protocols on OP Mainnet:

• Velodrome: primary liquidity hub on OP Mainnet and the leading ve(3,3)-based DEX in the ecosystem
• Synthetix: one of the earliest large-scale protocols to adopt Optimism as its primary execution environment
• Aave V3: major lending market with significant liquidity and borrowing activity
• Uniswap V3: core liquidity venue used across the Ethereum ecosystem
• ether.fi: liquid staking and restaking infrastructure with a growing presence on OP Mainnet
• Exactly Protocol: fixed-rate lending and borrowing markets

Beyond DeFi, Optimism hosts identity and attestation infrastructure such as Ethereum Attestation Service (EAS), while several Superchain members focus on consumer applications, creator economies, and social experiences.

Superchain deployments:

• Unichain: built by Uniswap Labs with a focus on trading infrastructure and low-latency execution
• World Chain: designed around verified human users and consumer-scale onboarding
• Zora: creator-focused network optimized for NFT and media applications
• Soneium: developed by Sony Block Solutions Labs for entertainment and consumer experiences

Orbit

Arbitrum’s expansion strategy centers around Orbit, a framework for launching custom Layer 2 and Layer 3 networks using the Nitro stack.

Orbit chains can settle to Arbitrum One or Ethereum and support a range of customization options, including alternative data availability layers, application-specific execution environments, and custom gas token models.

This flexibility has attracted gaming networks, trading-focused chains, and application-specific deployments that require greater control over execution and infrastructure design.

Notable Orbit deployments include XAI, Sanko, Degen Chain, and a growing number of application-specific chains.

Protocols on Arbitrum:

• GMX: one of the largest on-chain perpetual futures exchanges and an early success story for Layer 2 derivatives
• Camelot DEX: native Arbitrum DEX focused on ecosystem liquidity and token launches
• Pendle Finance: leading yield tokenization protocol with significant activity on Arbitrum
• Radiant Capital: cross-chain lending and borrowing markets
• Dolomite: margin trading and advanced lending infrastructure

Arbitrum has also become a destination for institutional and real-world asset initiatives. Robinhood selected Arbitrum as the infrastructure layer for tokenized stocks, ETFs, and commodities. Converge, developed by Ethena Labs and Securitize, brings large-scale dollar-denominated assets and tokenized financial products into the Arbitrum ecosystem. LG Electronics recently partnered with Arbitrum to build blockchain infrastructure for its onchain advertising network.

The ecosystem differences between Arbitrum and Optimism influence where applications find users and liquidity.

Arbitrum’s strengths are concentrated around trading, derivatives, lending markets, and institutional finance. Applications in these categories benefit from deep liquidity, mature financial infrastructure, and an active DeFi user base.

Optimism’s strengths come from ecosystem distribution. The Superchain provides access to multiple OP Stack networks through a shared technology stack, creating opportunities across consumer applications, identity systems, creator platforms, and multi-chain products.

For production teams, ecosystem selection shapes more than user acquisition. It influences liquidity access, integration opportunities, infrastructure requirements, and long-term expansion strategies across the Ethereum Layer 2 landscape.

Builder tools

Supported languages

Arbitrum

• Solidity: primary language for EVM smart contracts
• Vyper: Python-inspired smart contract language
• Rust: supported through Stylus for WebAssembly contracts
• C: supported through Stylus and WebAssembly compilation
• C++: supported through Stylus and WebAssembly compilation

Optimism

• Solidity: primary language for EVM smart contracts
• Vyper: Python-inspired smart contract language

SDKs and libraries

• Arbitrum SDK: TypeScript SDK for bridging, cross-chain messaging, and L1/L2 interaction
• Arbitrum Orbit SDK: toolkit for deploying and configuring Orbit chains
• Stylus SDK: Rust SDK for developing Stylus contracts
• Nitro Node Tooling: core tooling and node implementation for the Arbitrum stack
• Viem OP Extensions: OP Stack integrations for viem applications
• supersim: local Superchain simulator for multi-chain testing
• Superchain ERC-20: token standard for interoperability across Superchain networks

Developer support

• Arbitrum Docs: documentation for Nitro, Stylus, Orbit, and node operations
• Arbitrum Foundation: grants, ecosystem programs, and governance support
• Arbitrum DAO: governance forum and protocol decision-making
• Optimism Docs: documentation for the OP Stack, Superchain architecture, and node operations
• Optimism DAO: ecosystem governance

Which is the better L2?

The choice between Arbitrum and Optimism is an ecosystem and infrastructure alignment decision. Fees and execution speed are equivalent in 2026. The relevant considerations are where your users are, what protocols you need to compose with, and what your long-term infrastructure strategy looks like.

Choose both when:

• you are a stablecoin issuer, a major DeFi protocol, or an application where cross-rollup liquidity is important
• you expect users to interact across multiple ecosystems and want routing flexibility between liquidity venues
• you prefer intent-based routing systems that decide execution path dynamically across Arbitrum and OP Stack chains
• you are building at scale and want redundancy across two major Layer 2 ecosystems

Conclusion

Arbitrum One and OP Mainnet are both production-grade Ethereum scaling environments. They share the same rollup model, the same settlement layer, and equivalent fees post-EIP-4844. What they offer differently is ecosystem composition and infrastructure scaling philosophy.

Arbitrum leads in single-chain DeFi depth, institutional adoption, and Stylus as an execution environment for non-Solidity developers. Optimism leads in cross-chain infrastructure standardization through the OP Stack and Superchain interoperability.

For either choice, reliable RPC infrastructure is non-negotiable in production. Public endpoints are rate-limited and unsuitable for load. Archive access, trace methods, and WebSocket support all require a provider. Chainstack covers both networks with the infrastructure profile production applications need: dedicated nodes, archive access, trace support, and SOC 2 Type II compliance. The technical foundation exists on both chains. The question is which ecosystem gives your application the best starting position.

FAQ

Additional resources

Arbitrum on Chainstack

• Best Arbitrum RPC providers in 2026
• Arbitrum RPC nodes and APIs
• How to get an Arbitrum RPC endpoint in 2026
• Arbitrum tooling docs
• Arbitrum Nitro: an overview
• RPC infrastructure for RWA protocols

Optimism and the Superchain on Chainstack

• What is Unichain: choosing Unichain RPC for production
• Best Optimism RPC providers in 2026
• Optimism RPC nodes and APIs
• How to get an Optimism RPC endpoint in 2026
• Optimism tooling docs
• Flashblocks on Optimism via Chainstack