DEV Community: Zhuoxin Sun

Best Ethereum RPC for Latest Network Upgrades 2025 Guide

Zhuoxin Sun — Mon, 20 Jul 2026 03:09:38 +0000

Ethereum RPC Decision Checklist

Before diving into provider comparisons, use this checklist to evaluate any Ethereum RPC endpoint for upgrade readiness:

Upgrade support timeline: Does the provider announce support for upcoming hard forks (e.g., Pectra, Verkle) before mainnet activation?
Testnet availability: Can you test new methods on Sepolia or Holesky before mainnet?
Blob transaction support: Does the endpoint expose eth_getBlobSidecars and blobBaseFee?
Archive data: Do you need historical state access for pre-upgrade blocks?
Trace API: Are debug_trace* and trace_* methods available for post-upgrade debugging?
Rate limits and scaling: Can the provider handle increased traffic during upgrade periods?
Backward compatibility: Does the provider maintain legacy methods after a fork?

Why Ethereum Upgrades Matter for RPC Selection

Ethereum's roadmap includes frequent protocol upgrades that introduce new transaction types, state structures, and JSON-RPC methods. For example, the Dencun upgrade (EIP-4844) added blob-carrying transactions and the blobBaseFee field. Future upgrades like Pectra will bring account abstraction improvements, and Verkle trees will change how state is stored and accessed.

An RPC provider that lags in supporting these changes can break your dApp's functionality. You need a provider that:

Updates its nodes promptly after a hard fork.
Exposes new RPC methods as soon as they are stable.
Maintains testnet endpoints that mirror upcoming mainnet changes.

Key Criteria for Upgrade-Ready Ethereum RPC Providers

When evaluating providers for upgrade readiness, consider the following criteria:

Criterion	What to check	Why it matters
Upgrade announcement	Does the provider publish a support timeline?	Ensures you can plan ahead.
Testnet endpoints	Are Sepolia/Holesky endpoints available?	Allows pre-upgrade testing.
Blob method support	`eth_getBlobSidecars`, `blobBaseFee`	Required for Dencun+ features.
Archive node access	Historical state for pre-upgrade blocks	Needed for analytics and audits.
Trace API	`debug_traceTransaction`, `trace_block`	Essential for debugging after upgrades.
Rate limit flexibility	Can you increase limits during spikes?	Prevents throttling during upgrade events.
Backward compatibility	Are deprecated methods still available?	Avoids breaking changes.

How to Test an RPC Provider's Upgrade Support

You can verify a provider's upgrade readiness by sending test requests. For example, after Dencun, you can check blob support:

curl -X POST https://your-rpc-endpoint \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getBlobSidecars",
    "params": ["0x1234..."],
    "id": 1
  }'

If the method returns a result (even an empty array), the provider supports it. For upcoming upgrades, check for methods like eth_sendRawTransactionConditional (Pectra) or eth_getVerkleProof (Verkle).

Common Pitfalls When Using RPC Providers During Upgrades

Assuming immediate support: Not all providers update nodes on day one. Check their upgrade history.
Ignoring testnet: Always test new methods on Sepolia before mainnet.
Overlooking archive data: If you need historical state, ensure the provider offers archive nodes.
Neglecting rate limits: Upgrade events often cause traffic spikes; confirm your provider can handle them.
Forgetting backward compatibility: Some providers drop old methods after a fork. Verify your critical methods remain available.

Choosing Between Shared and Dedicated Nodes

Shared RPC endpoints are cost-effective for development and low-traffic applications. However, during network upgrades, shared nodes may experience higher latency due to increased load. Dedicated nodes provide isolated resources, predictable performance, and full control over node configuration (e.g., enabling specific flags for upgrade testing).

If your application is production-critical, consider a dedicated node to ensure consistent access during upgrade periods. OnFinality offers both shared RPC API access and dedicated node options for Ethereum mainnet and testnets.

Next Steps

Test on testnet: Use an Ethereum Sepolia endpoint to verify your application works with the latest upgrade methods.
Review provider documentation: Check the provider's upgrade support policy and method availability.
Plan for scaling: Ensure your RPC plan can handle traffic spikes during upgrade events.
Consider dedicated infrastructure: For production workloads, evaluate dedicated node options.

Explore OnFinality's Ethereum Sepolia testnet RPC to start testing, or view our full list of supported networks and RPC pricing.

Key Takeaways

Ethereum upgrades introduce new RPC methods and state changes; your provider must support them promptly.
Look for providers that announce upgrade support timelines and maintain testnet endpoints for pre-release testing.
Blob transaction support (eth_getBlobSidecars, blobBaseFee) is critical for Dencun and future upgrades.
Test new methods on testnet before mainnet deployment.
Dedicated nodes offer more control and predictable performance during upgrade periods.

Frequently Asked Questions

Q: How can I check if my RPC provider supports the latest Ethereum upgrade?
A: Send a request for a new method (e.g., eth_getBlobSidecars) and check the response. Also, review the provider's upgrade support documentation.

Q: What is the best Ethereum RPC for testing upcoming upgrades?
A: Use a testnet endpoint like Sepolia. OnFinality provides Sepolia RPC endpoints that are updated with the latest upgrade methods.

Q: Do I need an archive node for upgrade compatibility?
A: Only if your application requires historical state from before the upgrade. For most dApps, a full node is sufficient.

Q: Will my existing RPC methods stop working after an upgrade?
A: Most providers maintain backward compatibility, but it's best to verify with your provider's changelog.

Q: How do dedicated nodes help during upgrades?
A: Dedicated nodes give you full control over node configuration and ensure isolated resources, reducing the risk of rate limiting or latency spikes.

Related resources

Originally published at OnFinality.

Node Infrastructure Guide: Evaluation & Best Practices for Web3

Zhuoxin Sun — Mon, 20 Jul 2026 03:09:02 +0000

Node infrastructure decision checklist

Before committing to a node infrastructure strategy, evaluate these key factors:

Criterion	What to check	Why it matters
Network coverage	Which blockchains do you need?	Multi-chain apps require consistent access across L1s and L2s.
Node type	Full node, archive node, or light node?	Archive nodes provide historical state but cost more; light nodes are faster but limited.
Hosting model	Self-hosted vs managed provider	Self-hosted gives full control but adds DevOps burden; managed reduces operational overhead.
Reliability	Uptime history, redundancy, failover	Downtime directly impacts user experience and transaction finality.
Performance	Latency, throughput, rate limits	High-frequency trading or data-heavy dApps need low latency and high throughput.
Security	Access controls, DDoS protection, data encryption	Node endpoints are attack vectors; secure infrastructure is critical.
Cost	Hardware, bandwidth, maintenance vs subscription fees	Total cost of ownership varies significantly between self-hosted and managed.
Scalability	Ability to handle traffic spikes	Launch days or viral dApps can overwhelm under-provisioned nodes.

What is node infrastructure?

Node infrastructure is the combination of hardware (servers, storage, networking), software (blockchain client, middleware), and operational practices that enable a blockchain node to connect to a network, sync the ledger, validate transactions, and serve data to applications. In a decentralized network, each node maintains a copy of the ledger and communicates with peers to reach consensus. For developers building on Web3, node infrastructure is the gateway to reading and writing blockchain data.

Node infrastructure can be self-hosted (you run your own servers and software) or managed (a third-party provider hosts and maintains nodes for you). The choice depends on your project's requirements for control, cost, reliability, and scalability.

Why node infrastructure matters for Web3 projects

Every interaction with a blockchain—submitting a transaction, querying a balance, or listening for events—goes through a node. If the node is slow, unreliable, or unavailable, your application suffers. Poor node infrastructure leads to:

Transaction failures or delays
Stale data in user interfaces
Increased development and maintenance overhead
Security vulnerabilities from misconfigured nodes

For production dApps, node infrastructure is not an afterthought; it is a core architectural decision that affects user experience, development velocity, and operational costs.

Self-hosted vs managed node infrastructure

Self-hosted nodes

Running your own node gives you full control over the software, hardware, and configuration. You can optimize for specific workloads, use custom patches, and avoid third-party dependencies. However, self-hosting requires:

Dedicated hardware or cloud instances with sufficient CPU, RAM, and SSD storage
Network bandwidth for syncing and peer communication
Ongoing maintenance: software updates, chain migrations, security patches
Monitoring and alerting for uptime and performance
Expertise in blockchain client operations (e.g., Geth, Reth, Solana validator)

For a single Ethereum full node, you might need a machine with 4+ vCPUs, 16+ GB RAM, and 2+ TB SSD. Archive nodes require significantly more storage (12+ TB for Ethereum). The operational burden grows with the number of chains you support.

Managed node providers

Managed services handle the heavy lifting: provisioning, syncing, monitoring, and scaling. You get an RPC endpoint or dedicated node without managing the underlying infrastructure. Benefits include:

Reduced DevOps overhead
Built-in redundancy and failover
Access to multiple chains from a single provider
Predictable pricing (subscription or pay-as-you-go)

When evaluating managed providers, consider the criteria in the checklist above. Providers like OnFinality offer both shared RPC APIs and dedicated nodes across many networks, with transparent RPC pricing and a wide range of supported networks.

Key components of node infrastructure

Hardware

CPU: Multi-core processors for transaction validation and block processing.
RAM: Sufficient memory for state caching and client operations (16-64 GB typical).
Storage: Fast SSDs (NVMe recommended) for blockchain data. Archive nodes require terabytes of storage.
Network: Low-latency internet connection with high bandwidth for syncing and peer communication.

Software

Blockchain client: The core software that implements the network protocol (e.g., Geth, Nethermind, Solana Labs client, Substrate node).
Middleware: Tools for load balancing, caching, rate limiting, and API gateways.
Monitoring: Prometheus, Grafana, or custom scripts to track node health.

Operations

Syncing: Initial sync can take days; incremental sync must keep up with block production.
Updates: Regular client upgrades to stay on the correct chain fork.
Backups: Snapshot backups for quick recovery.
Security: Firewall rules, SSH key management, DDoS protection.

How to evaluate node infrastructure providers

When comparing providers, focus on these dimensions:

