Logo
RPC Assistant

Scroll RPC Provider: How to Select Infrastructure for Your dApp

Summary

Choosing a Scroll RPC provider means balancing latency, reliability, and data access. This guide covers Scroll’s chain settings, evaluation criteria for production use, and code examples to get started. Whether you need a public endpoint or dedicated nodes, understand what to check before integrating.

Scroll RPC Provider Decision Checklist

Before selecting a Scroll RPC provider, evaluate these factors:

CriterionWhat to checkWhy it matters
Endpoint typeFull node vs archive nodeArchive nodes support historical state queries; full nodes are cheaper and sufficient for most apps
Rate limitsRequests per second (RPS) and monthly request capsAffects scalability; free tiers may throttle under load
LatencyGeographic server distribution and response timeHigh latency slows transaction broadcasts and data fetches
WebSocket supportwss:// endpoint availabilityRequired for real-time subscriptions (e.g., pending transactions, event logs)
SecurityAuthentication method (API key vs public) and privacy guaranteesPublic endpoints risk IP exposure; private endpoints are better for production
Uptime SLAProvider’s historical uptime and compensation policyNo provider guarantees 100%; check real‑world performance
Data coverageWhether archival/trace APIs are availableNeeded for indexers, analytics, and debugging complex transactions
Pricing modelPay-as-you-go vs flat monthly feeMatch your request volume to cost

Use this list to compare providers like OnFinality, which offers both public and dedicated Scroll RPC endpoints.

Scroll Network Overview

Scroll is a zkEVM (Type‑2) scaling solution for Ethereum, designed for bytecode‑level EVM equivalence. Developers can deploy existing Ethereum smart contracts without modification by changing the RPC URL. The network uses zero‑knowledge proofs to batch transactions off‑chain and submit validity proofs to Ethereum L1.

Key network parameters for Scroll Mainnet:

  • Chain ID: 534352 (0x82750)
  • Currency: ETH
  • Block Explorer: scrollscan.com
  • Official RPC: https://rpc.scroll.io
  • WebSocket: wss://scroll-rpc.publicnode.com

How to Connect to Scroll

Using a public endpoint (for testing)

curl -X POST https://scroll.api.onfinality.io/public \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Replace YOUR_API_KEY with your key from your provider.

curl -X POST https://scroll.api.onfinality.io/public \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_API_KEY" \
  -d '{"jsonrpc":"2.0","method":"eth_getBalance","params":["0x...", "latest"],"id":1}'

What to Look for in a Scroll RPC Provider

1. Reliability and Uptime

Even the best public RPCs experience intermittent outages. For production dApps, consider a dedicated node or a provider with a proven track record. OnFinality’s infrastructure includes monitoring and failover across multiple regions.

2. Latency and Geographic Distribution

Scroll’s RPC nodes are globally distributed. Check if the provider offers endpoints in regions close to your user base. Tools like curl -w "%{time_total}" can measure response times.

3. Archive Node Support

If your dApp needs historical data (e.g., past balances, event logs over months), you need an archive node. OnFinality provides archive RPC endpoints for Scroll; verify with the eth_getBalance method on an older block.

4. WebSocket Endpoints

Real‑time features (like order book updates, transaction monitoring) require WebSocket. Ensure the provider exposes wss:// endpoints and supports eth_subscribe.

5. Rate Limits and Scalability

Public endpoints often have strict rate limits. For high‑throughput apps, look for providers with custom RPS tiers. OnFinality offers scalable pricing from shared to dedicated nodes.

Comparison: Public vs. Private Scroll RPC

FeaturePublic RPCPrivate RPC (Dedicated Node)
AuthenticationNone or API keyAPI key or whitelist
Rate limitsLow (e.g., 100 req/min)Customizable (e.g., 1000 RPS)
Archive dataOften no extra costExtra RU per request
LatencyVariable by regionConsistent low latency
CostFree or pay-as-you-goMonthly fee based on tier
Ideal forDevelopment, low‑traffic appsProduction, high‑traffic dApps

Common Pitfalls When Choosing a Provider

  • Using a public endpoint in production – You risk rate limiting, IP blacklisting, and lack of SLA.
  • Ignoring WebSocket support – Many dApps need real‑time data; without wss, you must poll.
  • Not testing archive access – If your app needs historical data, confirm archive support early.
  • Overlooking geographic latency – A single data center may be slow for global users.

Key Takeaways

  • Scroll is an EVM‑equivalent zkEVM; chain ID 534352, currency ETH.
  • Evaluate providers on latency, rate limits, WebSocket, archive support, and pricing.
  • Public endpoints are fine for testing; private dedicated nodes are better for production.
  • OnFinality provides public and dedicated Scroll RPC with global coverage.

Frequently Asked Questions

Q: Does Scroll support archive RPC? A: Yes, many providers including OnFinality offer archive endpoints for Scroll. Archive nodes store the full historical state, enabling queries like eth_getBalance at any past block.

Q: What are the rate limits for the public Scroll RPC on OnFinality? A: Public endpoints are rate‑limited to ensure fair usage. For production workloads, we recommend a paid plan with dedicated resources.

Q: Can I use MetaMask with Scroll? A: Yes. In MetaMask, add a custom network with chain ID 534352 and an RPC URL from your provider. The OnFinality public endpoint works.

Q: How do I monitor my Scroll node performance? A: OnFinality provides dashboard metrics for response time, error rate, and usage. You can also use third‑party monitoring tools.

Q: Is there a testnet available? A: Scroll Sepolia testnet (chain ID 534351) is available but note that it was shut down as of July 30, 2026. Use Scroll Mainnet for development.

Next Steps

RPC Knowledge Base

Related RPC details

Never Worry about Infrastructure Again

OnFinality takes away the heavy lifting of DevOps so you can build smarter and faster.

Get Started