Polygon explorer API: PolygonScan, Blockscout, RPC endpoints and explorer kits

A Polygon explorer API gives your code the same data you see on an explorer page: transactions, balances, token transfers, blocks, contract ABIs. You have three main options — Etherscan API V2 (PolygonScan's data, key required), Blockscout's API (open source, no key for moderate use) and raw JSON-RPC from a Polygon node — plus Heimdall's REST API for checkpoints and validators.

We use most of these every day: our own live Polygon explorer runs entirely on Blockscout API v2 and public RPC endpoints, called straight from your browser. Every endpoint and code sample on this page was run by our team on 25 September 2026 before publishing. Where we couldn't verify something, we say so.

Which Polygon API should you use?

The right choice depends on what you're building. Here's how the options compare in practice.

A rule of thumb from our own work: if you need "history" — all token transfers of an address, a list of holders — you need an indexer, meaning Etherscan or Blockscout. Plain RPC nodes can't answer "show me every transaction this wallet ever made" efficiently. If you need "current state" or want to submit a transaction, RPC is the direct route. For a user-facing comparison of the explorers behind these APIs, see our best Polygon explorers ranking.

PolygonScan API: Etherscan API V2 and your key

PolygonScan is built by the Etherscan team, and its API has been folded into Etherscan API V2. Instead of a separate PolygonScan key and api.polygonscan.com, you now use one Etherscan key for every supported chain and pick the chain with a chainid parameter. For Polygon PoS that's chainid=137.

We checked the old host: api.polygonscan.com now answers with a redirect, so update any legacy code. Without a key, the new endpoint answers politely but refuses:

curl -s "https://api.etherscan.io/v2/api?chainid=137&module=account&action=balance&address=0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270&tag=latest"
# {"status":"0","message":"NOTOK","result":"Missing/Invalid API Key"}

Add &apikey=YOUR_KEY and the same call returns the balance in wei. The module and action names (account, txlist, tokentx, contract, getabi, proxy, and so on) are the classic Etherscan ones, so years of tutorials still apply once you switch the base URL and add chainid.

Getting a PolygonScan API key: create a free account on Etherscan, open the API keys section of your dashboard and generate a key. The free tier comes with per-second and daily limits. Etherscan has adjusted which chains and endpoints the free tier covers more than once, so check the current plan page in the Etherscan API documentation before you commit to it for a product. Our PolygonScan review covers the explorer side of the account (watchlists, notifications, CSV export).

Blockscout API for Polygon PoS (no key needed)

Blockscout is the open-source explorer that runs the Polygon PoS instance at polygon.blockscout.com, and it offers two APIs on the same host. Neither required a key in our tests, and both returned Access-Control-Allow-Origin: *.

REST API v2

The modern JSON API lives at https://polygon.blockscout.com/api/v2/. It returns rich, pre-decoded objects: token metadata with prices, decoded method names, fee breakdowns. Endpoints we use constantly:

• /transactions/{hash} — status, block, confirmations, fee, method, decoded input
• /addresses/{address} — balance, contract flag, name, verification status
• /addresses/{address}/token-balances — every ERC-20, ERC-721 and ERC-1155 balance
• /blocks/{number} — gas used and limit, base fee, burnt fees
• /tokens/{address} — name, symbol, decimals, holders, price
• /stats — network-wide counters, gas prices, average block time

curl -s https://polygon.blockscout.com/api/v2/tokens/0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359

{"address_hash":"0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359","decimals":"6","exchange_rate":"0.999859","holders_count":"4165554","name":"USDC","reputation":"ok","symbol":"USDC","type":"ERC-20", "...": "..."}

Note that numbers arrive as strings (to avoid JavaScript precision loss) and amounts are in the token's smallest unit. Divide by 10 ** decimals before showing them.

Etherscan-compatible API

At https://polygon.blockscout.com/api Blockscout mimics Etherscan's module/action query style. That makes it a drop-in option when you have Etherscan-style code and don't want a key:

curl -s "https://polygon.blockscout.com/api?module=transaction&action=gettxreceiptstatus&txhash=0x9ba51db95824c1677415608326cefc1620c4c835dc0dbe8612a6b7674942b24b"
# {"message":"OK","result":{"status":"1"},"status":"1"}

Coverage isn't identical to Etherscan's — some actions are missing or behave slightly differently — so test each call you rely on. Blockscout's API documentation lists what's supported. For the explorer itself, read our full Blockscout review.

Public Polygon RPC endpoints (tested list)

JSON-RPC is how wallets and dApps talk to a Polygon node directly: eth_blockNumber, eth_getBalance, eth_call, eth_sendRawTransaction and so on. Here's what we confirmed on 25 September 2026 by calling eth_chainId on each endpoint with a browser-style Origin header.

A quick sanity check you can run from any terminal:

curl -s https://polygon-bor-rpc.publicnode.com \
  -H 'content-type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_chainId","params":[]}'
# {"jsonrpc":"2.0","result":"0x89","id":1}

0x89 is 137, Polygon PoS mainnet. Public endpoints differ in which methods they expose: txpool_status worked on publicnode but dRPC rejected it as unavailable. For adding these to a wallet with the right chain ID, currency and explorer URL, see our Polygon network settings page; Polygon's own docs keep a list of RPC providers, including paid ones with SLAs.

Heimdall REST API for checkpoints and validators

Polygon's consensus layer has its own public API at https://heimdall-api.polygon.technology. It's where you get checkpoint and validator data that no EVM explorer API exposes: /checkpoints/latest, /checkpoints/count, /checkpoints/{id}, /milestones/latest, /stake/validators-set and /stake/validator/{id}. No key, CORS open. Response shapes changed with the Heimdall v2 upgrade in July 2025 — root hashes are Base64 now — so old parsers may need updates. We document the endpoints with live output on our Heimdall checkpoint explorer, which uses exactly these calls.

A browser-ready example with fetch

Here's a small script that reads a wallet's USDC balance from Blockscout and the latest block from a public RPC. It runs unchanged in a modern browser console or in Node 18+, and we ran it before publishing:

const USDC = '0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359';
const wallet = '0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270';

const res = await fetch(`https://polygon.blockscout.com/api/v2/addresses/${wallet}/token-balances`);
if (!res.ok) throw new Error(`Blockscout returned ${res.status}`);
const balances = await res.json();

const usdc = balances.find(b => b.token.address_hash.toLowerCase() === USDC.toLowerCase());
const amount = usdc ? Number(usdc.value) / 10 ** Number(usdc.token.decimals) : 0;
console.log(`USDC balance: ${amount}`);

const rpc = await fetch('https://polygon-bor-rpc.publicnode.com', {
  method: 'POST',
  headers: { 'content-type': 'application/json' },
  body: JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'eth_blockNumber', params: [] }),
});
const { result } = await rpc.json();
console.log('Latest block:', parseInt(result, 16));