Network support: Does the provider cover the chains you need (Ethereum, Solana, Polygon, BNB Chain, etc.)? Check OnFinality's network list for supported chains.
Performance: Look for low latency and high throughput. Some providers offer dedicated nodes for consistent performance.
Reliability: Ask about uptime SLAs, redundancy architecture, and historical incident response.
Pricing: Compare free tiers, pay-as-you-go rates, and dedicated node costs. See RPC pricing for transparent options.
Developer experience: API documentation, SDKs, WebSocket support, and testnet availability.
Security: Authentication methods (API keys, JWT), IP whitelisting, and encryption.

Common pitfalls in node infrastructure

Under-provisioning: Choosing insufficient hardware leads to sync failures or high latency.
Single point of failure: Running a single node without redundancy risks downtime.
Ignoring chain migrations: Hard forks or state changes can break nodes if not updated promptly.
Rate limit surprises: Shared endpoints often have rate limits that can throttle production traffic.
Neglecting monitoring: Without proper alerts, node issues go unnoticed until users complain.

Example: Connecting to a node via JSON-RPC

Once you have node infrastructure (self-hosted or managed), you interact with it via RPC. Here's a simple curl example querying an Ethereum node:

curl -X POST https://eth-mainnet.g.alchemy.com/v2/YOUR_API_KEY \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_blockNumber",
    "params": [],
    "id": 1
  }'

For a managed provider like OnFinality, you would use the provided endpoint URL and API key.

Key Takeaways

Node infrastructure is the foundation of any Web3 application; reliability and performance directly impact user experience.
Choose between self-hosted and managed based on your team's DevOps capacity, budget, and scalability needs.
Evaluate providers on network coverage, performance, reliability, pricing, and security.
Avoid common pitfalls like under-provisioning and single points of failure.
Use the decision checklist to systematically compare options before committing.

Frequently Asked Questions

What is the difference between a full node and an archive node?
A full node stores the entire blockchain state up to the latest block but prunes historical state data. An archive node stores all historical states, allowing queries for any past block. Archive nodes require significantly more storage.

Can I run multiple chains on the same hardware?
Yes, but each node consumes CPU, memory, and storage. Running multiple nodes on one machine may cause resource contention. Use separate instances or containers with resource limits.

How do I choose between shared and dedicated nodes?
Shared nodes are cost-effective for low-to-medium traffic. Dedicated nodes provide consistent performance and are recommended for production dApps with high throughput or strict latency requirements.

What happens if my node provider goes down?
If you use a managed provider, check their redundancy and failover architecture. For self-hosted nodes, set up monitoring and have a backup node ready. Some providers offer multi-region deployments for high availability.

Do I need to run my own node?
Not necessarily. Many successful dApps use managed node providers. Running your own node gives you full control but requires significant operational expertise. Start with a managed service and migrate to self-hosted if needed.

Related resources

Originally published at OnFinality.

Solana Devnet Guide: RPC Endpoints, Faucet, and Setup for Developers

Zhuoxin Sun — Mon, 20 Jul 2026 03:08:26 +0000

Solana Devnet decision checklist

Before diving into Solana Devnet, consider these key factors:

Criterion	What to check	Why it matters
RPC endpoint reliability	Does the provider offer dedicated or shared Devnet RPC?	Unreliable endpoints cause transaction failures and wasted development time.
Faucet availability	Can you get Devnet SOL easily?	Without test tokens, you cannot deploy programs or pay transaction fees.
Rate limits	How many requests per second are allowed?	Low limits can block automated testing and CI/CD pipelines.
Network reset frequency	How often is Devnet wiped?	Frequent resets may require you to redeploy programs and re-fund accounts.
Documentation quality	Are there clear setup guides and examples?	Good docs reduce onboarding friction and debugging time.

What is Solana Devnet?

Solana Devnet is a public development network that closely mimics Solana Mainnet Beta. It is designed for developers to build, test, and iterate on Solana programs (smart contracts) and dApps without risking real SOL. Devnet uses test tokens that have no monetary value, and you can obtain them for free from faucets.

Devnet runs its own validator set and maintains a separate ledger from Mainnet. While it aims to replicate Mainnet's behavior, it may experience periodic resets or configuration changes. This makes it ideal for early-stage development, integration testing, and educational purposes.

Devnet vs Testnet vs Mainnet

Solana provides three main clusters:

Devnet: For developers to test applications with free test SOL. Closely mirrors Mainnet but may be reset.
Testnet: Used by validators and core developers to test protocol upgrades and network performance. Less stable than Devnet.
Mainnet Beta: The production network where real SOL is used. All applications should be thoroughly tested on Devnet before deploying here.

How to connect to Solana Devnet

To interact with Solana Devnet, you need an RPC endpoint. You can use the public endpoint provided by Solana Labs or a third-party provider like OnFinality.

Public Devnet RPC endpoint

https://api.devnet.solana.com

Using OnFinality for Devnet RPC

OnFinality offers dedicated and shared RPC endpoints for Solana Devnet, with higher rate limits and better reliability than the public endpoint. You can get your own endpoint URL from the OnFinality dashboard.

Getting Devnet SOL (faucet)

To pay for transactions and deploy programs on Devnet, you need Devnet SOL. The official faucet is at faucet.solana.com. You can request an airdrop of up to 2 SOL every 8 hours without authentication, or sign in with GitHub for a higher limit.

Using the Solana CLI

# Set your CLI to use Devnet
solana config set --url https://api.devnet.solana.com

# Request 1 SOL airdrop
solana airdrop 1 <YOUR_WALLET_ADDRESS>

# Check balance
solana balance

If the public faucet is rate-limited, you can use alternative faucets or an RPC provider that includes faucet access.

Setting up your development environment

Install Solana CLI

sh -c "$(curl -sSfL https://release.solana.com/v1.18.26/install)"

Configure for Devnet

solana config set --url https://api.devnet.solana.com
solana config get

Create a wallet

solana-keygen new --outfile ~/.config/solana/id.json

Deploy a sample program

# Create a new project
cargo new hello-solana --lib
cd hello-solana

# Build and deploy
cargo build-bpf
solana program deploy ./target/deploy/hello_solana.so

Common pitfalls and troubleshooting

Rate limiting on public RPC

The public Devnet endpoint (api.devnet.solana.com) has strict rate limits. If you encounter "429 Too Many Requests" errors, consider using a provider like OnFinality that offers higher limits.

Faucet not working

Ensure you are using the correct wallet address (Base58 format).
The official faucet limits requests to 2 SOL per 8 hours per IP. Use a GitHub account to increase limits.
If the faucet is down, try alternative faucets or use the CLI solana airdrop command with a different RPC provider.

Network resets

Devnet can be reset without notice. Always store your program IDs and account seeds so you can redeploy quickly. Use environment variables for configuration.

Choosing an RPC provider for Devnet

When selecting an RPC provider for Solana Devnet, consider:

Reliability: Uptime and response consistency.
Rate limits: Higher limits for CI/CD and automated testing.
Faucet integration: Some providers offer built-in faucet access.
Support: Responsive support for development issues.

OnFinality provides Solana Devnet RPC endpoints with competitive rate limits and easy setup. You can also compare RPC pricing to find a plan that fits your development needs.

Key Takeaways

Solana Devnet is a free test network that mirrors Mainnet Beta, ideal for development and testing.
Use the public RPC endpoint or a provider like OnFinality for better performance.
Get Devnet SOL from the official faucet or via CLI airdrop.
Be aware of rate limits and potential network resets.
Always test thoroughly on Devnet before deploying to Mainnet.

Frequently Asked Questions

Q: Can I transfer Devnet SOL to Mainnet?
No. Devnet SOL is a test token with no real value and cannot be transferred to Mainnet.

Q: How often is Devnet reset?
There is no fixed schedule, but resets occur during network upgrades or maintenance. Check the Solana status page for announcements.

Q: What is the difference between Devnet and Testnet?
Devnet is for application developers; Testnet is for protocol testing and validator experimentation.

Q: Do I need an API key to use Devnet RPC?
The public endpoint does not require a key, but it has low rate limits. Providers like OnFinality require a free account for higher limits.

Q: Can I run my own Devnet validator?
Yes, but it is not necessary for most developers. Using a public or provider RPC is simpler.

Related resources

Originally published at OnFinality.

Binance Smart Chain RPC: Complete Guide for Developers

Zhuoxin Sun — Mon, 20 Jul 2026 03:07:50 +0000

Binance Smart Chain RPC decision checklist

Before integrating a BSC RPC endpoint, consider these factors:

Criterion	What to check	Why it matters
Rate limits	Requests per second (RPS) or daily cap	Public endpoints often throttle; high-traffic dApps need higher limits
Reliability	Uptime history and redundancy	Downtime breaks your dApp; choose providers with multiple nodes
Data freshness	Block propagation delay	Stale data can cause transaction failures or incorrect state
Archive data	Support for historical state queries	Required for analytics, explorers, and certain DeFi operations
WebSocket support	Real-time event streaming	Essential for order books, notifications, and live updates
Security	HTTPS/WSS encryption, API key management	Protects against man-in-the-middle attacks and unauthorized access
Pricing model	Pay-as-you-go vs. subscription	Match your traffic patterns to avoid overpaying or hitting limits
Geographic latency	Server locations	Lower latency improves user experience; consider multi-region providers

What is a Binance Smart Chain RPC?

An RPC (Remote Procedure Call) endpoint is the URL that your wallet, dApp, or backend service uses to communicate with the Binance Smart Chain (BSC) network. BSC is an EVM-compatible blockchain, meaning it supports the same JSON-RPC API as Ethereum. This allows developers to use familiar tools like ethers.js, web3.js, and Hardhat to interact with BSC.

Every interaction with BSC—sending transactions, querying balances, calling smart contracts—goes through an RPC endpoint. The choice of RPC provider directly affects the speed, reliability, and cost of your application.

BSC network details

Chain ID: 56 (mainnet), 97 (testnet)
Currency: BNB
Block time: ~3 seconds
Consensus: Proof of Staked Authority (PoSA)
EVM compatibility: Full

How to connect to BSC using an RPC endpoint

