Skip to content
Developers7 min read

Polygon RPC URL Guide: Chain ID 137, Wallets, Code and Archive Access

Connecting to Polygon PoS takes a URL, chain ID 137 and the POL symbol. How to get a keyed Polygon RPC URL, add it to a wallet, use it in code, stay inside the limits, and read historical state.

Sourav Mishra · OrbitFlare
Polygon RPC URL Guide: Chain ID 137, Wallets, Code and Archive Access

What is a Polygon RPC URL? This is the gateway your wallet, dApp, and script use to fetch information from Polygon PoS and execute transactions on Polygon. The key components to enable a successful connection are: the Polygon RPC URL, chain ID (137 for mainnet, 80002 for Amoy testnet), and the gas token, POL. For OrbitFlare, the Polygon RPC URL is https://ams.poly.orbitflare.com?api_key=YOUR_LICENSE_KEY, served from Amsterdam. Plans start from $0/mo for 25 RPS.

Polygon network details

Field Mainnet Amoy testnet
Chain ID 137 80002
Gas token POL POL
Parent chain Ethereum Sepolia
Explorer https://polygonscan.com https://amoy.polygonscan.com

We took these values from Polygon's network reference on 9 November 2026. An incorrect chain ID is the typical reason a wallet won't add the network, or signs transactions the network then rejects.

Getting a Polygon RPC URL

Polygon and community nodes offer endpoints available freely to the public. No sign-up is required for these nodes, however, everybody shares these nodes, they are IP-rate limited, and the first ones that get affected during congestion times. These endpoints work well for testing but are not recommended as the foundation for user-driven applications.

With a provider, the URL carries your key and a limit you know ahead of time. On OrbitFlare, every Polygon plan comes with JSON-RPC, WebSockets, gRPC, and archive data access, and there are no limitations on monthly credits:

Plan Price Requests per second
Free $0/mo 25 RPS
Starter $49/mo 100 RPS
Growth $149/mo 300 RPS
Pro $299/mo 600 RPS
Performance $499/mo 1,000 RPS

License keys are under Licenses in the dashboard, and the key is sent the same way as on our other chains (see the authentication docs). One key covers your Solana and Robinhood Chain endpoints too. Treat the full URL as a secret kept server-side, since whoever holds it can drain your request budget.

Adding Polygon to a wallet

In any wallet based on the Ethereum virtual machine (MetaMask is an example), create a network using the RPC, 137 for the Chain ID, the ticker POL, and the Polygonscan explorer. In the case of Amoy, you'll use 80002 for the Chain ID and the Amoy Explorer. If Polygon is already set up with a public RPC link, simply edit that network and change the RPC; no other modification is required. You may still see MATIC, its old ticker, in some wallets and older pages.

Using the Polygon RPC URL in code

