Scroll RPC Guide: How to Connect and Build on Scroll (2026)

Scroll is a ZK rollup built for maximum EVM equivalence. Unlike other ZK-EVMs that required compiler-level workarounds, Scroll operates at the bytecode level, which means existing Solidity contracts deploy without changes. This guide covers how Scroll RPC works, what makes it different from other ZK-EVMs, and how to connect from ethers.js, Web3.py, or curl.

For endpoint URLs, MetaMask setup, chain configuration, see the BoltRPC Scroll endpoint page.

What Is a Scroll RPC Endpoint

An RPC (Remote Procedure Call) endpoint is the URL your application uses to read from and write to the Scroll blockchain. Every wallet connection, contract call, transaction submission, event subscription passes through an RPC endpoint.

Scroll implements the standard Ethereum JSON-RPC 2.0 interface. The same eth_ methods you use on Ethereum mainnet work on Scroll without modification. Any client library that supports Ethereum also supports Scroll.

BoltRPC endpoints for Scroll:

Transport	URL
HTTPS	`https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY`
WSS	`wss://eu.endpoints.matrixed.link/ws/scroll?auth=YOUR_KEY`

Scroll’s ZK-EVM Architecture: Type 1 EVM Equivalence

Scroll is a type 1 ZK-EVM (bytecode-compatible). Understanding the ZK-EVM type spectrum matters for developers choosing between rollups:

Type	EVM Equivalence	Example	What Changes
Type 1	Bytecode level	Scroll	Nothing. Exact EVM execution.
Type 2	EVM-equivalent	Linea	Minor precompile differences
Type 4	Language level	zkSync Era	Compiler required; Solidity works but bytecode differs

Scroll’s type 1 equivalence means:

Solidity bytecode deployed to Ethereum mainnet deploys to Scroll identically
Hardhat, Foundry, Remix work with no configuration changes
All eth_ RPC methods behave exactly as on Ethereum
No custom SDK, no different toolchain

The trade-off is computational cost. Proving EVM execution at the bytecode level requires more expensive ZK circuits than proving a simplified VM. This is an infrastructure cost absorbed by the chain, not passed to developers through the API.

Example Scroll RPC Methods

Because Scroll is type 1 EVM-equivalent, the full standard eth_ method set works without exceptions. These are the methods most commonly used in Scroll production applications:

Reading state:

{"jsonrpc":"2.0","method":"eth_call","params":[{"to":"0xContractAddress","data":"0xCalldata"},"latest"],"id":1}

Checking block height:

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

Gas estimation:

{"jsonrpc":"2.0","method":"eth_estimateGas","params":[{"from":"0xSender","to":"0xContract","data":"0xCalldata"}],"id":1}

Transaction receipt (sequencer confirmation):

{"jsonrpc":"2.0","method":"eth_getTransactionReceipt","params":["0xTxHash"],"id":1}

Fetching logs:

{"jsonrpc":"2.0","method":"eth_getLogs","params":[{"fromBlock":"0x1","toBlock":"latest","address":"0xContractAddress"}],"id":1}

Public Scroll RPC Endpoints

These public endpoints are useful for testing and local development. They are rate-limited and not suitable for production.

Provider	HTTPS Endpoint	Chain ID
Scroll Official	`https://rpc.scroll.io`	534352
Ankr	`https://rpc.ankr.com/scroll`	534352
PublicNode	`https://scroll-mainnet.public.blastapi.io`	534352
dRPC	`https://scroll.drpc.org`	534352

For Scroll Sepolia testnet, use https://sepolia-rpc.scroll.io with chain ID 534351.

Connecting Step by Step

ethers.js (v6)

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider(
  "https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY"
);

// Read block number
const block = await provider.getBlockNumber();
console.log("Scroll block:", block);

// Call a contract
const abi = ["function balanceOf(address) view returns (uint256)"];
const contract = new ethers.Contract("0xTokenAddress", abi, provider);
const balance = await contract.balanceOf("0xWalletAddress");

WebSocket for event subscriptions:

const wsProvider = new ethers.WebSocketProvider(
  "wss://eu.endpoints.matrixed.link/ws/scroll?auth=YOUR_KEY"
);

wsProvider.on("block", (blockNumber) => {
  console.log("New Scroll block:", blockNumber);
});