Adding BSC to MetaMask

Open MetaMask and click the network dropdown.
Click "Add Network" and fill in:
- Network Name: BNB Smart Chain
- RPC URL: (your chosen endpoint)
- Chain ID: 56
- Symbol: BNB
- Block Explorer URL: https://bscscan.com
Click "Save".

Connecting via ethers.js

const { ethers } = require("ethers");

const provider = new ethers.JsonRpcProvider("https://bsc-dataseed.bnbchain.org");

async function getBlockNumber() {
  const blockNumber = await provider.getBlockNumber();
  console.log("Current block:", blockNumber);
}

getBlockNumber();

Using curl to call the RPC

curl -X POST https://bsc-dataseed.bnbchain.org \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Public vs. private RPC endpoints

Public endpoints

Public RPC endpoints are free and open to everyone. BSC provides official endpoints like:

https://bsc-dataseed.bnbchain.org
https://bsc-dataseed1.bnbchain.org
https://bsc-dataseed2.bnbchain.org

These are suitable for development, testing, and low-traffic applications. However, they have rate limits (e.g., 10,000 requests per 5 minutes) and may throttle under heavy load.

Private endpoints

Private endpoints require an API key and offer higher rate limits, dedicated resources, and better reliability. They are recommended for production dApps, especially those with high transaction volumes or real-time requirements.

OnFinality provides both shared and dedicated RPC endpoints for BSC, with flexible pricing to match your traffic needs. You can get started with a free tier and scale up as your project grows. See RPC pricing for details.

How to choose a BSC RPC provider

When evaluating providers, consider:

Latency: Lower latency means faster transaction confirmation and better user experience.
Uptime: Look for providers with redundant infrastructure and transparent status pages.
Rate limits: Ensure the plan supports your peak request volume.
Archive data: If you need historical state (e.g., for analytics), choose a provider that offers archive nodes.
WebSocket support: Required for real-time applications like DEX aggregators or NFT marketplaces.
Geographic distribution: Providers with multiple regions reduce latency for global users.

OnFinality offers BSC endpoints with low latency, high availability, and support for both HTTP and WebSocket. Check our supported networks for the latest list.

Common pitfalls and troubleshooting

Rate limiting

If you receive errors like 429 Too Many Requests, your application is exceeding the provider's rate limit. Solutions:

Upgrade to a paid plan with higher limits.
Implement request caching or batching.
Use multiple endpoints with fallback logic.

Stale data

Some public endpoints may lag behind the latest block. This can cause transaction failures or incorrect state reads. Mitigate by:

Using a provider with fast block propagation.
Checking the block number from multiple sources.
Subscribing to newHeads via WebSocket for real-time updates.

Connection timeouts

Network issues or overloaded servers can cause timeouts. Best practices:

Set reasonable timeout values in your client.
Implement retry logic with exponential backoff.
Use a provider with load balancing and failover.

BSC testnet RPC

For development and testing, use the BSC Testnet (Chain ID 97). Official testnet endpoints include:

https://data-seed-prebsc-1-s1.bnbchain.org:8545
https://data-seed-prebsc-2-s1.bnbchain.org:8545

You can get test BNB from the BSC Faucet.

OnFinality also supports BSC Testnet. See our BNB Testnet page for details.

Key Takeaways

BSC RPC endpoints are the bridge between your application and the blockchain.
Public endpoints are free but limited; private endpoints offer better performance for production.
Choose a provider based on latency, uptime, rate limits, and archive data support.
Always test with the testnet before deploying to mainnet.
Implement fallback and retry logic to handle failures gracefully.

Frequently Asked Questions

What is the BSC RPC URL?

The official BSC mainnet RPC URL is https://bsc-dataseed.bnbchain.org. Other providers offer alternative endpoints with different features.

Is BSC RPC free?

Yes, public endpoints are free but have rate limits. For higher limits, you need a paid plan from a provider like OnFinality.

How do I get a BSC RPC endpoint?

You can use a public endpoint directly or sign up with an RPC provider to get a private endpoint with an API key.

What is the difference between BSC and BNB Chain?

BNB Chain is the broader ecosystem that includes BNB Beacon Chain (staking/governance) and BNB Smart Chain (EVM-compatible). BSC is often used interchangeably with BNB Smart Chain.

Can I use Ethereum tools with BSC?

Yes, because BSC is EVM-compatible, you can use ethers.js, web3.js, Hardhat, and other Ethereum development tools.

What is the BSC testnet RPC?

The BSC testnet RPC URL is https://data-seed-prebsc-1-s1.bnbchain.org:8545. Use it for development and testing.

How do I find the best BSC RPC provider?

Evaluate providers based on latency, uptime, rate limits, archive support, and pricing. OnFinality offers competitive options for both shared and dedicated nodes. Check our RPC pricing and supported networks for more information.

Related resources

Originally published at OnFinality.

Polygon RPC: Complete Developer Guide to Endpoints and Providers

Zhuoxin Sun — Mon, 20 Jul 2026 03:07:14 +0000

Polygon RPC decision checklist

Before you integrate a Polygon RPC endpoint, evaluate these factors to avoid common pitfalls:

Criterion	What to check	Why it matters
Network & Chain ID	Confirm you are using Polygon PoS mainnet (Chain ID 137) or Amoy testnet (Chain ID 80002)	Wrong chain ID can cause transaction failures or fund loss
Rate limits	Public endpoints often cap requests per second (e.g., 10-100 req/s)	Exceeding limits leads to 429 errors and dropped requests
Uptime & reliability	Check historical uptime and node redundancy	Downtime can break your dApp or cause missed blocks
Data freshness	Ensure the endpoint returns the latest block quickly	Stale data can lead to incorrect state reads
WebSocket support	Verify WSS endpoint availability for real-time subscriptions	Required for event listeners and live updates
Privacy & security	Public endpoints may log your IP and requests	Sensitive applications need private endpoints
Archive data	Do you need historical state? Archive nodes store full history	Required for certain queries like eth_getLogs over large ranges
Cost	Compare free vs paid tiers, and understand pricing models	Unplanned costs can blow your budget

What is a Polygon RPC endpoint?

A Polygon RPC (Remote Procedure Call) endpoint is a URL that allows your application to communicate with the Polygon blockchain. It acts as a gateway, enabling you to send transactions, query balances, call smart contracts, and subscribe to events using standard JSON-RPC methods like eth_call, eth_getBalance, and eth_sendRawTransaction.

Polygon is an Ethereum-compatible (EVM) sidechain, so its RPC interface is nearly identical to Ethereum's. This means you can use the same Web3 libraries (ethers.js, web3.js, viem) and tools (Hardhat, Foundry, Remix) with minimal configuration changes.

Polygon network details

Polygon PoS Mainnet

Chain ID: 137 (0x89)
Currency: POL (formerly MATIC)
RPC endpoint: https://polygon.api.onfinality.io/public
WSS endpoint: wss://polygon.api.onfinality.io/public
Block explorer: PolygonScan

Polygon Amoy Testnet

Chain ID: 80002
Currency: POL (testnet)
RPC endpoint: https://polygon-amoy.api.onfinality.io/public
WSS endpoint: wss://polygon-amoy.api.onfinality.io/public
Block explorer: Amoy Polygonscan
Faucet: Available via the official Polygon faucet

How to use a Polygon RPC endpoint

1. Add to MetaMask

Open MetaMask and click the network dropdown.
Click "Add Network" and then "Add a network manually".
Fill in the details:
- Network Name: Polygon Mainnet
- RPC URL: https://polygon.api.onfinality.io/public
- Chain ID: 137
- Currency Symbol: POL
- Block Explorer URL: https://polygonscan.com
Click "Save".

2. Use with ethers.js

import { ethers } from "ethers";

const provider = new ethers.JsonRpcProvider("https://polygon.api.onfinality.io/public");
const blockNumber = await provider.getBlockNumber();
console.log("Current block:", blockNumber);

3. Use with curl

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

Public vs private Polygon RPC endpoints

Public endpoints

Public RPC endpoints are free and easy to use. They are great for prototyping, small projects, and personal use. However, they come with limitations:

Rate limits: Typically 10-100 requests per second. Exceeding these limits results in HTTP 429 errors.
No reliability expectations: Public nodes can go offline without notice.
No privacy: Your IP address and request data are visible to the node operator.
Limited data: Some public endpoints do not support archive data or debug/trace methods.

Popular public Polygon RPC endpoints include:

https://polygon.api.onfinality.io/public
https://polygon-bor-rpc.publicnode.com
https://polygon.drpc.org
https://1rpc.io/matic

Private endpoints

Private (or dedicated) endpoints are provisioned for your exclusive use. They offer:

Higher rate limits: Customizable to your needs, often thousands of requests per second.
Better reliability: Redundant infrastructure with SLAs.
Enhanced privacy: Your requests are not shared with other users.
Full API access: Support for archive data, debug/trace methods, and custom configurations.

Providers like OnFinality offer dedicated Polygon nodes that can be tailored to your application's requirements. You can choose between shared and dedicated infrastructure depending on your scale and budget.

Common issues and troubleshooting

429 Too Many Requests

This error indicates you have exceeded the rate limit of the endpoint. Solutions:

Reduce request frequency: Implement exponential backoff or batch requests.
Upgrade to a private endpoint: Private endpoints offer higher or clear rate limits.
Use multiple endpoints: Distribute requests across several public endpoints (but be aware of data consistency).

Connection timeouts

Timeouts can occur due to network congestion or node overload. Try:

Switching to a different endpoint from the list above.
Using a WebSocket endpoint for real-time subscriptions (more efficient for event-driven apps).
Contacting your provider if the issue persists.

Stale data

If you receive outdated block data, the node may be lagging. Verify the latest block number using a block explorer. For production, use endpoints with proven low latency.

How to choose a Polygon RPC provider

When selecting a provider for your Polygon dApp, consider the following:

Performance: Look for low latency and high throughput. Test endpoints with tools like curl or wscat.
Reliability: Check uptime history and whether the provider offers redundant nodes.
Scalability: Ensure the provider can handle your peak request volume without degradation.
Support: Evaluate the quality of documentation and technical support.
Pricing: Compare free tiers, pay-as-you-go, and dedicated plans. See RPC pricing for details.
Network coverage: Does the provider support both mainnet and testnet? OnFinality supports Polygon mainnet and Amoy testnet.