The Polygon PoS is Ethereum JSON-RPC compliant, hence ethers, viem, web3.js, web3.py, alloy, and go-ethereum are used as is. Build the client from the HTTPS URL, and use the WebSocket URL (wss://ams.poly.orbitflare.com?api_key=YOUR_LICENSE_KEY) for subscriptions:

curl -X POST "https://ams.poly.orbitflare.com?api_key=$ORBITFLARE_LICENSE_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'

A mainnet endpoint responds with 0x89, which equals 137 in hex.

These three practices help you stay within your quota:

  1. Subscribe rather than poll. eth_subscribe coupled with newHeads or logs solves almost all polling loops.
  2. Page your log queries. Wide eth_getLogs ranges are the most frequent source of errors.
  3. Estimate fees from the chain itself. Use eth_feeHistory or eth_gasPrice and not a hard-coded gas price.

Free and paid limits

Control Free Paid
Batch size 1 item 100 items
eth_getLogs block range 150 blocks 10,000 blocks
debug_* and trace_* methods Blocked Allowed
WebSocket connections 1 From 10
Subscriptions per connection 5 25

HTTP calls and WebSocket traffic draw on one shared rate limit, so heavy subscriptions leave less room for HTTP calls on that key. The three errors you are most likely to see are -32429 – Request Rate limit, -32005 – Batch/concurrency/subscription limit and -32602 -eth_getLogs Range Limit.

Archive and trace methods

EVM nodes maintain state data in the most recent blocks only. In order to fetch the balance or the content of the contract’s storage in an older block or executing eth_call using an older state data, an archive node is required. Indexing, analytics and history rebuilding all rely on it, and plenty of providers charge extra for it. Every OrbitFlare Polygon plan contains archival state data. On Free, debug and trace calls are blocked; paid plans allow them.

Mainnet, Amoy and older tutorials

Polygon's network reference lists Amoy, anchored to Sepolia, as its testnet. Old tutorials still point at the Mumbai testnet; start new work on Amoy instead, funded with test POL from Polygon's faucet.

Coming from Solana

Solana Polygon PoS
API Solana JSON-RPC (getAccountInfo, sendTransaction) Ethereum JSON-RPC (eth_call, eth_sendRawTransaction)
Model Accounts and programs Addresses and contracts
Fees Base fee per signature plus a priority fee in compute units Gas, EIP-1559 base fee plus a priority tip
Streaming WebSockets, Yellowstone gRPC, shreds WebSockets (eth_subscribe); gRPC on OrbitFlare plans
History Archive for old transactions Archive node for old state and storage

The mindset change takes us from accounts to contracts and from computation units to gas. The tools needed for the EVM are well-evolved and interchangeable, making your choice of provider depend on their limitations, geographical location, and archive capabilities. Regarding Solana, begin with what JSON-RPC is on Solana.

When to move up a plan

  • -32429 or -32005 appear under standard operations.
  • You require batching, extensive eth_getLogs, or debug and trace methods.
  • Your app holds more than a few WebSocket subscriptions open.
  • Your requests remain above hundreds of requests per second for considerable periods of time. At that point a dedicated Polygon node on separate hardware, priced per deployment, deserves a quote.

Shared Polygon plans operate out of Amsterdam; thus, the roundtrip latency from your server location will play a role. Should your application not be hosted close to it, you could use the VPS in Amsterdam from our sister brand OrbitServers to get close to your endpoint.

Compare the plans on the Polygon RPC page or view sample codes at the Polygon docs.

Frequently asked questions

What is the Polygon mainnet RPC URL?
There is no single official URL. Polygon and community projects provide public URLs, while providers issue keyed ones. OrbitFlare's keyed URL is `https://ams.poly.orbitflare.com?api_key=YOUR_LICENSE_KEY`, served from Amsterdam. Whichever one you choose, set chain ID 137 and POL as the gas token alongside it.
What is the Polygon chain ID?
Polygon PoS Mainnet has the chain ID 137 whereas the Amoy Testnet is 80002. The Amoy Testnet chain comes from Sepolia as its parent. Polygon zkEVM is another independent network with its own chain ID, so confirm your target network before you configure a wallet.
Is MATIC the same as POL?
Polygon's network reference now names POL as the gas token; MATIC is the older name. Some cryptocurrency wallets and web pages might show the older alias of this cryptocurrency. Whatever symbol you type into a wallet is just a label, so balances and the chain stay the same.
Is there a free Polygon RPC?
Absolutely. There’s no signup for public endpoints, yet there is sharing and ratelimiting. The Free plan by OrbitFlare costs $0/mo for 25 RPS and includes WebSockets, gRPC and archival data; batching and debug methods unlock on paid plans.
Do I need an archive node for Polygon?
Only for historical state: balances, storage or `eth_call` at old blocks, and long-range `eth_getLogs` queries. Wallets and apps that read live state don't need one; indexers and analytics services usually do. All of our OrbitFlare Polygon plans include archival data.

About the author

Sourav Mishra

Solutions Engineer · OrbitFlare

Sourav Mishra help build low-latency Solana infrastructure at OrbitFlare — shred streaming, gRPC pipelines, and eBPF-powered networking, mostly in Rust. He writes the kind of deep dives he wishes existed when he started: what a shred actually is, why Solana's VM shares a lineage with the packet filter in your kernel, and how to get transaction data out of the network before everyone else does.

More articles by Sourav Mishra
Thanks for reading.Back to all articles

Code. Build. Stream. Without Limits.

Build something that moves.

Choose your infrastructure. We’ll help you find the right setup.

A useful starting point

Edit the brief, then copy it and open your assistant. Paste it into a new chat to get started.

Official sources included. You choose when to send.