Infura API Key, Infura.io, and Infura Pricing Plans 2026: Choosing the Right Tier

Infura moved to a credit-based model, added DIN-backed reliability, and tightened per-plan limits—so the “right” tier in 2026 depends on your exact RPC mix, throughput, and security posture. This guide translates the newest plan details and per-method credit costs into concrete capacity math, guardrails, and decision criteria for startup and enterprise teams.

Who this guide is for

Startup CTOs and heads of product evaluating RPC providers and budgets.
Enterprise architects designing for reliability, auditability, and scale.
Engineering managers who must keep APIs online and bills predictable.

TL;DR: 2026 Infura plans at a glance

Core (Free): 3,000,000 daily credits; 500 credits/second; 1 API key. Best for prototypes or very light prod read traffic. (docs.metamask.io)
Developer ($50/mo): 15,000,000 daily credits; 4,000 credits/second; up to 5 API keys; access to Debug/Trace and Settings Override. (infura.io)
Team ($225/mo): 75,000,000 daily credits; 40,000 credits/second; unlimited API keys; higher throughput and prioritized support. (infura.io)
Enterprise (Custom): Custom daily credits and throughput, autoscaling, enhanced SLAs, crypto payments available. (infura.io)
Add-on: $200/month “Additional Credits” pack of 55 million credits to extend capacity. (infura.io)

Note on docs: Some legacy pages still show older Core limits (6M/day, 2K credits/sec). The current “Infura plans” docs and pricing table reflect 3M/day and 500 credits/sec for Core as of January 7, 2026. Always defer to the pricing table and the “Infura plans” docs page. (infura.io)

How Infura credits actually map to work

Infura now charges by “credits” per request based on method complexity. Most common ETH JSON-RPC calls cost 80 credits; heavy methods cost more (for example,

eth_getBlockReceipts

is 1000 credits; Debug methods are 1000; Trace methods 300). Bundler (AA) methods can be several thousand credits per call. Error handling matters too: 429/402 aren’t charged; 4xx consume 5 credits; 5xx are free. Archive requests currently cost the same as non-archive but may change. (docs.infura.io)

Quick conversions you can use during planning:

“80-credit calls” per day: Core ≈ 3,000,000/80 = 37,500 calls; Developer ≈ 187,500; Team ≈ 937,500. (docs.metamask.io)
Per-second throughput into calls/sec (assuming 80-credit calls): Core 500/80 ≈ 6.25 calls/sec; Developer 4,000/80 = 50 calls/sec; Team 40,000/80 = 500 calls/sec. (docs.metamask.io)

Selected credit costs (ETH unless noted):

80 credits:

eth_blockNumber

eth_call

eth_getBalance

eth_sendRawTransaction

eth_getBlockByNumber

255 credits:
```
eth_getLogs
```
300 credits:
```
eth_estimateGas
```
, Trace (
```
trace_*
```
)
1000 credits:
```
eth_getBlockReceipts
```
, Debug (
```
debug_*
```
)
Subscriptions:
```
newHeads
```
50 credits/block;
```
logs
```
300 credits/block;
```
newPendingTransaction
```
~200 credits/second (per stream)

Bundler (AA):

eth_sendUserOperation

4,950 credits;

eth_estimateUserOperationGas

1,980 credits

Solana: 160 credits for each method call
These figures are pulled from the official credit cost tables. (docs.infura.io)

Daily resets and rate limiting:

Credit quotas reset at 00:00 UTC daily. Hitting the daily limit halts traffic and severs WebSocket connections until reset. Exceeding per‑second throughput returns HTTP 429. (docs.metamask.io)

Supported networks and endpoints (what you get on any plan)

Infura exposes 40+ networks via consistent HTTPS and WebSocket endpoint formats, including Ethereum mainnet/Sepolia/Holesky, Layer 2s (Arbitrum, Optimism, Base, zkSync Era, Scroll, Linea), Polygon PoS, Avalanche C-Chain, BNB Smart Chain, Starknet, and more. Endpoint URLs are listed per chain in the “All endpoints” docs. (infura.io)

Example you can drop into your IaC:

Base mainnet HTTPS: https://base-mainnet.infura.io/v3/<YOUR-API-KEY>
Base mainnet WSS: wss://base-mainnet.infura.io/ws/v3/<YOUR-API-KEY>
Arbitrum mainnet HTTPS: https://arbitrum-mainnet.infura.io/v3/<YOUR-API-KEY> (docs.metamask.io)