Key Takeaways

Polygon RPC endpoints allow your dApp to interact with the Polygon blockchain using standard JSON-RPC.
Public endpoints are free but come with rate limits and no guarantees; private endpoints offer better performance and reliability.
Always verify the network (mainnet vs testnet) and chain ID to avoid costly mistakes.
For production applications, consider using a dedicated node or a premium RPC service to ensure uptime and scalability.
Test your endpoint thoroughly before deploying to production.

Frequently Asked Questions

Q: What is the difference between Polygon RPC and Ethereum RPC?

A: Polygon is EVM-compatible, so the RPC interface is nearly identical. The main differences are the chain ID (137 vs 1) and the underlying consensus mechanism (Polygon uses a modified Proof-of-Stake with Bor and Heimdall layers).

Q: Can I use a free Polygon RPC for production?

A: It depends on your traffic. Free public endpoints are suitable for low-volume applications and testing. For production with high traffic, a private endpoint is recommended to avoid rate limits and downtime.

Q: How do I get a Polygon RPC URL?

A: You can use public endpoints listed in this guide, or sign up with a provider like OnFinality to get a dedicated endpoint. See supported RPC networks for more options.

Q: What is the Polygon Amoy testnet RPC?

A: The Amoy testnet RPC endpoint is https://polygon-amoy.api.onfinality.io/public with Chain ID 80002. It is used for testing before deploying to mainnet.

Q: How do I check my Polygon RPC endpoint is working?

A: Use curl to send a simple eth_blockNumber request. If you get a valid JSON response with a block number, the endpoint is working.

Q: What are the rate limits for public Polygon RPC?

A: Rate limits vary by provider. Typically, public endpoints allow 10-100 requests per second. Check the provider's documentation for exact limits.

Q: Can I use WebSocket with Polygon RPC?

