Dedicated Polygon RPC Node — Own Bare-Metal, Full eth_getLogs

Polygon PoS processes roughly 500 transactions per second, with a new block arriving every ~2 seconds. That speed generates event-dense history fast: a busy DeFi protocol on Polygon can emit hundreds of thousands of logs per day. Scanning that history with eth_getLogs on a shared endpoint means competing for compute budget with every other tenant — and Polygon's block density makes that competition expensive.

A dedicated node gives your application its own compute-unit budget. No shared quota, no throttling from a neighbour's indexing job.

What "dedicated" means at NodeFlare#

NodeFlare is not an aggregator routing calls through a third-party pool. The Polygon node you connect to is hardware NodeFlare operates directly — we run the bor client on bare-metal servers we rack, configure, and monitor.

What that means in practice:

• No noisy-neighbour quota spikes. Your budget is yours; another tenant's burst does not eat it.
• Standard method access. eth_getLogs, eth_call, eth_getTransactionReceipt, eth_blockNumber, eth_getStorageAt, and the full standard JSON-RPC surface are all available.
• Consistent latency. Same node, same routing path, every request.
• Custom limits on request. Need a longer eth_getLogs block range or a tighter SLA? That is negotiable on a private node.

One honest note: NodeFlare's Polygon node does not support debug_* or trace_* methods. If your use case requires transaction-level execution tracing on Polygon, you will need a node that exposes the debug API. Standard indexing, simulation, and wallet reads all work without it.

Polygon chain facts for RPC design#

Polygon PoS uses a proof-of-stake consensus layer combined with periodic checkpoint submissions to Ethereum mainnet. Each block achieves soft finality on arrival, but the cryptographic security guarantee comes from the checkpoint ~every 30 minutes.

For most DeFi and indexing workloads, the practical approach is to treat ~128 block confirmations (~256 seconds) as the safe finality depth — beyond the re-org window, before the next checkpoint.

Quick-start with the free keyed endpoint#

A free API key gives you access to NodeFlare's Polygon node with 2,000,000 compute units per month and no credit card required:

# Latest block on Polygon — replace YOUR_KEY
curl -s https://rpc.nodeflare.app/polygon \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

// ethers v6 / TypeScript
import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider(
  "https://rpc.nodeflare.app/polygon",
  undefined,
  { staticNetwork: true }   // skip chainId probe — you already know it's 137
);

const block = await provider.getBlockNumber();

Public (no-key) endpoint for low-volume testing: https://rpc.nodeflare.app/polygon/public

eth_getLogs for Polygon indexers#

Polygon's 2-second block time means a 10,000-block eth_getLogs window covers roughly 5.5 hours of chain history — similar to Avalanche. For protocols with dense event emission (Aave, QuickSwap, Uniswap v3 on Polygon), that window can return tens of thousands of log entries.

On a shared endpoint, that kind of query hits per-request compute caps fast. On a dedicated node, your budget is not shared.

A well-filtered query keeps costs predictable:

# Fetch Transfer events for a specific ERC-20 — replace YOUR_KEY
curl -s https://rpc.nodeflare.app/polygon \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "eth_getLogs",
    "params": [{
      "fromBlock": "0x1FA0000",
      "toBlock":   "0x1FA2710",
      "address":   "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",
      "topics":    ["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"]
    }],
    "id": 1
  }'

Use tight address and topics filters to stay inside sensible compute-unit budgets. A broad eth_getLogs with no address filter across thousands of blocks is expensive on any endpoint.

When to upgrade to a private dedicated node#

The free keyed tier covers most development and staging workloads. Move to a private dedicated node when:

• You need a guaranteed uptime SLA for production indexing traffic.
• Your eth_getLogs jobs run wide block ranges that the free-tier per-call limits constrain.
• You want a private endpoint URL not visible in network traces.
• You're running an indexer or DeFi protocol that needs predictable burst headroom.

NodeFlare provides dedicated Polygon nodes with custom rate limits and an SLA — email [email protected] or see the dedicated nodes page.

Try it#

• Get a free API key — 2M CU/month, no card
• Polygon chain page — live endpoint, Try-it console, all supported methods
• Dedicated nodes — private Polygon node with SLA, plus every EVM chain we run
• Rate limits and compute-unit costs — what counts, what doesn't