Newer ecosystems appear through partners too—for instance, Unichain docs list Infura as a node provider for Unichain mainnet and Sepolia. Validate availability in the “All endpoints” page before launch. (docs.unichain.org)

DIN: why “Decentralized by DIN” matters to uptime and risk

Infura’s Decentralized Infrastructure Network (DIN) routes traffic across independent providers and launched an EigenLayer AVS in November 2025, targeting decentralized economic security and performance. DIN is now serving 13B+ requests/month across 30+ networks. “Decentralized by DIN” access appears in all plans; additional DIN failover/resilience has been packaged at higher tiers historically—confirm during procurement. (theblock.co)

Key takeaways for decision-makers:

Reduces single-provider blast radius risk.
Adds verifiability and incentives for performance/uptime via restaked ETH.
Broadens network coverage quickly (2024 additions included Blast, Mantle, Starknet, zkSync, BSC/opBNB, Scroll). (prnewswire.com)

Security and API key management (what changed and what to turn on)

Infura now ships stronger key controls in the MetaMask Developer dashboard:

API key limits per plan: Core=1, Developer=5, Team+=unlimited. Create distinct keys per environment and per app surface. (infura.io)
Allowlists: Restrict by contract addresses, HTTP Origin, User-Agent, and allowed JSON-RPC methods. Up to 30 entries per type; types are ANDed, multiple entries in a type are ORed. Wildcard subdomains are supported for Origins. (docs.metamask.io)
API key secret: Require a “secret” for server-side calls; on Developer+ you can override allowlists when using the secret (principle of least privilege on client, unrestricted on server). (docs.metamask.io)
Per-key credit caps: Set daily and per-second credit limits so a leaked key can’t nuke your budget; exceeding user-defined caps returns 429 with a descriptive payload. (docs.metamask.io)
Request visibility (analytics retention): Core up to 24h; paid plans up to 30 days. Monitor usage and create alerts for 75/85/100%. (infura.io)

Minimal server-side example with API key secret:

# Server-side: use Basic auth with your API key secret
curl --user :$INFURA_API_SECRET \
  https://mainnet.infura.io/v3/$INFURA_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'

This enables secret-based override (Developer+) while your client key remains allowlisted and constrained. (docs.metamask.io)

Browser note: Infura returns exact-origin CORS headers (not “*”) where auth is involved; keep secrets off the client and prefer a thin backend or signed JWTs. (support.infura.io)

Practical capacity planning: translate credit math into tiers

Below are real-world patterns mapped to daily credits and throughput. Replace volumes with your projections.

Wallet/dapp home screen (ETH L1)

Calls on first load:
```
eth_blockNumber
```
(80),
```
eth_getBalance
```
(80),
```
eth_call
```
(80) for a few contracts,
```
eth_getLogs
```
(255) for recent user events. Assume 6 calls ≈ 80*5 + 255 = 655 credits per fresh load.
10,000 daily active users without caching: ≈ 6.55M credits/day → Developer (15M) fine; Core (3M) insufficient. With caching and WS for new blocks, you can cut 50–70%. (docs.infura.io)

Indexer grabbing receipts per block

```
eth_getBlockReceipts
```
costs 1000 credits. Scanning 7,200 blocks/day (≈12s block time) costs ~7.2M credits/day per chain—Team plan recommended (or shard the job, cache, and filter to target blocks first). (docs.infura.io)

Realtime updates via WebSockets

```
eth_subscribe
```
newHeads charges 50 credits per block per subscription. At ~7,200 blocks/day, that’s ~360,000 credits/day per active subscriber. For 100 concurrent live sessions, that’s ~36M/day—Developer won’t cut it; consider Team or push more logic server-side with fan-out. (docs.infura.io)

Heavy debugging and tracing

Debug/Trace methods cost 1000 or 300 credits, respectively. A QA pipeline that traces 5,000 txs/day burns ~5M credits/day; that fits in Developer—but it leaves little headroom for prod traffic. Run traces off-peak and cache results. (docs.infura.io)

Account Abstraction (Bundler)

A
```
eth_sendUserOperation
```
is 4,950 credits. 10,000 user ops/day consumes ~49.5M credits—Team tier baseline; if bursts are spiky, plan throughput too (per-second budget). (docs.infura.io)

Solana program reads

Each Solana method costs 160 credits. 1M Solana method calls/day needs ~160M credits—Enterprise or a Team plan plus add-ons. (docs.infura.io)

Throughput guardrails:

Convert your hot path into credits/sec. Example: you need ~100 “80-credit” calls/sec on average → 8,000 credits/sec → Developer (4,000) will 429; Team (40,000) is appropriate. (docs.metamask.io)

Reset behavior and error economics:

Daily cap halts HTTP and severs WS until 00:00 UTC; 429/402 aren’t charged; 4xx costs 5 credits; bogus methods cost 160 credits—avoid tight loops and validate methods in CI. (docs.metamask.io)

Choosing the right 2026 tier: a decision framework

Start with three axes—daily credits, throughput, and security/ops needs—then pick a minimum tier:

Credits/day
- ≤ 3M: Core for POCs or small internal tools (assume ~37.5k “80-credit” calls/day).
- 3M–15M: Developer for small prod dapps or AA pilots.
- 15M–75M: Team for mainstream traffic or multi-chain launches.
- 75M: Enterprise or add-ons. (docs.metamask.io)
Throughput (credits/sec)
- ≤ 500: Core; fits ~6 “80-credit” calls/sec.
- ≤ 4,000: Developer; ~50 calls/sec.
- ≤ 40,000: Team; ~500 calls/sec sustained.
- Spiky/bursting beyond that: Enterprise. (docs.metamask.io)
Security and governance
- Need per-key allowlists, secrets with override (server), multiple env keys, and longer analytics retention? Start at Developer; Team if many squads need their own keys. (docs.metamask.io)
Reliability
- If you require decentralized failover and SLAs, validate DIN packaging and Enterprise SLAs with Consensys Sales; “Decentralized by DIN” endpoints exist across plans, with advanced failover historically tied to higher tiers. (infura.io)
Add-ons
- If your math lands just above a tier threshold, the $200 add-on for 55M additional credits can be the cheapest lever—model daily and throughput together to avoid 429s. (infura.io)

Cost-hardening best practices (to avoid 3 a.m. surprises)

Set per-key hard caps: Use per-second and per-day key-level credit limits 10–20% below your plan to limit blast radius on leaks or runaway jobs. Your app will get structured 429s if it misbehaves. (docs.metamask.io)
Split keys by environment and surface: Prod frontend, backend, indexers, and QA should each have separate keys with different allowlists and caps. Core=1 key, Dev=5 keys, Team+=unlimited. (docs.metamask.io)
Apply allowlists everywhere:
- Client keys: restrict by Origin and allowed methods.
- Server keys: require API key secret and override allowlists (Developer+).
- Contract address allowlists if your reads are scoped. (docs.metamask.io)
Use WS judiciously: Subscriptions cost per block/event—don’t open hundreds of
```
logs
```
streams from the browser. Consolidate on the server and fan out via your own WebSocket/GraphQL. (docs.infura.io)
Cache aggressively:
- Cache historical blocks, receipts, and code. Ethereum L1 reorgs are shallow; cache anything older than a few blocks.
- Prefer
```
eth_subscribe
```
  for new data and backfill via HTTP only when needed. (docs.metamask.io)
Watch method mix:
```
eth_getLogs
```
(255) and Debug/Trace (1000 / 300) dominate budgets. Refactor indexers to target addresses/topics first, then escalate to heavy calls off the hot path. (docs.infura.io)
Analytics and alerting: Use the dashboard to monitor per-method credit usage and set email alerts at 75/85/100%. Retention increases with plan. (docs.metamask.io)

Example scenarios with exact budgets

NFT gallery on Ethereum and Polygon PoS

Home load (cached):
```
eth_blockNumber
```
(80), two
```
eth_call
```
(160), one
```
eth_getLogs
```
(255) per chain: ~495 credits/chain. Two chains ≈ 990 credits per uncached load.
5,000 daily users with 60% cache hit rate → 2,000 “uncached” loads → ≈ 2M credits/day. Core fits, but you’ll be close once you add WS or search features. Developer offers headroom and Debug/Trace when triaging issues. (docs.infura.io)

On-chain analytics dashboard using receipts

Hourly job: fetch receipts for the last 300 blocks → 300,000 credits/hour → 7.2M/day. Team tier is the right floor; consider sampling or using logs by topic instead. (docs.infura.io)

Account Abstraction MVP on L2

2,000 user operations/day → ~9.9M credits/day just for
```
sendUserOperation
```
; add estimation and reads and you’re ≈ 12–14M/day: Developer fits; if you plan growth, step up to Team for throughput. (docs.infura.io)

Solana bot fleet