A: Yes, many providers offer WebSocket endpoints (e.g., wss://polygon.api.onfinality.io/public). WebSocket is recommended for real-time subscriptions.

Q: What is the best Polygon RPC provider?

A: The best provider depends on your needs. For a balance of performance, reliability, and pricing, consider OnFinality. Evaluate multiple providers using the checklist above.

Q: How do I add Polygon to MetaMask?

A: Use the network details provided in this guide (Chain ID 137, RPC URL, etc.) and add it manually in MetaMask's network settings.

Q: What is the difference between Polygon PoS and Polygon zkEVM?

A: Polygon PoS is a sidechain with its own validator set, while Polygon zkEVM is a zero-knowledge rollup that inherits security from Ethereum. They have different RPC endpoints and chain IDs.

Related resources

Originally published at OnFinality.

Polygon RPC Provider Guide: How to Choose the Best One

Zhuoxin Sun — Mon, 20 Jul 2026 03:06:38 +0000

Polygon RPC provider decision checklist

Before evaluating providers, clarify your requirements:

Traffic volume: Estimate daily request count. Shared RPCs may suffice for under 1M requests/day; dedicated nodes or premium plans are better for higher throughput.
Data needs: Do you need archive state (historical balances, logs) or debug/trace methods? Not all providers offer these.
Latency sensitivity: Real-time applications (trading, gaming) require consistent low latency. Check WebSocket support.
Reliability: Look for providers with multiple endpoints, load balancing, and transparent uptime history.
Budget: Compare free tiers, pay-as-you-go, and dedicated node pricing. Factor in overage costs.
Support: For production, ensure access to technical support via chat, ticket, or dedicated account manager.

What is a Polygon RPC provider?

A Polygon RPC provider is a service that exposes JSON-RPC endpoints for interacting with the Polygon PoS chain (chain ID 137) and its testnet Amoy (chain ID 80002). Instead of running your own node, you connect to a provider's infrastructure to send transactions, query state, and subscribe to events. Providers handle node maintenance, scaling, and uptime, letting you focus on application logic.

Why your choice of Polygon RPC provider matters

Polygon processes millions of transactions daily. A poorly chosen RPC endpoint can become a bottleneck: rate limits throttle your app during spikes, unreliable nodes cause failed transactions, and missing archive data blocks analytics. The right provider ensures your dApp remains responsive and trustworthy.

Key criteria for evaluating Polygon RPC providers

Criterion	What to check	Why it matters
Rate limits	Requests per second (RPS) or daily cap	Exceeding limits causes errors; choose a plan matching your peak traffic
Archive data	Support for `eth_getBalance` at historical blocks, `eth_getLogs` with large ranges	Required for analytics, auditing, and dApp features like historical portfolio views
Debug/trace methods	`debug_traceTransaction`, `trace_block`	Needed for MEV analysis, gas optimization, and advanced debugging
WebSocket support	WSS endpoint availability	Essential for real-time event subscriptions (e.g., pending transactions, log filters)
Geographic distribution	Multiple regions or edge nodes	Reduces latency for global user base and improves failover
Uptime SLA	reliability expectations percentage (if any)	Critical for production apps; verify with independent monitoring
Pricing model	Free tier, pay-as-you-go, dedicated node	Match to your budget and scaling needs; watch for hidden overage fees
Support	Community vs. dedicated support	Production apps need responsive support to resolve issues quickly

Types of Polygon RPC providers

Shared (public) RPC endpoints

Free or low-cost endpoints shared among many users. Suitable for development, testing, and low-traffic apps. Limitations include rate limits, no archive data, and potential instability during high demand. Examples include the official Polygon public RPC and community-run endpoints.

Premium shared RPC

Paid plans with higher rate limits, priority access, and often archive support. Good for growing dApps that need more headroom without managing dedicated infrastructure.

Dedicated nodes

A private node (or cluster) reserved for your use. Offers full control over resources, clear rate limits, and consistent performance. Ideal for high-throughput applications, enterprise deployments, and workloads requiring custom configurations.

RPC aggregators / load balancers

Services that route requests across multiple providers for redundancy and failover. Useful for production apps that cannot tolerate downtime.

How to connect to a Polygon RPC provider

Once you have an endpoint URL, configure your Web3 library. Example using ethers.js:

const { ethers } = require("ethers");

// Replace with your Polygon RPC URL
const provider = new ethers.providers.JsonRpcProvider("https://polygon.api.onfinality.io/public");

async function getBlockNumber() {
  const blockNumber = await provider.getBlockNumber();
  console.log("Current block number:", blockNumber);
}

getBlockNumber();

For WebSocket subscriptions:

const provider = new ethers.providers.WebSocketProvider("wss://polygon.api.onfinality.io/public-ws");

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

Common pitfalls and how to avoid them

Ignoring rate limits: Always check the provider's rate limit policy. Implement retry logic with exponential backoff.
Using public RPC for production: Public endpoints are unreliable under load. Invest in a paid plan or dedicated node.
Not testing WebSocket stability: Some providers have flaky WebSocket connections. Test reconnection logic.
Assuming archive support: Not all providers offer full archive data. Verify before building features that depend on historical state.
Single point of failure: Use multiple providers or a load balancer to avoid downtime.

Troubleshooting Polygon RPC issues

Common errors

429 Too Many Requests: You've hit the rate limit. Reduce request frequency or upgrade your plan.
503 Service Unavailable: Provider overloaded. Switch to a different endpoint or implement failover.
Invalid JSON-RPC response: Network issue or malformed request. Check your payload and network connectivity.
Nonce too low: Transaction nonce mismatch. Use eth_getTransactionCount with the correct block parameter.

Quick checks

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

When to consider a dedicated Polygon node

Consider a dedicated node if:

Your app makes over 10M requests per month.
You need consistent low latency for real-time features.
You require custom node configurations (e.g., pruning, tracing).
You want to avoid noisy neighbors affecting performance.
You need full control over node software and upgrades.

Dedicated nodes from providers like OnFinality offer isolated resources, private endpoints, and often include archive data and debug methods.

Key Takeaways

Evaluate Polygon RPC providers based on rate limits, archive support, latency, and pricing.
Shared RPC is fine for development; production apps need premium or dedicated solutions.
Always test WebSocket stability and implement failover for critical applications.
Use the decision checklist to match provider features to your workload.
For high-throughput or enterprise use cases, consider a dedicated node for maximum reliability.

Frequently Asked Questions

What is the best Polygon RPC provider?
There is no single "best" provider—it depends on your traffic, data needs, and budget. Compare features like rate limits, archive support, and pricing to find the right fit.

Can I use a free Polygon RPC for production?
Free public RPCs are not recommended for production due to rate limits and potential instability. Use a paid plan or dedicated node for reliable service.

Does OnFinality support Polygon RPC?
Yes, OnFinality provides Polygon mainnet and testnet RPC endpoints. Visit the Polygon network page for details and RPC pricing for plan options.

How do I get Polygon testnet tokens?
Use the official Polygon Amoy faucet or your provider's faucet if available.

What is the difference between Polygon PoS and Polygon zkEVM?
Polygon PoS is a sidechain with its own RPC endpoints (chain ID 137). Polygon zkEVM is a ZK-rollup on Ethereum with separate endpoints. This guide focuses on Polygon PoS.

How can I monitor my Polygon RPC performance?
Use tools like Tenderly, Alchemy's dashboard, or custom monitoring with Prometheus to track latency, error rates, and throughput.

Related resources

Originally published at OnFinality.

Moonriver RPC: Endpoints, Configuration, and Best Practices

Zhuoxin Sun — Mon, 20 Jul 2026 03:06:02 +0000

Moonriver RPC Decision Checklist

Before integrating Moonriver RPC into your project, consider the following:

Criterion	What to check	Why it matters
Network type	Mainnet (chain ID 1285) vs testnet	Moonriver is a canary network with real MOVR tokens; ensure you are on the correct network for your use case.
Endpoint type	HTTPS vs WSS	Use HTTPS for standard requests, WSS for real-time subscriptions (e.g., event listeners).
Rate limits	Public vs private endpoints	Public endpoints have rate limits; for production, use a private endpoint or dedicated node.
Archive data	Full vs archive node	Archive nodes provide historical state; needed for dApps that query past data.
Provider reliability	Uptime, latency, support	Choose a provider with consistent performance and responsive support.
Pricing model	Pay-as-you-go vs subscription	Match the pricing model to your expected request volume.
Security	API key management, encryption	Protect your API keys and use HTTPS/WSS to secure data in transit.
Geographic distribution	Node locations	Multiple regions reduce latency for global users.

What is Moonriver?

Moonriver is a companion network to Moonbeam, serving as an incentivized canary network on the Kusama ecosystem. It provides a full Ethereum-like environment, supporting Solidity smart contracts and Ethereum-compatible tools. Developers use Moonriver to test new features and dApps in a production-like setting before deploying to Moonbeam. The native token is MOVR.

Moonriver Network Details

Chain ID: 1285 (0x505 in hex)
Currency: MOVR
Block Explorer: Moonscan
Block Time: ~12 seconds
Consensus: Nominated Proof-of-Stake (NPoS) with collators

Moonriver RPC Endpoints

To interact with Moonriver, you need an RPC endpoint. Below are common public endpoints (rate-limited) and private endpoints from providers.

Public Endpoints (for testing)

Provider	HTTPS URL	WSS URL
Moonbeam Foundation	`https://rpc.api.moonriver.moonbeam.network`	`wss://wss.api.moonriver.moonbeam.network`
OnFinality	`https://moonriver.api.onfinality.io/public`	`wss://moonriver.api.onfinality.io/public-ws`
PublicNode	`https://moonriver-rpc.publicnode.com`	`wss://moonriver-rpc.publicnode.com`
UnitedBloc	`https://moonriver.unitedbloc.com`	`wss://moonriver.unitedbloc.com`

Note: Public endpoints are rate-limited and not suitable for production. For reliable access, obtain a private API key from an RPC provider.

Private Endpoints (for production)

Private endpoints offer higher rate limits, dedicated support, and optional archive/trace data. Providers like OnFinality offer managed RPC services with configurable plans. Visit the Moonriver network page for details.

How to Connect to Moonriver

Using curl

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

Using ethers.js (JavaScript)

const { ethers } = require("ethers");

const provider = new ethers.JsonRpcProvider(
  "https://moonriver.api.onfinality.io/public",
  { chainId: 1285, name: "moonriver" }
);

async function getBlockNumber() {
  const blockNumber = await provider.getBlockNumber();
  console.log("Current block:", blockNumber);
}

getBlockNumber();

Using web3.py (Python)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://moonriver.api.onfinality.io/public"))
print(w3.eth.block_number)

Adding Moonriver to MetaMask

Open MetaMask and click the network dropdown.
Click "Add Network" or "Custom Network".
Enter the following details:
- Network Name: Moonriver
- New RPC URL: https://rpc.api.moonriver.moonbeam.network (or your private endpoint)
- Chain ID: 1285
- Currency Symbol: MOVR
- Block Explorer URL: https://moonriver.moonscan.io
Click "Save".

Choosing an RPC Provider for Moonriver

When selecting an RPC provider, consider:

Reliability: Look for providers with consistent uptime and low latency. Check their status page or community feedback.
Scalability: Ensure the provider can handle your request volume without throttling.
Features: Some providers offer archive nodes, trace APIs, or WebSocket support.
Pricing: Compare pay-as-you-go vs subscription plans. Visit RPC pricing for details.
Support: Access to technical support can be crucial for production dApps.

OnFinality provides Moonriver RPC endpoints with configurable rate limits, archive support, and dedicated node options. See the Moonriver network page for more information.

Common Pitfalls and Troubleshooting

Rate Limiting

Public endpoints have rate limits (e.g., 25-40 req/s). If you get 429 errors, switch to a private endpoint or reduce request frequency.

Incorrect Chain ID

Ensure your wallet or dApp uses chain ID 1285. Using the wrong chain ID can cause transaction failures.

WebSocket Disconnections

For real-time subscriptions, use WSS endpoints. If disconnections occur, implement reconnection logic in your application.

Missing Archive Data

If your dApp requires historical state, use an archive node. Not all providers offer archive data.

Key Takeaways

Moonriver is an Ethereum-compatible canary network on Kusama with chain ID 1285.
Public RPC endpoints are available for testing but have rate limits.
For production, use a private endpoint from a reliable provider.
Configure your tools (MetaMask, ethers.js, etc.) with the correct network details.
Evaluate providers based on reliability, scalability, features, and pricing.

Frequently Asked Questions

What is the difference between Moonriver and Moonbeam?

Moonriver is a canary network on Kusama where new features are tested before being deployed to Moonbeam on Polkadot. Moonriver uses MOVR tokens and has real economic value.

Can I use Moonriver for production dApps?

Yes, Moonriver is a live network with real assets. Many dApps deploy on Moonriver to reach the Kusama ecosystem.

How do I get MOVR tokens?

MOVR can be obtained through decentralized exchanges (e.g., SushiSwap on Moonriver) or centralized exchanges that list MOVR.

What are the rate limits for public endpoints?

Rate limits vary by provider. For example, the Moonbeam Foundation endpoint allows 25 req/s, while OnFinality's public endpoint allows 40 req/s. For higher limits, use a private endpoint.

Does OnFinality support Moonriver archive nodes?

Yes, OnFinality offers archive nodes for Moonriver. Check the Moonriver network page for details.

Next Steps

Explore the Moonriver network page to create a dedicated endpoint.
Review RPC pricing to choose a plan that fits your needs.
Browse all supported networks for other chains you may need.
For a deeper understanding of RPC provider selection, read our guide on choosing an RPC provider.

Related resources

Originally published at OnFinality.

Ethereum RPC Node Guide: What It Is and How to Choose One

Zhuoxin Sun — Mon, 20 Jul 2026 03:05:26 +0000

Ethereum RPC Node decision checklist

Before selecting an Ethereum RPC node, consider these factors:

Throughput requirements: Estimate your peak requests per second (RPS). Shared nodes may throttle at high volumes; dedicated nodes provide consistent capacity.
Reliability needs: For production apps, look for providers with redundant infrastructure and SLAs. Avoid single points of failure.
Data access: Full nodes provide current state; archive nodes store historical data. If you need past block states or trace calls, choose an archive node.
Geographic distribution: Low latency requires nodes close to your users. Providers with global endpoints reduce round-trip time.
Security and privacy: Shared nodes may log requests. Dedicated nodes offer isolation and better control over data.
Cost model: Evaluate free tiers, pay-as-you-go, and flat-rate plans. Factor in overage charges for burst traffic.
Testnet support: Ensure the provider offers Sepolia or Holesky endpoints for development and testing.

What is an Ethereum RPC node?

An Ethereum RPC node is a server that runs an Ethereum client (e.g., Geth, Nethermind, Erigon) and exposes the JSON-RPC API. This API allows external applications—wallets, dApps, block explorers—to read blockchain data (balances, transaction receipts, logs) and submit transactions. The term "RPC" stands for Remote Procedure Call, a protocol that lets a program request a service from another program on a different machine.

Every Ethereum node implements the same JSON-RPC specification, so you can use the same API methods regardless of the client software. Common methods include eth_blockNumber, eth_getBalance, eth_sendRawTransaction, and eth_call. The API is transport-agnostic but typically accessed over HTTP or WebSocket.

How does JSON-RPC work?

JSON-RPC is a lightweight protocol that uses JSON for data encoding. A request contains a method name, parameters, and an ID. The node responds with a result or error. Here's a simple example using curl to get the latest block number:

curl -X POST https://eth.drpc.org \
  -H "Content-Type: application/json" \
  --data '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Response:

{"jsonrpc":"2.0","id":1,"result":"0x134e2a0"}

The result is hex-encoded. To use it in JavaScript with ethers.js:

const { ethers } = require("ethers");
const provider = new ethers.JsonRpcProvider("https://eth.drpc.org");
provider.getBlockNumber().then(console.log);

Types of Ethereum RPC nodes

Full nodes

A full node stores the entire blockchain and validates all blocks. It can serve current state data but prunes historical state older than a certain number of blocks (e.g., 128 blocks for Geth). Full nodes are sufficient for most dApps that need recent data.

Archive nodes

Archive nodes retain all historical state, allowing queries like eth_getBalance at any past block. They require significantly more storage (multiple TB) and are used by block explorers, analytics platforms, and services that need deep history.

Shared vs. dedicated nodes

Shared nodes: Multiple users share the same node infrastructure. Providers rate-limit requests to ensure fairness. Suitable for development, low-traffic apps, and testing.
Dedicated nodes: You get a private node with guaranteed resources. clear rate limitsing from other tenants, better performance consistency, and full control over the client configuration.

How to choose an Ethereum RPC provider

When evaluating providers, compare these criteria:

Criterion	What to check	Why it matters
Throughput	Maximum RPS, burst allowance	Prevents throttling during traffic spikes
Uptime SLA	reliability expectations percentage	Ensures service reliability for production
Latency	Geographic endpoint distribution	Reduces round-trip time for global users
Data retention	Archive vs. full node support	Needed for historical queries
Security	Encryption, request logging	Protects sensitive data and user privacy
Pricing model	Free tier, pay-as-you-go, flat rate	Aligns cost with usage patterns
Testnet availability	Sepolia, Holesky endpoints	Enables safe development and testing

Setting up your own Ethereum RPC node

Running your own node gives you full control but requires technical expertise and infrastructure. Here's a minimal setup using Geth:

Install Geth on a Linux server (recommended: Ubuntu 22.04+).
Start the node with HTTP RPC enabled:

geth --syncmode snap --http --http.addr 0.0.0.0 --http.port 8545 --http.api eth,net,web3

The RPC endpoint will be http://<your-server-ip>:8545.

Important considerations:

Initial sync can take days and requires ~1TB of storage for a full node.
You must keep the node updated and monitor its health.
Security: restrict access via firewall and use TLS if exposed to the internet.

For most teams, using a managed RPC service is more practical. OnFinality offers both shared and dedicated Ethereum RPC nodes with global endpoints, archive support, and flexible pricing. Check our supported RPC networks and RPC pricing for details.

Common pitfalls and troubleshooting

Rate limiting: If you receive HTTP 429 errors, you've exceeded the provider's rate limit. Upgrade to a higher tier or use a dedicated node.
Nonce errors: When sending transactions, ensure the nonce is correct. Use eth_getTransactionCount with the pending block parameter.
Block not found: If querying a recent block, it may not yet be finalized. Use the latest or safe block tag as appropriate.
WebSocket disconnections: For real-time feeds, implement reconnection logic in your client.

Key Takeaways

An Ethereum RPC node is the gateway for applications to interact with the blockchain.
Choose between full and archive nodes based on your data needs.
Shared nodes are cost-effective for low traffic; dedicated nodes offer consistent performance.
Evaluate providers on throughput, latency, uptime, and pricing.
Managed services simplify operations; OnFinality provides reliable Ethereum RPC endpoints for mainnet and testnets.

Frequently Asked Questions

What is the difference between an Ethereum node and an RPC node?
An Ethereum node is the software that runs the blockchain protocol. An RPC node is a node that exposes the JSON-RPC API, allowing external applications to interact with it.

Can I use a free Ethereum RPC node for production?
Free tiers are suitable for development and low-traffic apps. For production, consider a paid plan with guaranteed throughput and uptime.

How do I find the best Ethereum RPC endpoint?
Compare providers based on latency, reliability, and features. Services like OnFinality offer multiple endpoints with automatic failover.

What is an archive node?
An archive node stores the complete history of the Ethereum blockchain, enabling queries for any past state. It requires significant storage.

How do I switch RPC providers?
Update the RPC URL in your application configuration. If using a library like ethers.js, change the provider URL and test thoroughly.

For more details, visit our Ethereum RPC API service or explore all supported networks.

Related resources

Originally published at OnFinality.

Acala Network Guide: RPC Endpoints, Architecture & Developer Tips

Zhuoxin Sun — Mon, 20 Jul 2026 03:04:50 +0000

Acala Network decision checklist

Before integrating with the Acala Network, evaluate the following criteria to ensure your infrastructure aligns with your project's needs.

Criterion	What to check	Why it matters
Network type	Mainnet or testnet (e.g., Acala Mandala)	Testnet is essential for development; mainnet for production.
RPC endpoint reliability	Uptime, rate limits, and latency	Unreliable endpoints cause transaction failures and poor user experience.
EVM compatibility	Solidity support, precompiles	Acala's EVM+ allows Ethereum tooling; verify compatibility with your contracts.
Data archival depth	Full, archive, or pruned node	Archive nodes are needed for historical queries; full nodes suffice for most dApps.
Provider reputation	Documentation, support, SLAs	A responsive provider reduces downtime and troubleshooting effort.
Pricing model	Pay-as-you-go, subscription, or dedicated node	Match cost structure to your traffic patterns and budget.

What is the Acala Network?

Acala Network is a decentralized finance (DeFi) platform built on Polkadot. It functions as a parachain, meaning it leverages Polkadot's shared security and interoperability while maintaining its own execution environment. Acala provides a suite of DeFi primitives including a liquid staking protocol (Homa), a decentralized exchange (DEX), and a cross-chain stablecoin system (Honzon). It is EVM-compatible, allowing developers to deploy Solidity smart contracts with minimal changes.

Key components:

ACA token: The native utility and governance token.
aUSD (now AUSD): A decentralized, multi-collateral stablecoin.
LDOT: Liquid staked DOT, representing staked DOT plus staking rewards.
Euphrates: A unified liquid staking platform.
EVM+: An enhanced Ethereum Virtual Machine with Substrate-native features.

Acala Network architecture

Acala is built using the Substrate framework, which provides flexibility and modularity. It connects to the Polkadot Relay Chain via a parachain slot. The network uses collators to produce blocks and relay them to Polkadot validators for finalization. This design gives Acala high throughput, low fees, and the ability to customize its runtime.

EVM+ and Substrate dual environment

Acala supports both Substrate-native pallets and Ethereum-compatible smart contracts. Developers can write contracts in Solidity and deploy them via MetaMask or Hardhat, while also accessing Substrate-specific features like on-chain governance and custom pallets.

How to connect to the Acala Network

To interact with Acala, you need an RPC endpoint. Below are examples of connecting using common tools.

Using curl

curl -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}' \
  https://acala-rpc.publicnode.com