Web3.py

from web3 import Web3

w3 = Web3(Web3.HTTPProvider(
    "https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY"
))

print(w3.is_connected())
print(w3.eth.block_number)
print(w3.eth.chain_id)  # 534352

# Call a contract
abi = [{"inputs":[{"name":"account","type":"address"}],"name":"balanceOf","outputs":[{"type":"uint256"}],"type":"function"}]
contract = w3.eth.contract(address="0xTokenAddress", abi=abi)
balance = contract.functions.balanceOf("0xWalletAddress").call()

curl

# Check block number
curl https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

# Check chain ID
curl https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY \
  -X POST \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_chainId","params":[],"id":1}'

The returned eth_chainId for Scroll Mainnet is 0x82750 (decimal 534352).

Scroll-Specific Considerations

ZK Proof Batching

Scroll does not generate a ZK proof for every individual transaction. Instead, transactions are collected into batches, and a single ZK proof is generated for the entire batch. This proof is then submitted to Ethereum L1 for verification.

For your application, this means:

Transactions are sequenced by the Scroll sequencer within seconds
ZK proof generation for the batch takes additional time
Proof verification on Ethereum L1 takes additional time after that

Two-Stage Finality

Scroll transactions pass through two distinct finality stages:

Stage 1: Sequencer confirmation The Scroll sequencer includes your transaction in a block. This happens within a few seconds of submission. eth_getTransactionReceipt returns a result at this stage. The transaction is not yet cryptographically final.

Stage 2: ZK finality on Ethereum The batch containing your transaction is proven and the proof is verified on Ethereum L1. This typically takes 1 to 2 hours. After this point, the transaction has the same finality guarantees as an Ethereum mainnet transaction.

What this means for your application:

For most DeFi interactions: sequencer confirmation is sufficient
For bridge withdrawals from Scroll to Ethereum: ZK finality is required
For applications that need to display “confirmed” status: consider which stage is appropriate for the risk profile

L1 Data Fees

Every Scroll transaction has two cost components:

L2 execution fee: standard gas costs for EVM execution on Scroll
L1 data fee: cost of publishing transaction calldata to Ethereum

eth_estimateGas returns the L2 execution cost only. The L1 data fee is automatically included when a transaction is submitted, based on current Ethereum gas prices. Scroll provides a scroll_estimateL1DataFee method for applications that need to display total cost upfront.

{"jsonrpc":"2.0","method":"scroll_estimateL1DataFee","params":[{"from":"0xSender","to":"0xContract","data":"0xCalldata"},"latest"],"id":1}

Common Issues

Transaction stuck after submission Scroll blocks are produced approximately every 3 seconds. If eth_getTransactionReceipt returns null for longer than 30 seconds, check: (1) that the transaction was broadcast successfully, (2) that the gas price meets the current network minimum, and (3) that the nonce is correct.

eth_getLogs returns no results on large ranges Public endpoints limit log query ranges. If querying a large block range, split the request into smaller chunks of 1000 to 2000 blocks. This is a rate-limiting policy on public nodes, not a Scroll protocol limitation.

Gas estimation lower than actual cost If a transaction reverts after passing eth_estimateGas, the contract state may have changed between estimation and submission. Add a 20% buffer to estimated gas when submitting transactions in automated pipelines.

WebSocket disconnects For long-running processes subscribed to Scroll events, implement reconnection logic. WebSocket connections may drop due to network timeouts or server-side limits. Libraries like ethers.js v6 do not automatically reconnect on disconnect.

Wrong chain ID Scroll Mainnet is 534352. Scroll Sepolia testnet is 534351. Signing transactions with the wrong chain ID causes immediate rejection. Verify eth_chainId before broadcasting transactions in staging environments.

Choosing a Scroll RPC Provider

For local development and testing, public endpoints are adequate. For production applications, public endpoints have rate limits that cause failures under real traffic.

When evaluating a provider for Scroll:

Latency: Scroll blocks are 3 seconds, so p95 response time matters for UX
WebSocket support: required for event subscriptions and real-time updates
Pricing predictability: some providers bill per method call or compute unit; ZK chains have higher proof complexity which some providers pass through in cost
Multi-chain coverage: if running across multiple ZK-EVMs, a single provider reduces credential management overhead

