Rate limits

Every plan has two budgets: requests per second (RPS) and compute units per month (CU). You only get throttled on the per-second budget; the monthly CU figure is for billing. See billing for how CU is counted.

Plan limits

Per-chain limits apply on top of your plan. Monad currently runs on shared public nodes with limited total capacity, so every caller (anonymous or keyed) is capped at 20 requests per second per IP per method on Monad. Other chains have no per-chain cap today.

RPS limits are per api key, not per IP. Inside one plan, a key can burst to the listed RPS sustained. Brief overshoots are absorbed by a short token bucket.

Anonymous traffic

Unauthenticated requests fall into the anonymous tier with the following caps:

• Up to 200 requests per second per IP, across all methods and chains.
• A shared ceiling across all anonymous callers (5,000 RPS overall, 1,500 RPS for the bot-favourite reads eth_gasPrice and eth_getBlockByNumber), so a distributed fan-out cannot crowd out everyone else.
• eth_query* range methods: 5 RPS per IP, 25 RPS overall.
• The per-chain limits above (Monad: 20 RPS per IP per method).

Anonymous access exists for evaluation. Production traffic must use a key.

Tron anonymous limits

Tron's anonymous tier is more generous than EVM because Tron's upstream nodes are heavier and a lower cap would push too many evaluators to sign up before they finish their test:

• 60 requests per second per IP (2x the EVM anon limit).
• 20,000 requests per day per IP (2x EVM).
• Polling-bait methods (wallet/getnowblock, eth_blockNumber) get a stricter 15 RPS per IP sub-cap, plus a 800 RPS global / 1.5M day global ceiling. Distributed scrapers run into the global limit before the upstream notices.
• Write methods are hard-denied for anonymous traffic: wallet/broadcasttransaction, wallet/broadcasthex, eth_sendRawTransaction. Writes require a key.

See Tron for the full reference.

What happens when you hit a limit

The gateway returns HTTP 429 Too Many Requests with a Retry-After: 1 header:

HTTP/1.1 429 Too Many Requests
Retry-After: 1
Content-Type: application/json

{"error":"rate limit exceeded"}

A Retry-After of 1 means: wait at least one second before retrying. Treat it as a hint, not a contract. If you keep hammering, every retry will hit the same limit.

Recommended client behavior

1. On 429, sleep at least Retry-After seconds.
2. Add small random jitter (50-250ms) so a fleet of clients doesn't thunder back at the same instant.
3. After three consecutive 429s, back off exponentially up to 30s.
4. Surface the failure to your caller; don't retry forever silently.

async function fetchRpc(body: unknown, attempt = 0): Promise<Response> {
  const res = await fetch("https://infra.originstake.com/pharos/evm", {
    method: "POST",
    headers: {
      "X-OriginRPC-Token": process.env.ORIGINRPC_KEY!,
      "Content-Type": "application/json",
    },
    body: JSON.stringify(body),
  });
 
  if (res.status === 429 && attempt < 3) {
    const wait = Number(res.headers.get("Retry-After") ?? "1");
    const jitter = Math.random() * 250;
    await new Promise((r) =>
      setTimeout(r, (wait * 1000) + jitter + attempt * 1000),
    );
    return fetchRpc(body, attempt + 1);
  }
 
  return res;
}

Going over the monthly CU allowance

When monthly CU usage exceeds your plan's allowance:

• If your credit balance is positive, overage is billed against credit at $0.20 per million CU. Requests keep flowing.
• If your credit balance is zero, or you turned overage off, your keys are limited to 1 request per second until you top up, turn overage on, or the next month starts.

See billing for top-up and overage details.

Burst absorption

Brief bursts above your nominal RPS are usually absorbed by:

• Hot-path cache for read-heavy methods (e.g. eth_chainId, eth_blockNumber). A cached response does not count against RPS.
• Token bucket smoothing with a small headroom on top of the advertised RPS.

In practice this means: if your steady-state load is well within plan and you occasionally spike, you will not see 429s. Sustained traffic at the limit will.

Check your quota

Query your own limits and month-to-date usage with your RPC key — no dashboard login needed. The key goes in the Authorization header (or ?api=, or X-OriginRPC-Token), same as any gateway call.

curl https://infra.originstake.com/v1/key/status \
  -H "Authorization: Bearer originrpc_live_YOUR_KEY"

{
  "ok": true,
  "key": { "prefix": "originrpc_live_1Pvg", "name": "my-app" },
  "plan": { "id": "pro", "name": "Pro" },
  "limits": { "rps": 50, "tierOverride": null, "monthlyCu": 50000000, "concurrent": 25 },
  "usage": {
    "cuThisMonth": 12450000,
    "callsThisMonth": 980123,
    "cuRemaining": 37550000,
    "pctUsed": 24.9,
    "periodResetsAt": "2026-07-01T00:00:00.000Z"
  },
  "credit": { "balanceCents": 500, "payg": true, "throttled": false },
  "chains": null
}

Field notes:

• limits.tierOverride — non-null only if your key has a custom rate budget that overrides the plan tier.
• usage.cuRemaining / pctUsed — null on unlimited plans.
• usage.periodResetsAt — when the monthly CU window rolls over (UTC).
• credit.payg — true when pay-as-you-go overage is enabled and you're not throttled; throttled is true if a zero balance has dropped you to free-tier limits.
• chains — null means the key is not chain-restricted; otherwise the allowed arch:chainId list.

The response is cached ~30s per key, so poll it at most every few seconds.

Asking for more

If you're consistently hitting RPS caps, the answer is one of:

1. Upgrade your plan at endpoint.originstake.com/dashboard/billing.
2. Split traffic across keys if you have logical separation (different apps, different environments). Each key has its own bucket.
3. Email us for custom Scale caps. Standard Scale is 1,500 RPS; we'll go higher if your workload makes sense.