Using ethers.js

const { ethers } = require("ethers");

const provider = new ethers.providers.JsonRpcProvider(
  "https://acala-rpc.publicnode.com"
);

provider.getBlockNumber().then(console.log);

Using web3.py

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://acala-rpc.publicnode.com"))
print(w3.eth.block_number)

Choosing an RPC provider for Acala

When selecting an RPC provider, consider the following factors:

Reliability: Look for providers with transparent uptime statistics and redundant infrastructure.
Rate limits: Ensure the plan matches your request volume. Free tiers often have strict limits.
Geographic distribution: Low-latency endpoints improve user experience for global audiences.
Support: Access to technical support can be critical during development and incidents.

OnFinality offers RPC endpoints for Acala mainnet and testnet, with flexible pricing options suitable for projects of all sizes. For high-traffic applications, a dedicated node provides isolated resources and consistent performance.

Common pitfalls and troubleshooting

1. Incorrect chain ID

Acala's chain ID is 787. Using the wrong chain ID in MetaMask or other wallets will cause transaction failures.

2. Insufficient gas for EVM transactions

Acala uses a gas model similar to Ethereum. Ensure your account has enough ACA to cover gas costs. You can estimate gas using eth_estimateGas.

3. Block finality delays

Acala blocks are finalized after being included in a Polkadot relay chain block. This may take a few seconds longer than Ethereum. Use eth_getTransactionReceipt to confirm finality.

4. Rate limiting on public endpoints

Public RPC endpoints often have rate limits. For production dApps, consider a private endpoint or dedicated node to avoid throttling.

Key Takeaways

Acala Network is a DeFi parachain on Polkadot with EVM compatibility.
It offers liquid staking, a DEX, and a stablecoin protocol.
Developers can connect using standard Ethereum tools via Acala's EVM+.
Choosing a reliable RPC provider is crucial for dApp performance.
OnFinality provides Acala RPC endpoints and dedicated node solutions.

Frequently Asked Questions

What is the Acala Network RPC URL?

The public RPC URL for Acala mainnet is https://acala-rpc.publicnode.com. For testnet (Mandala), use https://acala-mandala-rpc.publicnode.com.

Is Acala EVM-compatible?

Yes, Acala supports the Ethereum Virtual Machine (EVM+) with additional Substrate features. You can deploy Solidity contracts with minor adjustments.

How do I get ACA tokens for testnet?

Use the Acala faucet available on their official website or community channels. Testnet tokens have no real value.

Can I run my own Acala node?

Yes, you can run a full node using Substrate. However, for production dApps, using a managed RPC provider like OnFinality saves operational overhead.

What is the difference between Acala and Karura?

Karura is the sister network of Acala on Kusama, serving as a canary network for experimental features. Acala is the mainnet on Polkadot.

Next steps

Explore the Acala documentation for detailed integration guides.
Test your dApp on Acala Mandala testnet using a reliable RPC endpoint.
Compare RPC providers on OnFinality's network page to find the best fit for your project.
Consider a dedicated node for high-throughput applications requiring consistent performance.

Related resources

Originally published at OnFinality.

Shared vs Dedicated Solana RPC: Cost Differences Explained

Zhuoxin Sun — Mon, 20 Jul 2026 03:04:14 +0000

When building on Solana, one of the first infrastructure decisions you face is whether to use a shared RPC endpoint or provision a dedicated node. The cost difference between these two options goes beyond the monthly bill—it affects performance predictability, scaling strategy, and operational overhead. This article breaks down the pricing models, hidden costs, and decision criteria so you can choose the right fit for your project.

Solana RPC cost decision checklist

Before diving into the numbers, use this checklist to evaluate your situation:

[ ] Estimate your monthly request volume (getCurrentBlockheight, getProgramAccounts, sendTransaction, etc.)
[ ] Identify peak traffic patterns and whether they are predictable
[ ] Determine latency sensitivity: does a 50ms jitter affect your user experience?
[ ] Check if you need custom Solana configuration (e.g., snapshot settings, Geyser plugins)
[ ] Review provider pricing pages for shared tiers and dedicated node costs
[ ] Consider data transfer costs (egress) if you stream large amounts of data
[ ] Evaluate whether you need devnet/testnet access with the same provider
[ ] Plan for scaling: can you start shared and migrate to dedicated later?

How shared Solana RPC pricing works

Shared RPC nodes are multi-tenant infrastructure. The provider runs a cluster of Solana nodes and distributes traffic among all customers. Pricing is typically usage-based:

Pay-as-you-go credits: You buy a pool of credits (e.g., 1 credit = 1 request) and consume them monthly.
Tiered subscriptions: Fixed monthly fee for a capped request volume (e.g., 10M requests/month).
Overage charges: Additional cost per extra request beyond the tier.

For example, a shared plan might cost $49/month for 10M requests, while a higher tier at $499/month offers 100M requests. The unit cost per request decreases as you move up tiers, but you still share the underlying node with other users.

Hidden costs of shared nodes:

Rate limiting under heavy traffic from other tenants
Variable latency (jitter) during peak hours
No control over node configuration or software version
Potential IP blacklisting if another tenant misbehaves

How dedicated Solana RPC pricing works

Dedicated Solana RPC nodes give you exclusive access to one or more full nodes. Pricing is typically a flat monthly fee that covers:

Hardware rental: Cloud or bare-metal server costs
Node management: Monitoring, patching, and uptime maintenance
Data transfer: Often included up to a certain limit
Support: Faster response times and dedicated engineering contacts

Dedicated node prices vary widely based on hardware specs (CPU, RAM, NVMe storage), network bandwidth, and geographic location. A basic dedicated Solana RPC node might start around $300–$500/month, while high-availability clusters with archive data can exceed $2,000/month.

What you pay for:

