OnFinality
新用户订阅 RPC,首月享 6.5 折优惠查看优惠
RPC Assistant

How do I check Polygon RPC status and keep RPC healthy?

摘要

Polygon RPC status is best understood as the health of the RPC layer your app depends on, not a single global metric. A public endpoint can look fine while your requests fail because of rate limiting, a stale head, or a missing archive/trace method. This page shows how to confirm the chain is producing blocks, how to probe your own endpoint, and how to tell whether the problem is the network or your provider. It also covers when a shared public endpoint is enough and when a dedicated Polygon node or managed RPC API removes the guesswork.

When developers search for "Polygon RPC status," they usually want one of three things: confirmation that the Polygon network itself is producing blocks, a way to check whether their own RPC endpoint is healthy, or a quick answer to "why are my Polygon calls failing right now?" This page answers all three, then helps you decide whether to keep using a shared endpoint or move to a managed RPC API or a dedicated Polygon node.

Diagnose first: is it the network or your endpoint?

Before you change providers or restart anything, separate network-level problems from endpoint-level problems. Polygon mainnet (chain ID 137) is a busy network, and most "RPC status" complaints trace back to the endpoint, not the chain.

SymptomLikely layerFirst check
eth_blockNumber returns but barely changesNetwork congestion or your node is behindCompare against a block explorer
Requests time out or return 429Endpoint rate limitingYour provider's plan and request pattern
eth_getLogs fails on old rangesArchive/history limitsWhether the endpoint is archive-capable
Some methods work, others return "method not found"Method supportProvider's supported API surface
Everything fails at onceNetwork or DNS/connectivityA second endpoint and a raw curl

A fast way to confirm the chain is alive is to read the latest block number from two independent endpoints. If both agree and the number is advancing, the network is fine and the issue is your endpoint or your client.

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

Run it twice a few seconds apart. A rising hex block number means Polygon is producing blocks. A static number, a timeout, or a JSON-RPC error points at the endpoint.

What "RPC status" actually measures

There is no single global Polygon RPC status number. Health is a combination of signals, and different workloads care about different ones.

  • Head freshness — how far the endpoint's latest block is behind the chain tip. A few blocks of lag is normal; hundreds means the node is struggling.
  • Block production — whether new blocks keep arriving. This is a network property, not something an RPC provider controls.
  • Availability — the share of requests that return a valid response instead of a timeout or 5xx.
  • Method coverage — whether archive, trace, or log queries are supported for the ranges you need.
  • Latency — round-trip time for common calls like eth_call and eth_getBalance.
  • Rate limits — how many requests per second your key or IP is allowed before throttling.

When people say "Polygon RPC is down," they usually mean one of these degraded, not that the chain stopped. Naming the specific signal makes the fix obvious.

Probe your endpoint like a monitoring system

A one-off curl tells you the endpoint is reachable right now. Production teams need a repeatable probe. The pattern below checks head freshness and latency together, which is what you actually alert on.

// health-probe.mjs
const ENDPOINT = process.env.POLYGON_RPC_URL; // e.g. your OnFinality endpoint

async function rpc(method, params = []) {
  const started = Date.now();
  const res = await fetch(ENDPOINT, {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ jsonrpc: "2.0", id: 1, method, params }),
  });
  const json = await res.json();
  return { result: json.result, error: json.error, ms: Date.now() - started };
}

const head = await rpc("eth_blockNumber");
console.log("head:", parseInt(head.result, 16), "latency_ms:", head.ms);

const chainId = await rpc("eth_chainId");
console.log("chainId:", parseInt(chainId.result, 16)); // expect 137

Run this on a schedule and store the results. You want to know your endpoint's normal head lag and latency so you can spot the moment it drifts. Alert on trends, not single failures.

Chain settings at a glance

If you are wiring Polygon into a wallet, a backend, or a new environment, use the canonical values. Wrong chain IDs and stale RPC URLs are a frequent cause of "status" confusion.

