Tutoriál: boti pro Polymarket · Kapitola 5 z 32
Polygon RPC provider comparison for Polymarket bots in 2026: Alchemy, QuickNode, Ankr, public endpoints, self-hosted. Latency, rate limits, free-tier usable for paper trading.
What this chapter covers
The Polygon RPC endpoint is the bot's only direct view of on-chain state - balances, allowances, settlement confirmations, UMA events. Polymarket's own API hides most of this, but a production bot needs to read on-chain truth to verify its own bookkeeping. This chapter compares the major RPC providers under live load, gives the free-tier thresholds where each one stops working, and ends with the two-provider failover pattern most bots eventually adopt.
- What an RPC does for your bot
- Alchemy: free tier and pricing
- QuickNode: dedicated nodes
- Ankr: cheapest paid tier
- Public Polygon RPCs (free, rate-limited)
- Self-hosted Polygon node (when it makes sense)
- Latency benchmarks (US-East vs EU)
- Failover patterns
What an RPC does for your bot
An RPC endpoint is the HTTPS or WebSocket URL through which your bot reads and writes Polygon chain state. For a Polymarket bot, the RPC handles four jobs.
- Read balances: how much pUSD or USDC sits in the proxy, how many outcome tokens you actually hold. Necessary to verify the CLOB API's view matches chain truth.
- Read allowances: whether the Polymarket contracts can spend your tokens. A misconfigured allowance produces silent order rejections.
- Subscribe to events: UMA Optimistic Oracle proposals and disputes, deposit confirmations, large on-chain transfers from other wallets.
- Verify settlement: when the CLOB says "matched," the chain has not yet confirmed the ERC-1155 transfer. Reading the chain confirms it actually happened.
The bot does not sign orders through the RPC - order signing is done locally and the signed payload is sent to the CLOB HTTP API. The RPC is purely a read-and-event channel for most strategies.
Alchemy: free tier and pricing
Alchemy is the most-used Polygon RPC provider among Polymarket builders we know. The free tier covers most paper-trading and small-bot use cases: 300 compute units per second, 300 million per month, the same dashboard used to provision Polygon mainnet and Polygon testnet endpoints.
A typical 20-market bot reading balances + UMA events every 30 seconds consumes about 50-80 million CU/month, comfortably under the free cap. Paid plans start around $50/month and primarily buy higher per-second throughput, not more total calls. The free tier rate limit is the constraint most paper-trade bots hit, not the monthly volume.
Alchemy ships a useful dashboard for inspecting failed requests and a per-method latency breakdown that is helpful when debugging slow reads. The dashboard alone is worth choosing them over a no-dashboard provider for a first bot.
QuickNode: dedicated nodes
QuickNode positions itself for higher-throughput needs. Their pricing scales with monthly request volume rather than tiers - most relevant for bots that subscribe to many WebSocket event filters or do heavy historical-log queries. Entry tier is roughly $10-20/month and includes WebSocket support that some free Alchemy tiers throttle.
QuickNode's per-request latency from US-East is typically 5-15ms, slightly better than Alchemy's free tier under load. For a single-strategy bot the difference is invisible; for a market-maker quoting 100 markets it can matter. Their archive node access (full historical state) is the cheapest among the three majors if your strategy needs it.
The pain point: their JSON-RPC error responses are less specific than Alchemy's, so debugging takes longer when a method fails.
Ankr: cheapest paid tier
Ankr offers the cheapest paid Polygon RPC in the major-provider tier - roughly $10/month for the entry premium plan with 1,500 CU/second. The free tier has tight rate limits but is workable for paper trading.
Two warnings. First, Ankr's load-balanced endpoint occasionally serves slightly stale block data (1-2 blocks behind tip). For balance reads, that is fine; for arbitrage strategies depending on the latest block, it is a meaningful problem. Second, their support response time is slower than Alchemy's or QuickNode's when a region's nodes have an issue.
Ankr is a sensible primary provider for cost-sensitive bots and an excellent backup provider regardless of primary. The failover-pattern section below covers how to combine them.
Public Polygon RPCs (free, rate-limited)
Polygon publishes several free public RPC endpoints - polygon-rpc.com, rpc.ankr.com/polygon (public, separate from paid Ankr), and a few community-hosted ones. They work, but with caveats.
- Rate limits are aggressive and undocumented. Expect to be throttled if you exceed ~10 req/sec sustained.
- No support, no dashboard. When an endpoint fails, you find out by your bot's error rate climbing.
- Frequently 1-3 blocks behind. Fine for non-time-sensitive reads.
Use public endpoints for: development on a laptop, the third tier of a failover stack (after two paid providers), one-shot scripts. Do not run live bot trading against a public endpoint as primary.
Self-hosted Polygon node (when it makes sense)
Running your own Polygon full node is feasible - Bor + Heimdall on a 4-vCPU/16GB VPS with ~2 TB SSD, syncing in a couple of days. The math for or against it is simple.
Cost: roughly $40-80/month in VPS + storage on a major host. About 4x a comfortable paid RPC plan.
Win: zero per-request fees, no rate limits, and the lowest possible latency to chain state (1-3ms vs 20-50ms over the internet to a hosted provider).
Pain: snapshot management, Heimdall and Bor each have crash modes, and a stalled sync mid-trading produces silent stale reads.
For 95% of builders, do not self-host. The hours spent on node maintenance dwarf the RPC bill savings. Self-host only if you have a strategy where 30ms of read latency matters in PnL terms and you have already proven the strategy at a hosted provider.
Latency benchmarks (US-East vs EU)
Measured median round-trip times from VPS in three regions to each provider's nearest Polygon RPC, May 2026.
| VPS region | Alchemy | QuickNode | Ankr (paid) | polygon-rpc.com |
|---|---|---|---|---|
| NY (US-East) | 14ms | 11ms | 22ms | 34ms |
| AMS (EU) | 21ms | 17ms | 28ms | 41ms |
| SG (Asia) | 97ms | 89ms | 110ms | 140ms |
Numbers shift week to week within ~3ms. The pattern is stable: QuickNode and Alchemy are within noise of each other; Ankr is consistently 5-10ms behind; public endpoints are 15-25ms behind. Asia-hosted bots pay an unavoidable ~80ms tax against Polygon's North-America-centric backbone.
Failover patterns
One RPC is a single point of failure. Production bots use two providers with a simple swap rule.
Pattern: primary call against provider A; on timeout (3s) or 5xx response, retry against provider B; if both fail, sleep 5s and retry primary. Track consecutive primary failures and auto-pin to B for 60s after 3 failures, then probe primary again.
Recommended combo: Alchemy paid as primary, Ankr free or public Polygon endpoint as backup. They use different upstream node operators, so a hiccup in one is rarely correlated with the other. Avoid running two endpoints from the same provider (e.g. two Alchemy keys) - that gives no real redundancy.
Implementation: a thin wrapper around web3.py or ethers.js that selects between providers on every call. About 30 lines of code; pays for itself the first time a provider has a regional outage.