Resource isolation: no noisy neighbors
Predictable latency and throughput
Custom configuration (e.g., enable Geyser plugins, adjust snapshot intervals)
Higher rate limits (often unlimited internal requests)
Ability to run validator or RPC with custom flags

Cost comparison table

Criterion	Shared RPC	Dedicated RPC
Pricing model	Usage-based (credits/tiers)	Flat monthly fee
Typical monthly cost (low usage)	$0–$100	$300–$500+
Typical monthly cost (high usage)	$500–$2,000+	$500–$2,000+
Cost predictability	Variable with traffic	Fixed
Rate limits	Yes, per tier	No (or very high)
Latency jitter	Possible during peaks	Minimal
Configuration control	None	Full
Data transfer costs	Often metered	Often included
Scaling cost	Step-function (next tier)	Linear (add more nodes)

When shared RPC is more cost-effective

Shared RPC is usually the better financial choice when:

You are in development or staging: Low request volumes make shared plans very cheap or free.
Your traffic is low or sporadic: Pay-as-you-go avoids paying for idle capacity.
You don't need custom configuration: Standard endpoints work fine for most dApps.
You want to test the waters: Start with a shared plan and upgrade when you hit limits.

Example: A new DeFi dashboard serving 500 daily active users might generate 5M requests/month. A shared plan at $49/month covers this easily, while a dedicated node would be overkill.

When dedicated RPC is worth the cost

Dedicated nodes become cost-justified when:

Your traffic is high and predictable: A dedicated node's flat fee may be lower than shared overage charges.
Latency is critical: Trading bots, arbitrage, and real-time gaming need consistent sub-100ms responses.
You need custom Solana features: Geyser plugins, custom snapshot policies, or specific validator flags.
You run high-throughput applications: NFT minting, DEX aggregators, or data indexing services.
You require SLA-backed support: Production outages cost more than the node itself.

Example: A Solana NFT marketplace processing 50M requests/month might pay $1,750/month on a shared plan (25TB tier). A dedicated node with similar capacity could cost $1,500/month with better performance and clear rate limits.

How to estimate your costs

To compare shared vs dedicated costs for your use case, follow these steps:

Measure your current usage: Use a provider's dashboard or log your RPC calls for a week.
Project growth: Estimate request volume for the next 3–6 months.
Get quotes: Check shared pricing tiers and dedicated node pricing from providers like OnFinality.
Include hidden costs: Factor in engineering time for managing your own node vs. using a managed service.
Test both: Many providers offer trials or money-back guarantees. Run load tests on shared and dedicated endpoints.

Example: Using Solana RPC with curl

Test a shared endpoint vs. a dedicated endpoint to see latency differences:

# Shared endpoint (replace with your provider's URL)
curl -X POST https://api.mainnet-beta.solana.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getBlockHeight"}'

# Dedicated endpoint (replace with your dedicated node URL)
curl -X POST https://your-dedicated-node.example.com \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"getBlockHeight"}'

Compare the response times. A difference of 20–50ms is normal; larger gaps indicate shared node congestion.

Common pitfalls when comparing costs

Ignoring egress costs: Some providers charge for data leaving their network. If you stream large account updates, this can add up.
Overlooking minimum commitments: Dedicated nodes often require a 1-month or 3-month minimum.
Assuming shared is always cheaper: At very high volumes, dedicated can be more cost-effective per request.
Forgetting about devnet/testnet: If you need non-mainnet endpoints, check if they are included or cost extra.
Not accounting for redundancy: A single dedicated node is a single point of failure. High-availability setups cost more.

Key Takeaways

Shared Solana RPC is cost-efficient for low-to-medium traffic and development environments.
Dedicated Solana RPC provides predictable performance and is cost-competitive at high volumes.
The break-even point varies by provider, but typically falls between 50M–100M requests per month.
Always measure your actual usage before committing to a plan.
Consider total cost of ownership, including engineering time and redundancy.

Frequently Asked Questions

Q: Can I start with a shared plan and migrate to dedicated later?
Yes, most providers allow seamless upgrades. OnFinality, for example, lets you switch between shared and dedicated without downtime.

Q: Do dedicated nodes include Solana devnet access?
Some providers bundle devnet access with dedicated plans; others charge separately. Check the Solana network page for details.

Q: How do I know if I'm hitting rate limits on a shared plan?
Monitor HTTP 429 responses. Many providers include rate limit headers in responses. Log these to identify patterns.

Q: Are there any hidden fees with dedicated nodes?
Common extras include data transfer overages, additional IP addresses, and managed backup services. Always read the fine print.

Q: What about self-hosting a Solana node?
Self-hosting requires hardware, bandwidth, and ongoing maintenance. The monthly cost can be lower than a managed dedicated node, but the operational overhead is significant. For most teams, a managed service is more cost-effective.

For more details on pricing and plans, visit the RPC pricing page and explore supported RPC networks.

Related resources

Originally published at OnFinality.

Aleph Zero RPC Endpoints & Provider Guide | OnFinality

Zhuoxin Sun — Fri, 17 Jul 2026 04:14:54 +0000

Summary

Aleph Zero is a layer-1 blockchain that combines a Substrate-based core with an EVM-compatible layer, offering privacy, scalability, and instant finality. Developers building on Aleph Zero need reliable RPC endpoints to interact with the network—whether querying on-chain data, submitting transactions, or deploying smart contracts. This article provides the official RPC endpoints for Aleph Zero mainnet and testnet, configuration examples for common tools, and a structured checklist to help you choose an RPC provider that meets your performance and budget requirements.

Aleph Zero RPC Decision Checklist

Before selecting an RPC provider for Aleph Zero, evaluate the following criteria to ensure your infrastructure aligns with your project's needs.

Criterion	What to check	Why it matters
Network coverage	Does the provider support both mainnet and testnet?	You need testnet for development and mainnet for production.
Endpoint type	Are HTTPS and WSS endpoints available?	WSS is required for real-time subscriptions (e.g., event listeners).
Rate limits	What is the requests-per-second (RPS) limit?	High-throughput dApps need higher RPS to avoid throttling.
Latency	Where are the provider's nodes located?	Lower geographic distance reduces round-trip time.
Pricing model	Is it pay-as-you-go, subscription, or dedicated?	Match the model to your expected call volume and budget.
Reliability	Does the provider publish uptime SLAs or status pages?	Downtime can break your application.
Developer support	Are there docs, SDKs, or community channels?	Quick troubleshooting saves development time.
Additional features	Does the provider offer archive data, trace APIs, or analytics?	Archive nodes are needed for historical queries.

Aleph Zero Network Overview

Aleph Zero is designed for high throughput and low fees, with a native privacy layer called Liminal. It has two execution environments:

Substrate layer: The core chain using Substrate framework, with its own RPC interface.
EVM layer: A fully EVM-compatible sidechain that allows developers to deploy Solidity contracts and use Ethereum tooling.

Most developers interact with the EVM layer for dApps, while the Substrate layer is used for staking, governance, and native asset transfers. RPC endpoints differ for each layer.

Aleph Zero RPC Endpoints

Below are the official public RPC endpoints for Aleph Zero. Note that public endpoints often have rate limits and may not be suitable for production workloads.

Mainnet

EVM Layer:
- HTTPS: https://rpc.alephzero.raas.gelato.cloud
- WSS: wss://ws.alephzero.raas.gelato.cloud
Substrate Layer:
- HTTPS: https://rpc.alephzero.substrate.network (example, check official docs)
- WSS: wss://rpc.alephzero.substrate.network

Testnet (Sepolia-based)

EVM Layer:
- HTTPS: https://rpc.alephzero-testnet.gelato.digital
- WSS: wss://ws.alephzero-testnet.gelato.digital
Substrate Layer:
- HTTPS: https://rpc.alephzero-testnet.substrate.network
- WSS: wss://rpc.alephzero-testnet.substrate.network

Chain IDs:

Mainnet EVM: 41455
Testnet EVM: 2039

Connecting to Aleph Zero RPC

Using curl (JSON-RPC)

curl -s -X POST https://rpc.alephzero.raas.gelato.cloud \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

Using ethers.js (JavaScript)

const { ethers } = require("ethers");

const provider = new ethers.JsonRpcProvider("https://rpc.alephzero.raas.gelato.cloud");

async function getBlockNumber() {
  const blockNumber = await provider.getBlockNumber();
  console.log("Current block number:", blockNumber);
}

getBlockNumber();

Using web3.py (Python)

from web3 import Web3

w3 = Web3(Web3.HTTPProvider("https://rpc.alephzero.raas.gelato.cloud"))
print(w3.eth.block_number)

Adding to MetaMask

Open MetaMask and click the network dropdown.
Click "Add Network" and fill in:
- Network Name: Aleph Zero Mainnet
- RPC URL: https://rpc.alephzero.raas.gelato.cloud
- Chain ID: 41455
- Currency Symbol: AZERO
- Block Explorer URL: https://evm-explorer.alephzero.org
Click "Save".

Choosing an RPC Provider for Aleph Zero

Public endpoints are convenient for development but often insufficient for production due to rate limits and potential downtime. When evaluating RPC providers, consider the following factors:

1. Network Support

Ensure the provider supports both mainnet and testnet for Aleph Zero. Some providers may only offer one or the other.

2. Performance and Reliability

Look for providers with geographically distributed nodes to reduce latency. Check if they have a status page or SLA. For example, OnFinality offers Aleph Zero endpoints with transparent performance metrics.

3. Pricing

Compare pricing models:

Free tier: Good for prototyping but limited.
Pay-as-you-go: Flexible for variable usage.
Dedicated nodes: Best for high-throughput or latency-sensitive applications.

OnFinality provides competitive pricing for Aleph Zero RPC access. See our RPC pricing page for details.

4. Additional Features

Some providers offer archive nodes, trace APIs, or WebSocket subscriptions. If your dApp requires historical data or real-time events, prioritize providers that support these features.

Common Pitfalls and Troubleshooting

Rate Limiting

Public endpoints often throttle requests. If you encounter "429 Too Many Requests", consider upgrading to a paid plan or using a dedicated node.

WebSocket Disconnections