300 requests/sec sustained (160 credits each) → 48,000 credits/sec. Team (40,000/sec) will 429; Enterprise throughput or a hybrid architecture is required. (docs.infura.io)

Creating your Infura API key (and setting it up correctly)

Sign up in the MetaMask Developer dashboard; Infura auto-creates a “My First Key.” Then restrict networks per key—only enable the endpoints you’ll use. (docs.metamask.io)
Create separate keys per environment and per surface (frontend vs backend). Plans limit keys to 1/5/unlimited across Core/Developer/Team+. (docs.metamask.io)
Turn on API key secret for server calls, and optionally override allowlists (Developer+). Keep secrets out of client code. (docs.metamask.io)
Add allowlists: Origins for browser, contract addresses for scoped reads, allowed methods to narrow the attack surface. Up to 30 entries per type; AND across types, OR within type. (docs.metamask.io)

Expansion APIs and features that can tilt your math

Gas API: EIP‑1559 fee endpoints cost ~80 credits per call; wiring these into fee estimation pipelines increases read volume predictably. (docs.infura.io)
Full archive access: Currently costs the same as non-archive reads by credits; plan as if this may change. (docs.infura.io)
IPFS/Dedicated Gateway: Access is limited to pre‑qualified customers; if you need subdomain gateways for NFT/media, apply early. (infura.io)
Crypto payments: Supported for custom plans (Enterprise). (infura.io)

Plan selection cheatsheet (fast mapping)

Prototyping, hackathon, or internal tool:
- Core. Keep under ~37.5k “80-credit” calls/day and ~6 calls/sec. Use caching and no heavy debug/trace in prod. (docs.metamask.io)
Small prod dapp (single chain), light AA, steady 25–50 calls/sec:
- Developer. Enables Debug/Trace, 5 keys, Settings Override, and 4k credits/sec. (infura.io)
Consumer app or multi-chain launch; log-heavy analytics; hundreds of calls/sec:
- Team. 75M/day and 40k credits/sec; unlimited keys; prioritized support. (infura.io)
Exchange/aggregator-scale, Solana + EVM multi-chain, or AA at volume:
- Enterprise. Custom throughput, autoscaling, SLAs, crypto payments; confirm DIN failover specifics. (infura.io)
On the fence between tiers:
- Buy the $200 add-on for +55M credits/month to bridge gaps without a full tier jump—then watch throughput. (infura.io)

7Block Labs’ emerging best practices for 2026

Design with “credits/second” first. The most common outage cause we see isn’t daily quota—it’s per‑second bursts. Compute your peak credits/sec and size up one tier if real-time is mission‑critical. (docs.metamask.io)
Prefer server fan‑out for WS. One backend subscription per topic, many client subscribers via your infra; this slashes subscription credit burn. (docs.infura.io)
Make “expensive” queries accountable. Tag
```
eth_getLogs
```
, Debug, Trace, and Bundler calls in your telemetry; budget them separately and run heavy jobs off‑peak. (docs.infura.io)
Use DIN as a reliability layer, not a license to skip caching. DIN reduces correlated failures, but good caching and backoff keep bills stable. (theblock.co)
Enforce allowlists in CI. Treat your key’s allowed methods and origins as code—fail PRs that add methods without budget updates. (docs.metamask.io)

Final checklist before you buy

Map your 30‑day method mix to credits/day and credits/sec, not “requests.” Use 80/255/300/1000/4950 anchors from the official table. (docs.infura.io)
Validate network coverage in “All endpoints” for every chain on your roadmap. (docs.metamask.io)
Decide on key topology (env/surface) and set per‑key caps and allowlists on day one. (docs.metamask.io)
Confirm DIN packaging and SLAs if you’re in a regulated or always‑on environment. (infura.io)
If you’re within 10–20% of a tier boundary, model add‑on credits vs. stepping up a tier; consider both daily and per‑second headroom. (infura.io)

Bottom line

Infura’s 2026 pricing is transparent once you think in credits, not requests. If your workloads are mostly 80‑credit reads with modest WS, Developer often suffices; once you introduce heavy logs, receipts, traces, or Bundler, Team is the practical floor. For cross‑ecosystem scale or Solana-heavy throughput, plan for Enterprise—and ask about DIN-backed failover and SLAs to match your risk model. (docs.metamask.io)

Description: An expert, data-driven guide to Infura’s 2026 pricing and API key setup—complete with per-method credit costs, throughput math, DIN reliability notes, and concrete scenarios to pick the right tier. (docs.metamask.io)