SettingPolygon mainnetPolygon Amoy testnet
Chain ID13780002
Chain namePolygon MainnetAmoy
Native currencyPOL (18 decimals)POL (18 decimals)
Explorerpolygonscan.comamoy.polygonscan.com
OnFinality public RPChttps://polygon.api.onfinality.io/publichttps://polygon-amoy.api.onfinality.io/public
TransportsHTTP, WebSocketHTTP

For a wallet or client config, the shape looks like this:

{
  "chainId": "0x89",
  "chainName": "Polygon Mainnet",
  "nativeCurrency": { "name": "POL", "symbol": "POL", "decimals": 18 },
  "rpcUrls": ["https://polygon.api.onfinality.io/public"],
  "blockExplorerUrls": ["https://polygonscan.com"]
}

Note that 0x89 is 137 in hex. If a tool shows the wrong chain ID, transactions can be signed for the wrong network even though the RPC endpoint responds normally.

Reading the errors behind a "down" status

Most Polygon RPC failures map to a small set of causes. Match the message to the fix before you escalate.

  • HTTP 429 / "rate limit exceeded" — you are sending more requests than the endpoint allows. Batch calls, cache reads, or move to a plan with higher throughput. See RPC pricing for capacity options.
  • execution timeout or connection reset on eth_getLogs — the block range is too wide or the endpoint is not archive-capable. Narrow the range and paginate.
  • method not found — the endpoint does not expose that method (common with trace or debug calls). Confirm the provider's supported API surface.
  • Stale head / old eth_blockNumber — the node is behind. Fail over to a second endpoint and investigate.
  • nonce too low or replacement transaction underpriced — this is a transaction-level issue, not an RPC outage. Check your nonce handling.
  • TLS or DNS errors — local network or certificate problem, not Polygon. Test with curl -v.

If your app depends on WebSocket subscriptions, remember that eth_subscribe needs a WS-capable endpoint. A healthy HTTP endpoint does not guarantee WS works.

When a shared endpoint is enough, and when it is not

Public and shared endpoints are fine for development, scripts, and low-volume reads. They become a liability when you need predictable throughput, archive history, trace data, or WebSocket streams under load.

WorkloadShared public RPCManaged RPC APIDedicated Polygon node
Prototyping, tutorialsGood fitOptionalOverkill
Production dApp reads/writesRisky under burstsGood fitGood fit
Indexers, eth_getLogs at scaleUsually limitedGood fit with archiveBest fit
Trace/debug toolingOften unsupportedCheck method supportBest fit
Trading or latency-sensitive pathsNot idealGood fitBest fit
Strict isolation and custom configNoPartialYes

OnFinality offers both a managed RPC API service and dedicated nodes for Polygon, so you can start shared and move to isolated capacity as your workload grows. The right choice depends on your request profile, not on a single status number.

A practical failover setup

Even a healthy endpoint can degrade. A simple failover pattern keeps your app online while you investigate.

const ENDPOINTS = [
  process.env.POLYGON_RPC_PRIMARY,
  process.env.POLYGON_RPC_SECONDARY,
];

async function sendWithFailover(payload) {
  for (const url of ENDPOINTS) {
    try {
      const res = await fetch(url, {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify(payload),
        signal: AbortSignal.timeout(4000),
      });
      if (res.ok) return await res.json();
    } catch (err) {
      // try the next endpoint
    }
  }
  throw new Error("All Polygon RPC endpoints failed");
}

Keep the secondary endpoint on a different provider or region so a single incident does not take both down. Log which endpoint served each request so you can spot patterns.

Operational checklist for Polygon RPC

  • Confirm chain ID 137 (mainnet) or 80002 (Amoy) in every environment.
  • Monitor head lag and latency, not just reachability.
  • Cache read-heavy calls and batch where the client supports it.
  • Paginate eth_getLogs and confirm archive support for historical ranges.
  • Test WebSocket subscriptions separately from HTTP.
  • Configure at least one failover endpoint.
  • Review rate limits against your peak request rate before launch.

Browse the full list of supported RPC networks to see where Polygon fits alongside other chains you run.