For WSS connections, ensure your client handles reconnection gracefully. Use libraries that support automatic reconnection.

Wrong Chain ID

Double-check the chain ID when adding the network to wallets. Using the wrong chain ID can cause transaction failures.

Testnet Faucet

To get testnet AZERO, use the faucet at drpc.org/faucet/alephzero.

Key Takeaways

Aleph Zero has two layers: Substrate and EVM, each with separate RPC endpoints.
Public endpoints are suitable for development but not for production.
When choosing an RPC provider, evaluate network coverage, latency, pricing, and additional features.
OnFinality supports Aleph Zero RPC with reliable infrastructure and transparent pricing. Check our supported networks for availability.
Always test with testnet endpoints before deploying to mainnet.

Frequently Asked Questions

What is the Aleph Zero RPC URL for mainnet?

The mainnet EVM RPC URL is https://rpc.alephzero.raas.gelato.cloud. For the Substrate layer, refer to the official documentation.

How do I get testnet AZERO?

Use the PoW faucet at drpc.org/faucet/alephzero or request tokens via the Aleph Zero Discord.

Can I use Aleph Zero RPC with MetaMask?

Yes. Add the network with RPC URL https://rpc.alephzero.raas.gelato.cloud and Chain ID 41455 (mainnet) or 2039 (testnet).

What is the difference between Substrate and EVM RPC?

The Substrate RPC exposes chain-specific methods (e.g., staking, governance), while the EVM RPC is compatible with Ethereum JSON-RPC for smart contract interactions.

Does OnFinality support Aleph Zero?

Yes, OnFinality provides Aleph Zero RPC endpoints. Visit our networks page for details.

FAQ

What is the Aleph Zero RPC URL for mainnet?

The mainnet EVM RPC URL is https://rpc.alephzero.raas.gelato.cloud. For the Substrate layer, refer to the official documentation.

How do I get testnet AZERO?

Use the PoW faucet at drpc.org/faucet/alephzero or request tokens via the Aleph Zero Discord.

Can I use Aleph Zero RPC with MetaMask?

Yes. Add the network with RPC URL https://rpc.alephzero.raas.gelato.cloud and Chain ID 41455 (mainnet) or 2039 (testnet).

What is the difference between Substrate and EVM RPC?

The Substrate RPC exposes chain-specific methods (e.g., staking, governance), while the EVM RPC is compatible with Ethereum JSON-RPC for smart contract interactions.

Does OnFinality support Aleph Zero?

Yes, OnFinality provides Aleph Zero RPC endpoints. Visit our networks page for details.

Related resources

Originally published at OnFinality.

Starknet RPC Guide: Endpoints, Providers, and Best Practices

Zhuoxin Sun — Fri, 17 Jul 2026 04:14:18 +0000

Summary

Starknet is a Layer 2 ZK-rollup on Ethereum that uses STARK validity proofs for scalable computation. To interact with Starknet, developers use JSON-RPC endpoints to query state, send transactions, and deploy contracts. This guide explains what Starknet RPC is, lists available endpoints, and provides a decision framework for selecting the right provider for your project.

Starknet RPC Decision Checklist

Before integrating a Starknet RPC provider, consider these criteria:

Criterion	What to check	Why it matters
Network support	Mainnet, Sepolia testnet	Ensure the provider supports the networks you need for development and production.
Rate limits	Requests per second (RPS) and daily cap	High-traffic dApps require higher limits to avoid throttling.
Reliability	Uptime history, redundancy	Downtime can disrupt your application; choose providers with proven reliability.
Latency	Geographic distribution of nodes	Lower latency improves user experience, especially for time-sensitive operations.
Archive data	Access to historical state	Needed for analytics, explorers, and certain dApp features.
Pricing model	Free tier, pay-as-you-go, or dedicated node	Match the pricing to your usage pattern and budget.
API compatibility	JSON-RPC methods supported	Verify that the provider supports the methods your application requires.
Security	HTTPS, WebSocket support, privacy features	Protect data in transit and consider privacy-focused relays if needed.

What is Starknet RPC?

Starknet RPC (Remote Procedure Call) is the standard interface for communicating with the Starknet network. It allows wallets, dApps, and backend services to submit transactions, query account balances, read contract state, and interact with smart contracts. The RPC protocol follows the JSON-RPC 2.0 specification, with Starknet-specific methods defined in the Starknet API specification.

Starknet uses a unique account abstraction model where every account is a smart contract. This means RPC interactions often involve deploying and invoking contracts through the starknet_call and starknet_sendTransaction methods.

Starknet RPC Endpoints

Starknet provides both public and private RPC endpoints. Public endpoints are free but often have rate limits and may not be suitable for production. Private endpoints offer higher limits, dedicated resources, and better reliability.

Public Endpoints

https://public.1rpc.io/starknet (1RPC)
https://starknet-rpc.publicnode.com (Allnodes)
https://starknet.drpc.org (dRPC)
https://rpc.starknet.lava.build (Lava)
https://starknet.api.onfinality.io/public (OnFinality)

Private Endpoints (require API key)

https://starknet-mainnet.g.alchemy.com/v2/<api-key> (Alchemy)
https://starknet-mainnet.infura.io/v3/<api-key> (Infura)
https://starknet.api.onfinality.io/v1/<api-key> (OnFinality)

Testnet (Sepolia)

https://starknet-sepolia-rpc.publicnode.com (Allnodes)
https://rpc.starknet-testnet.lava.build (Lava)
https://starknet-sepolia.api.onfinality.io/public (OnFinality)

How to Use Starknet RPC

To connect to Starknet, you need an RPC URL and a JSON-RPC client. Below is an example using curl to query the latest block number.

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

For JavaScript (using ethers or starknet.js):

import { Provider } from 'starknet';

const provider = new Provider({
  rpc: { nodeUrl: 'https://starknet.api.onfinality.io/public' }
});

const blockNumber = await provider.getBlockNumber();
console.log(blockNumber);

Choosing a Starknet RPC Provider

When selecting a provider, consider the following factors:

Network Support: Ensure the provider supports Starknet mainnet and testnet (Sepolia).
Rate Limits: Free tiers typically allow 10-100 requests per second. For high-traffic dApps, look for paid plans or dedicated nodes.
Reliability: Check uptime history and whether the provider offers redundancy across multiple data centers.
Latency: Providers with global node distribution can offer lower latency.
Archive Data: Some providers offer access to historical state, which is essential for analytics and explorers.
Pricing: Compare free tiers, pay-as-you-go, and dedicated node pricing. OnFinality offers transparent pricing for Starknet RPC.

For a detailed comparison of RPC providers, see our guide on choosing an RPC provider.

Common Pitfalls and Troubleshooting

1. Rate Limiting

Public endpoints often have strict rate limits. If you receive HTTP 429 errors, consider upgrading to a private endpoint or using a dedicated node.

2. Incorrect Network ID

Starknet mainnet chain ID is 0x534e5f4d41494e (SN_MAIN). Sepolia testnet chain ID is 0x534e5f5345504f4c4941 (SN_SEPOLIA). Double-check your configuration.

3. Unsupported Methods

Not all providers support every JSON-RPC method. For example, starknet_getStateUpdate may be unavailable on some public endpoints. Check the provider's documentation.

4. WebSocket Connections

For real-time updates, use WebSocket endpoints. Example:

wss://starknet.api.onfinality.io/public/ws

5. Transaction Failures

Starknet transactions can fail due to insufficient fees, invalid nonce, or contract errors. Use starknet_getTransactionReceipt to debug.

Starknet RPC vs. Other Networks

Starknet's RPC differs from Ethereum's in several ways:

Account abstraction: Every account is a contract; transactions are invoked via starknet_addInvokeTransaction.
Fee model: Starknet uses a separate fee token (STRK) and a unique fee calculation.
Block time: Blocks are produced every 20-60 seconds, faster than Ethereum.

Key Takeaways

Starknet RPC is essential for interacting with the Starknet network.
Choose a provider based on network support, rate limits, reliability, and pricing.
Public endpoints are suitable for development; private endpoints are recommended for production.
Always test with a testnet before deploying to mainnet.
OnFinality provides scalable Starknet RPC endpoints with transparent pricing. Check our supported networks and pricing for more details.

FAQ

What is the Starknet RPC URL?

Public Starknet mainnet RPC URLs include https://starknet.api.onfinality.io/public, https://public.1rpc.io/starknet, and https://starknet.drpc.org. Private endpoints require an API key.

How do I get a Starknet RPC endpoint?

You can use a public endpoint for free or sign up with a provider like OnFinality to get a private endpoint with higher rate limits and dedicated support.

Is Starknet RPC compatible with MetaMask?

No, MetaMask only supports EVM-compatible chains. Starknet uses a different virtual machine (Cairo VM), so you need a Starknet-compatible wallet like Argent X or Braavos.

What is the difference between Starknet mainnet and Sepolia testnet?

Mainnet is the production network with real assets. Sepolia is a testnet for development and testing. Both have separate RPC endpoints.

How do I choose between public and private RPC?

Use public endpoints for prototyping and low-traffic applications. For production dApps with high traffic, choose a private endpoint or dedicated node to ensure reliability and performance.

FAQ

What is the Starknet RPC URL?

Public Starknet mainnet RPC URLs include https://starknet.api.onfinality.io/public, https://public.1rpc.io/starknet, and https://starknet.drpc.org. Private endpoints require an API key.

How do I get a Starknet RPC endpoint?

You can use a public endpoint for free or sign up with a provider like OnFinality to get a private endpoint with higher rate limits and dedicated support.

Is Starknet RPC compatible with MetaMask?

No, MetaMask only supports EVM-compatible chains. Starknet uses a different virtual machine (Cairo VM), so you need a Starknet-compatible wallet like Argent X or Braavos.

What is the difference between Starknet mainnet and Sepolia testnet?

Mainnet is the production network with real assets. Sepolia is a testnet for development and testing. Both have separate RPC endpoints.

How do I choose between public and private RPC?

Use public endpoints for prototyping and low-traffic applications. For production dApps with high traffic, choose a private endpoint or dedicated node to ensure reliability and performance.

Related resources

Originally published at OnFinality.