SCRIPTMASTERLABS · AGENT COMMERCE · SEP 25, 2026

Polygon Agent Pay Channels: 11 Million Payments Per Second

Q: Is 11 million updates per second Polygon's onchain TPS?

No. The 11M+ figure is offchain channel updates — payment-channel state moves confirmed by the payment engine, batched and settled on Polygon Chain later. It is not Polygon mainnet throughput. The full x402 path (agent + site + facilitator + hub) measured ~40,000 payments per second.

Q: What did the full x402 path actually measure?

About 40,000 payments per second end-to-end across agent, site, facilitator, and hub. The test recorded 2.4 million payments with 100% success.

Q: What was the test setup?

An OpenRouter-style inference API on a live devnet, with a signed payment triggered every 100-token window. The payment path was real; the inference provider was a stand-in.

Q: What does it cost?

About $0.15 per billion payment updates in the benchmark configuration. Settlement is configurable: after 1 payment, 50,000 updates, or 100,000,000 updates.

Q: How fast can a single hub go?

One 24-core server driving a single hub directly hit 533,000 to 536,000 fully verified payments per second. The payment engine confirmed each update in 20 microseconds (excluding network latency).

Q: What does this mean for x402 builders?

The payment-friction question is being answered by infrastructure: agents paying per inference, per API call, per data fetch is becoming technically and economically trivial. The open question flips from 'can my agent pay' to 'should my agent pay for this' — which is a decision-gating problem, not a payments problem.

Polygon Labs tested x402-based payment channels that let AI agents pay for inference, data, and API calls as they consume them — 11M+ verified updates per second across 25 hubs.

The critical qualifier: that's offchain channel updates — not Polygon onchain TPS. The full x402 path measured ~40,000 payments/sec. Every rewrite that prints "11 million" without the qualifier is wrong, and most of them did.

HONESTY BOX — READ THIS FIRST

What 11M means: 11M+ payment-channel state updates per second confirmed by the payment engine, each in 20 microseconds (excluding network latency). Updates accumulate offchain inside channels; Polygon Chain only sees batched settlement.

What it is NOT: Polygon mainnet throughput. Onchain TPS is a different metric entirely.

What was real in the test: a live devnet, an OpenRouter-style inference API, a signed payment triggered every 100-token window — 2.4M payments recorded at 100% success on the full path. The inference provider itself was a stand-in.

What is a projection, not a result: Polygon's estimate of 100M+ updates/sec with a larger hub fleet. Tested: 11M with 25 hubs.

The numbers

metric	result	what it actually is
Channel updates (25 hubs × 16 vCPU)	11M+/sec	Offchain payment-engine confirmations. Hubs partition payers with no cross-hub coordination.
Full x402 path (agent + site + facilitator + hub)	~40,000/sec	End-to-end payments. 2.4M recorded, 100% success.
Single hub, engine-direct (one 24-core server)	533k–536k/sec	Fully verified payments through one hub.
Update confirmation	20μs	Payment-engine confirmation per update; excludes network latency.
Cost	~$0.15 per billion updates	In the benchmark configuration.
Settlement	configurable	Batched onchain after 1 payment, 50k updates, or 100M updates — operator's choice.
Projected scale	100M+/sec	Polygon's estimate for a larger fleet — not a test result.

What it means for x402 builders

The friction question is dying. Agents paying per inference window, per API call, per data fetch — at $0.15 per billion updates — stops being an engineering debate and becomes a default.
Channels, not chains, carry machine commerce. The chain settles; the channel transacts. x402's signed-payment handshake rides channels that settle in batches — throughput at this scale only exists because settlement is deferred.
Polygon is wiring it into the Open Money Stack. The mechanism will connect to Polygon's broader "Open Money Stack" — this test is the throughput receipt before the product story.

THE SML ANGLE — 11M updates/sec makes the gate the product

When an agent can pay 11 million times a second, the question stops being "can agents pay" and becomes "SHOULD this agent pay for THIS?" That's a decision problem, not a payments problem.

The pattern we're cornering: decision-gated machine payments — a confidence score gates whether the payment fires: ≥0.80 auto-pay, 0.50–0.79 confirm, <0.50 escalate. Model-agnostic. Infinite throughput makes the gate more necessary, not less — every one of those 11M updates is a decision somebody's agent made, and an ungated agent is a blank check.

The kind of service those gated agents pay for: pay-per-query x402 APIs like SML's SEO API for AI agents — per-call pricing, no subscription, no key-negotiation, signed payment per request. Rails this fast exist to be spent against services this granular.

Sources

crypto.news: Polygon payment channels hit 11 million updates per second across 25 hubs
Traders Union: Polygon boosts agent payments

Reported Sept 25, 2026. Numbers as published by Polygon Labs and the outlets above; the "not onchain TPS" qualifier is ours and is the point.

FAQ

Is 11 million updates per second Polygon's onchain TPS?

No. It's offchain channel updates — payment-channel state moves confirmed by the payment engine in 20μs each, batched and settled on Polygon Chain later. The full x402 path (agent + site + facilitator + hub) measured ~40,000 payments per second.

What did the full x402 path actually measure?

About 40,000 payments per second end-to-end across agent, site, facilitator, and hub. 2.4 million payments recorded at 100% success.

What was the test setup?

An OpenRouter-style inference API on a live devnet, with a signed payment triggered every 100-token window. The payment path was real; the inference provider was a stand-in.

What does it cost?

About $0.15 per billion payment updates in the benchmark configuration. Settlement is configurable: after 1 payment, 50,000 updates, or 100,000,000 updates.

How fast can a single hub go?

One 24-core server driving a single hub directly hit 533,000–536,000 fully verified payments per second.

What does this mean for x402 builders?

The payment-friction question is being answered by infrastructure. The open question flips from "can my agent pay" to "should my agent pay for this" — a decision-gating problem. That's the decision-gated machine payments pattern.

TRUTH FIRST. PROOF ALWAYS. 11M CHANNEL UPDATES ≠ ONCHAIN TPS.