Key Takeaways

  • "Polygon RPC status" is not one number; it is head freshness, availability, method coverage, latency, and rate limits combined.
  • Confirm the chain is producing blocks with two independent endpoints before blaming the network.
  • Most failures are endpoint-level: rate limits, missing archive/trace methods, or stale heads.
  • Match chain ID 137 and the correct RPC URL when configuring wallets and clients.
  • Use a managed RPC API or dedicated node when shared endpoints cannot meet your throughput, history, or isolation needs.

Frequently Asked Questions

Is Polygon RPC down right now? There is no single global status. Check whether the chain is producing blocks via a block explorer, then probe your own endpoint for head lag, latency, and errors. If two endpoints disagree, the problem is usually the endpoint, not Polygon.

Why does my Polygon RPC return 429? A 429 means you are exceeding the endpoint's rate limit. Reduce request volume, batch or cache calls, or move to a plan with higher throughput.

What is the Polygon mainnet chain ID? Polygon mainnet uses chain ID 137 (0x89). The Amoy testnet uses 80002.

Why does eth_getLogs fail on old blocks? The endpoint may not be archive-capable, or the block range is too wide. Narrow the range and confirm the provider supports historical queries.

Do I need a dedicated Polygon node? Only if you need predictable throughput, archive or trace data, WebSocket streams under load, or strict isolation. For light usage, a shared or managed endpoint is usually enough.

Does OnFinality support Polygon? Yes. OnFinality provides Polygon RPC through its managed RPC API service and dedicated nodes. See the Polygon network page for endpoint details.

RPC 知识库

相关 RPC 内容

网络 RPCEfinity

什么是 TON 公共节点,何时应该使用它?

TON 公共节点是一个共享的 RPC 端点,允许你读取 TON 区块链数据并提交交易,而无需运行自己的节点。这是让钱包、脚本或原型与 TON 通信的最快方式,但共享端点存在速率限制、延迟波动,且没有运营保证。 本文解释了 TON RPC 与 EVM 链的区别、如何连接到公共端点、何时公共节点足够,以...

区块链基础设施Efinity

什么是 Solana 轻节点,何时应该使用它?

Solana 轻节点是一种客户端,它只保留验证账户和交易所需的状态,而不是存储完整账本。它适用于需要快速读取而无需运行验证者级硬件的钱包、仪表盘和边缘服务。对于大多数生产应用,托管 RPC 端点或专用节点可以替代自行运行轻客户端的运维负担。本文解释了轻节点在 Solana 上的作用、它与验证者和全节...

网络 RPCAcala

什么是Acala Network,如何连接?

Acala Network是基于Polkadot构建的去中心化金融(DeFi)中心,提供跨链流动性、流动性质押和EVM兼容的智能合约平台。本指南涵盖Acala的架构、如何通过RPC端点连接,以及开发者在Acala上构建时的关键考量。...

区块链基础设施

Blockchain Node as a Service: Key Criteria for Choosing a Provider

Blockchain node as a service (also called node-as-a-service or NaaS) lets developers access blockchain nodes without running, syncing, or maintaining ...

区块链基础设施

Web3 存储是什么?它如何与 RPC 基础设施连接?

Web3 存储指的是去中心化的数据存储方式——通常使用 IPFS 这类内容寻址网络,以及 Filecoin 这类带激励的持久化层——使文件无需依赖单一中心化服务器即可被检索。开发者在需要持久化应用数据(NFT 元数据、用户上传内容、快照),或构建同时读写区块链和链下数据层的 dApp 时,常会搜索“...

网络 RPCHyperliquid

选择 Hyperliquid RPC 提供商时应注意什么?

最佳的 Hyperliquid RPC 提供商能为交易机器人、分析系统和 HyperEVM 应用提供低延迟访问、可靠的端点行为、清晰的请求可见性,以及在共享 RPC 不再匹配工作负载时通往专用基础设施的路径。 如果你的应用依赖快速读取、交易状态检查、后端自动化或高流量市场工作流,那么提供商的选择就成...

永远不用担心基础设施

OnFinality 消除了 DevOps 的繁重工作,让您能够更聪明、更快地构建。

开始