The wallet in the example is the WPOL contract, which Blockscout still labels "WMATIC" — a nice reminder that names in API responses can lag behind rebrands. Always key your logic on addresses, not names or symbols. For production code, use BigInt or a decimal library rather than Number for token amounts; large balances lose precision as floating-point numbers.

Rate limits, CORS and running in the browser

Rate limits. Every free API here is rate-limited. Blockscout sends x-ratelimit-limit, x-ratelimit-remaining and x-ratelimit-reset headers with each response — on our test the limit header read 180 — so read them and back off instead of hammering. Etherscan enforces per-key limits per second and per day. Public RPCs throttle by IP without telling you the numbers. Cache aggressively: a confirmed transaction never changes, so fetch it once.

CORS. Blockscout, Heimdall REST and the three working public RPCs all returned Access-Control-Allow-Origin: *, which is why a purely static site like ours can query them from the visitor's browser. Etherscan's API also returned an open CORS header, but that doesn't make it safe to call from the front end.

Fallbacks. Public infrastructure goes down. Our explorer tries Blockscout first and falls back across several RPC endpoints if one fails; we'd recommend the same pattern for any app that depends on free endpoints.

Polygon explorer kit: building or hosting your own explorer

"Polygon explorer kit" is a phrase people search when they want to run an explorer rather than use one — for a Polygon-based chain they operate, for an internal dashboard, or simply to avoid third-party rate limits. There's no single official product by that name. In practice it means assembling:

For most teams, self-hosting a full Polygon PoS explorer isn't worth it — the public Blockscout and PolygonScan instances already index billions of transactions. It makes sense for new chains, private networks, or when you need guaranteed capacity. Blockscout's deployment docs and its GitHub repository are the place to start.

If you're building something that moves real funds and just need POL for gas while testing on mainnet, buy it on a regulated exchange that holds licences in several jurisdictions and lets you withdraw directly to the Polygon network — pick Polygon PoS as the withdrawal network. For free test funds, use the Amoy faucet described on our Amoy testnet explorer page instead.

How our live tool uses these APIs

Our Polygon transaction and address explorer is a working example of everything above. Transaction, address, block and token lookups on Polygon PoS go to Blockscout API v2; if a lookup fails or is very fresh, it falls back to JSON-RPC via the public endpoints listed here. Amoy and zkEVM lookups use basic RPC data. The gas tracker and mempool widgets read RPC directly, and the Heimdall widget calls Heimdall REST. No API key, no backend, nothing stored on our side — requests go from your browser straight to the public APIs. That's also why, if one of these providers has an outage, you may briefly see a dash where a number should be.