BoltRPC uses flat monthly pricing, which means proof complexity on Scroll does not affect your invoice. One API key covers Scroll alongside Linea and zkSync Era.

For MetaMask setup, wallet configuration, and full endpoint details, see the Scroll RPC endpoint page.

FAQ

What is the Scroll RPC endpoint URL?

The BoltRPC Scroll Mainnet endpoint is https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY. The chain ID is 534352. For WebSocket connections, use wss://eu.endpoints.matrixed.link/ws/scroll?auth=YOUR_KEY. Get your API key at trial.boltrpc.io.

What makes Scroll a type 1 ZK-EVM?

Type 1 refers to bytecode-level EVM equivalence. Scroll proves EVM execution at the bytecode level, meaning Solidity contracts compile to the same bytecode as on Ethereum and execute identically. This differs from type 4 ZK-EVMs like zkSync Era, which use a custom compiler, and type 2 like Linea, which may have minor precompile differences.

How long does Scroll transaction finality take?

Sequencer confirmation happens within a few seconds. Full ZK finality on Ethereum L1 takes approximately 1 to 2 hours, depending on batch size and Ethereum gas conditions. Most application interactions only require sequencer confirmation. Bridge withdrawals require ZK finality.

Can I use the same Solidity contracts on Scroll as on Ethereum?

Yes. Scroll’s type 1 EVM equivalence means Ethereum bytecode runs on Scroll without any modifications. The same contract code, deployment scripts, ABIs, and tooling (Hardhat, Foundry, Remix) work unchanged. The only required change is the RPC endpoint and chain ID.

FAQPage Schema

<script type="application/ld+json">
{
  "@context": "https://schema.org",
  "@type": "FAQPage",
  "mainEntity": [
    {
      "@type": "Question",
      "name": "What is the Scroll RPC endpoint URL?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "The BoltRPC Scroll Mainnet endpoint is https://eu.endpoints.matrixed.link/rpc/scroll?auth=YOUR_KEY. The chain ID is 534352. For WebSocket connections, use wss://eu.endpoints.matrixed.link/ws/scroll?auth=YOUR_KEY. Get your API key at trial.boltrpc.io."
      }
    },
    {
      "@type": "Question",
      "name": "What makes Scroll a type 1 ZK-EVM?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Type 1 refers to bytecode-level EVM equivalence. Scroll proves EVM execution at the bytecode level, meaning Solidity contracts compile to the same bytecode as on Ethereum and execute identically. This differs from type 4 ZK-EVMs like zkSync Era and type 2 like Linea."
      }
    },
    {
      "@type": "Question",
      "name": "How long does Scroll transaction finality take?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Sequencer confirmation happens within a few seconds. Full ZK finality on Ethereum L1 takes approximately 1 to 2 hours. Most application interactions only require sequencer confirmation. Bridge withdrawals require ZK finality."
      }
    },
    {
      "@type": "Question",
      "name": "Can I use the same Solidity contracts on Scroll as on Ethereum?",
      "acceptedAnswer": {
        "@type": "Answer",
        "text": "Yes. Scroll's type 1 EVM equivalence means Ethereum bytecode runs on Scroll without any modifications. The same contract code, deployment scripts, ABIs, and tooling work unchanged. The only required change is the RPC endpoint and chain ID."
      }
    }
  ]
}
</script>

Get your Scroll RPC endpoint at BoltRPC. 2-week free trial. No credit card required.

Scroll RPC Guide: How to Connect and Build on Scroll (2026)

Scroll RPC Guide: How to Connect and Build on Scroll (2026)

What Is a Scroll RPC Endpoint

Scroll’s ZK-EVM Architecture: Type 1 EVM Equivalence

Example Scroll RPC Methods

Public Scroll RPC Endpoints

Connecting Step by Step

ethers.js (v6)

Web3.py

curl

Scroll-Specific Considerations

ZK Proof Batching

Two-Stage Finality

L1 Data Fees

Common Issues

Choosing a Scroll RPC Provider

FAQ

FAQPage Schema

Frequently asked questions

Ready to build with high-performance RPC?

Continue reading

Enjin RPC Guide: Matrix Chain + Relay Chain Endpoints, Methods, Code Examples 2026

Ethereum Hoodi Beacon Chain API Guide (2026)

Ethereum Sepolia Beacon Chain API Guide (2026)