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

Infura has switched to a credit-based model, brought in DIN-backed reliability, and adjusted the limits for each plan. That means figuring out the best tier for 2026 really hinges on your specific RPC mix, throughput, and security needs. In this guide, we break down the latest plan details and the costs per method in a way that makes it easy to understand the capacity, provide some guardrails, and help both startup and enterprise teams make informed decisions.

---

Who this guide is for

• Startup CTOs and product leads are diving into the world of RPC providers and reviewing their budgets.
• Enterprise architects are focusing on building systems that are reliable, easy to audit, and can scale up as needed.
• Engineering managers are juggling the challenge of keeping APIs running smoothly while also keeping their costs in check.

---

TL;DR: 2026 Infura plans at a glance

• Core (Free): You get 3,000,000 daily credits here, with a pace of 500 credits per second and just 1 API key. This plan is perfect for experimenting or handling light production read traffic. (docs.metamask.io)
• Developer ($50/mo): This one bumps you up to 15,000,000 daily credits and 4,000 credits per second. You can have up to 5 API keys, plus you'll get access to Debug/Trace and Settings Override features. (infura.io)
• Team ($225/mo): Here, you’re looking at 75,000,000 daily credits and a whopping 40,000 credits per second. Enjoy unlimited API keys along with better throughput and prioritized support. (infura.io)
• Enterprise (Custom): This plan is tailored just for you! It offers custom daily credits and throughput, autoscaling, enhanced SLAs, and even crypto payments if that's your jam. (infura.io)
• Add-on: Need more? For $200 a month, you can grab an “Additional Credits” pack that gives you 55 million more credits to boost your capacity. (infura.io)

Important Note on Documentation

Just a heads up! Some of the older pages still mention the previous Core limits (6M/day, 2K credits/sec). However, the latest “Infura plans” documentation and the pricing table now state that the Core limits have been updated to 3M/day and 500 credits/sec since January 7, 2026. So, make sure to always check out the pricing table and the “Infura plans” docs page for the most accurate info. You can find them here: (infura.io)

---

How Infura credits actually map to work

Infura has switched to a credit-based system for their requests, and the number of credits you’ll need really depends on how complex the method is. For the most frequently used ETH JSON-RPC calls, you’re looking at 80 credits each. However, if you’re diving into heavier methods, be prepared to spend more--like for eth_getBlockReceipts, which will hit you for 1000 credits. Debug methods also cost 1000, while Trace methods run at 300 credits. And if you're using Bundler (AA) methods, those can set you back several thousand credits per call.

Don't forget about error handling, either! If you encounter error codes 429 or 402, those won't cost you any credits. For 4xx errors, you'll burn through 5 credits, but 5xx errors are on the house. As for archive requests, they currently carry the same price tag as non-archive requests, but that might change down the line. You can find more details here.

Here are some quick conversions to keep in mind while you're planning:

• When thinking about “80-credit calls” per day:
  • For Core, it’s about 3,000,000/80 which gives you around 37,500 calls.
  • For Developer, it rounds up to about 187,500 calls.
  • And for Team, you’re looking at roughly 937,500 calls. You can check out more details here.
• Now, if you want to break it down to calls per second (using those 80-credit calls):
  • Core comes in at about 500/80, so that’s around 6.25 calls/sec.
  • Developer amps it up to 4,000/80, which equals about 50 calls/sec.
  • For Team, that’s a solid 40,000/80, translating to 500 calls/sec. Again, you can find more info here.

Here’s a breakdown of the credit costs (all in ETH unless stated otherwise):

• For 80 credits, you can use: eth_blockNumber, eth_call, eth_getBalance, eth_sendRawTransaction, eth_getBlockByNumber
• If you’re looking to log things, eth_getLogs will set you back 255 credits.
• For tasks like estimating gas or tracing, it’s 300 credits for eth_estimateGas and any trace_* functions.
• Need block receipts or debugging? That’ll cost you 1000 credits for eth_getBlockReceipts and debug_* methods.
• On the subscription side, here’s the deal: newHeads will take 50 credits per block, logs will cost 300 credits per block, and keeping an eye on newPendingTransaction runs about 200 credits per second (per stream).
• If you’re using the Bundler (AA), it’s 4,950 credits for eth_sendUserOperation and 1,980 credits for eth_estimateUserOperationGas.
• And for Solana, expect to spend 160 credits for each method call.

These numbers are all straight from the official credit cost tables. You can check them out here.

Daily Resets and Rate Limiting:

• Credit quotas refresh every day at 00:00 UTC. Once you hit that daily cap, all traffic stops, and WebSocket connections are dropped until the next reset. If you go over the per-second throughput, you'll get an HTTP 429 response. Check out the details here: (docs.metamask.io)

---

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

Infura gives you access to over 40 networks through reliable HTTPS and WebSocket endpoint formats. This includes popular options like Ethereum mainnet, Sepolia, and Holesky, along with Layer 2 solutions such as Arbitrum, Optimism, Base, zkSync Era, Scroll, and Linea. You can also tap into Polygon PoS, Avalanche C-Chain, BNB Smart Chain, Starknet, and more. For a complete list of endpoint URLs for each chain, check out the “All endpoints” section in the docs. (infura.io)

Here's a handy snippet you can use for your Infrastructure as Code (IaC):

• Base mainnet HTTPS: https://base-mainnet.infura.io/v3/
• Base mainnet WSS: wss://base-mainnet.infura.io/ws/v3/
• Arbitrum mainnet HTTPS: https://arbitrum-mainnet.infura.io/v3/ (docs.metamask.io)

New ecosystems are popping up thanks to partners as well. For example, the Unichain docs mention that Infura serves as a node provider for both the Unichain mainnet and Sepolia. Be sure to check the “All endpoints” page to confirm availability before launching. (docs.unichain.org)

---

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

Infura’s Decentralized Infrastructure Network (DIN) is all about routing traffic through independent providers. Back in November 2025, they rolled out an EigenLayer AVS, aiming to boost decentralized economic security and performance. Right now, DIN is handling over 13 billion requests a month across more than 30 networks. You’ll see “Decentralized by DIN” access included in all plans; however, keep in mind that the extra DIN failover and resilience features have typically been bundled into the higher-tier plans, so it’s a good idea to double-check that during procurement. (theblock.co)

Key Takeaways for Decision-Makers:

• Diminishes the risk of relying on a single provider: This approach helps to spread out potential issues and enhances resilience.
• Brings in verifiability and boosts incentives for performance and uptime with restaked ETH: By utilizing restaked ETH, teams can expect better reliability and accountability.
• Expands network coverage rapidly: In 2024, we’re expecting to see additions from projects like Blast, Mantle, Starknet, zkSync, BSC/opBNB, and Scroll. You can read more about it here.

---

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

Infura has rolled out some pretty impressive key controls in the MetaMask Developer dashboard:

• API Key Limits by Plan: You've got different limits depending on your plan--Core gives you 1 key, Developer offers 5, and Team+ lets you create as many as you want. It's a good idea to set up separate keys for each environment and app surface. (infura.io)
• Allowlists: You can narrow things down by specifying contract addresses, HTTP Origins, User-Agents, and the JSON-RPC methods that are allowed. You can have up to 30 entries for each type; remember, types are combined with AND, while multiple entries in one type are combined with OR. Oh, and if you're using Origins, wildcard subdomains are totally supported! (docs.metamask.io)
• API Key Secret: For server-side calls, you’ll need to use a “secret.” If you’re on Developer+, you can bypass your allowlists when using this secret (this follows the principle of least privilege on the client side, but gives you more freedom on the server side). (docs.metamask.io)
• Per-Key Credit Caps: You can set daily and per-second credit limits to make sure a leaked key doesn’t blow your budget. If you hit your self-imposed caps, you'll get a 429 error with a detailed message explaining what happened. (docs.metamask.io)
• Request Visibility (Analytics Retention): For the Core plan, you can keep track of usage for up to 24 hours, while paid plans extend that to 30 days. It’s smart to monitor usage and set up alerts when you reach 75/85/100%. (infura.io)

Minimal Server-Side Example with API Key Secret

If you’re looking to get started with a simple server-side setup using an API key secret, you’re in the right place. Here’s a straightforward example to help you along.

Setting Up Your Environment

First things first, you’ll need to create a new directory for your project and navigate into it:

mkdir my-server-app
cd my-server-app

Next, you’ll want to initialize your Node.js project:

npm init -y

After that, go ahead and install the necessary dependencies:

npm install express dotenv

Create Your .env File

You should store your API key secret in a .env file to keep it safe. Create a file named .env in your project root and add your key like this:

API_KEY=your_api_key_here

Build the Server

Now, let’s create a basic Express server. Make a new file called server.js and open it up to write some code:

const express = require('express');
const dotenv = require('dotenv');

dotenv.config();

const app = express();
const PORT = process.env.PORT || 3000;

app.get('/api/data', (req, res) => {
    const apiKey = process.env.API_KEY;

    // Imagine this is where you'd typically call an external API
    res.json({
        message: 'Here’s some data!',
        apiKeyUsed: apiKey,
    });
});

app.listen(PORT, () => {
    console.log(`Server is running on http://localhost:${PORT}`);
});

Running Your Server

You can kick off your server by running:

node server.js

Once it's up and running, you can head over to http://localhost:3000/api/data in your browser or use a tool like Postman to see the response.

A Quick Note

Make sure to never share your .env file or the keys inside it publicly, as it can compromise your project's security.

And that’s a wrap on this minimal server-side example! Now you're ready to start building more complex features with your API key secret safely in place.

# 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 lets you use secret-based override (Developer+) while keeping your client key allowlisted and limited. Check it out here: (docs.metamask.io)

Browser note: Infura provides exact-origin CORS headers instead of the wildcard “*” when authentication is in play. To keep your secrets safe, it's best to avoid putting them on the client side. Instead, consider using a lightweight backend or signed JWTs for better security. (support.infura.io)

---

Practical capacity planning: translate credit math into tiers

Check out these real-world patterns that show how daily credits and throughput line up. Go ahead and swap out the volumes with your own projections.

1. Wallet/dapp home screen (ETH L1)

• When you first load up the app, it makes a bunch of calls: eth_blockNumber (80), eth_getBalance (80), eth_call (80) for a few contracts, and eth_getLogs (255) to grab the latest user events. So, if you do the math, that’s around 655 credits for each fresh load (80*5 + 255 = 655).
• With about 10,000 daily active users and no caching in place, we're looking at roughly 6.55 million credits per day. That would mean a fine of around 15 million for developers and a pretty insufficient 3 million for Core. But don’t sweat it--if you set up caching and WebSocket for new blocks, you could totally slash those numbers by 50-70%. Check out more on this over at docs.infura.io.

1. Indexer grabbing receipts per block

• Using eth_getBlockReceipts will set you back 1000 credits. If you’re scanning around 7,200 blocks a day (which is about a 12-second block time), that’s roughly 7.2 million credits per day for each chain. It’s a good idea to go with the Team plan for this, or you could split up the job, cache some data, and focus on the blocks you really need first. (docs.infura.io)

3) Realtime updates via WebSockets

• Using eth_subscribe for newHeads will run you 50 credits for each block per subscription. With around 7,200 blocks coming in each day, that adds up to about 360,000 credits daily for every active subscriber. If you've got 100 live sessions kicking off at the same time, you're looking at roughly 36 million credits a day. That's a lot! A Developer plan might not cover that, so you might want to think about going with a Team plan or shifting more of the logic over to the server-side with a fan-out strategy. (docs.infura.io)

1. Heavy Debugging and Tracing

• When it comes to Debug and Trace methods, you’re looking at a cost of 1000 or 300 credits each time. If you have a QA pipeline that’s tracing around 5,000 transactions a day, that’s about 5 million credits burned daily. Sure, that works for Developer plans, but it doesn’t leave much wiggle room for production traffic. To avoid a credit crunch, try running traces during off-peak times and caching the results. Check out the details here: (docs.infura.io)

1. Account Abstraction (Bundler)

• Sending a eth_sendUserOperation costs 4,950 credits. If you're looking at around 10,000 user operations a day, that's roughly 49.5 million credits. This is based on the Team tier's baseline. Just a heads up--if your usage spikes, you might want to plan for that as well (think about your per-second budget). Check out more details here.

1. Solana Program Reads

• Every Solana method you call takes up 160 credits. So, if you're looking at around 1 million Solana method calls in a day, you're going to need about 160 million credits. That means you'll need either an Enterprise or Team plan, along with some add-ons. Check out the details here: (docs.infura.io)

Throughput Guardrails

• Transform your hot path into credits per second. For instance, if you're averaging around 100 calls per second that each use 80 credits, you'll need about 8,000 credits per second. In this case, a Developer plan with 4,000 credits would hit the limit and return a 429 error. Instead, a Team plan offering 40,000 credits would be a better fit. Check out the details here.

Reset Behavior and Error Economics

• The daily cap kicks in and pauses HTTP requests as well as WebSocket connections until it hits 00:00 UTC. If you get a 429 or 402 error, no charges apply! Just keep in mind that 4xx errors will cost you 5 credits each, while using bogus methods will rack up a hefty 160 credits. So, it’s a good idea to steer clear of tight loops and make sure to validate your methods in your CI processes. Check out the details here: (docs.metamask.io)

---

Choosing the right 2026 tier: a decision framework

Let’s kick things off with three main axes: daily credits, throughput, and your security/ops needs. From there, you can choose a minimum tier:

• Credits/day
  • ≤ 3M: This tier is ideal for POCs or small internal tools (think around 37.5k “80-credit” calls each day).
  • 3M-15M: Perfect for developers working on small production dapps or AA pilots.
  • 15M-75M: Great for teams handling mainstream traffic or launching on multiple chains.
  • > 75M: Best suited for enterprises or additional features. (docs.metamask.io)
• Throughput (credits/sec)
  • ≤ 500: Core; handles around 6 “80-credit” calls per second.
  • ≤ 4,000: Developer; manages about 50 calls per second.
  • ≤ 40,000: Team; can sustain around 500 calls per second.
  • For those unpredictable bursts: Enterprise. (docs.metamask.io)
• Security and governance
  • Looking for per-key allowlists, server secrets with overrides, multiple environment keys, and longer analytics retention? Kick things off with the Developer plan; go Team if you've got a bunch of squads needing their own keys. Check out the details here: (docs.metamask.io)
• Reliability
  • For those of you needing decentralized failover and SLAs, make sure to check out the DIN packaging and Enterprise SLAs with the Consensys Sales team. You’ll find “Decentralized by DIN” endpoints available in different plans. Just a heads up, advanced failover options have traditionally been linked to the higher tiers. (infura.io)
• Add-ons
  • If your math ends up slightly over a tier threshold, consider the $200 add-on for an extra 55M credits--it could be your most cost-effective option. Just make sure you model your daily needs and throughput together to steer clear of those pesky 429s. (infura.io)

---

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

• Set per-key hard caps: Keep those key-level credit limits 10-20% below your plan for per-second and per-day usage. This way, if something goes sideways with your app, you'll receive structured 429 responses, which is definitely better than a free-for-all. Check out the details here.
• Split keys by environment and surface: It's a smart move to have separate keys for your production frontend, backend, indexers, and QA. Each should have its own allowlists and caps. Think Core=1 key, Dev=5 keys, and Team+ gets unlimited. More info can be found here.
• Apply allowlists everywhere:
  • Client keys: Limit access by Origin and allowed methods.
  • Server keys: Make sure you require the API key secret and override allowlists, at least for Developer+.
  • Contract address allowlists come in handy if your reads are scoped. More details here.
• Use WS judiciously: Subscriptions will cost you per block/event, so don’t go opening hundreds of logs streams straight from the browser. It’s way better to consolidate everything on the server and then fan it out with your own WebSocket/GraphQL. You can read up on pricing here.
• Cache aggressively:
  • Keep a cache of historical blocks, receipts, and code. Remember, Ethereum L1 reorgs are usually shallow, so anything older than a few blocks can definitely be cached.
  • Try to use eth_subscribe for new data, and only fall back to HTTP for backfilling when absolutely necessary. More insights here.
• Watch method mix: The eth_getLogs (255) and Debug/Trace (1000 / 300) calls usually munch through budgets pretty quickly. So, consider refactoring your indexers to prioritize targeting addresses/topics first, then only escalate to those heavy calls when you're off the hot path. See more about it here.
• Analytics and alerting: Make the most of the dashboard by keeping an eye on your per-method credit usage and set up email alerts at 75/85/100%. Remember, your retention gets better with a higher plan. Check it out here.

---

Example scenarios with exact budgets

NFT Gallery on Ethereum and Polygon PoS

• When it comes to the home load (cached), you’ll be using eth_blockNumber (80), plus two eth_call (160 each), and one eth_getLogs (255) per chain. That adds up to about 495 credits per chain. So for two chains, you're looking at roughly 990 credits for an uncached load.
• With around 5,000 daily users and a 60% cache hit rate, you can expect about 2,000 “uncached” loads. That brings you to roughly 2 million credits a day. It definitely meets the core requirements, but you'll be pushing it if you add WebSocket or search features. The developer options give you some breathing room, along with Debug/Trace to help you sort out any issues. Check out the details here: (docs.infura.io)

On-chain Analytics Dashboard with Receipts

• Hourly Task: Grab receipts for the last 300 blocks → That means 300,000 credits each hour → Which totals up to about 7.2 million credits a day. The current team tier seems like a good starting point; you might want to think about sampling or tapping into logs by topic instead. Check it out here.

3) Account Abstraction MVP on L2

• We’re seeing about 2,000 user operations each day, which translates to around 9.9 million credits daily just for sendUserOperation. If you factor in some reads, you're looking at roughly 12 to 14 million daily. This is a solid fit for developers; if you’re planning for growth, consider upgrading to Team for better throughput. (docs.infura.io)

4) Solana Bot Fleet

• We’re looking at a solid 300 requests per second sustained, with each request using 160 credits. That’s a whopping 48,000 credits per second! The team can handle around 40,000 requests per second, so we’re likely to run into some 429 errors. To take it up a notch, we’ll need either an enterprise-level throughput or a hybrid architecture. Check out the details over at docs.infura.io.

---

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

• First, head over to the MetaMask Developer dashboard and sign up. You’ll get a handy “My First Key” automatically created for you. Just make sure to limit the networks for each key--only enable the endpoints that you actually plan to use. You can find more details here.
• It's a good idea to create separate keys for each environment and surface, like frontend and backend. Just a heads up, the plans restrict you to a certain number of keys: 1 for Core, 5 for Developer, and unlimited for Team+. If you're curious about more specifics, check this link: Docs.
• Don’t forget to enable the API key secret for server calls! You can also choose to override allowlists if you’re on Developer+. And remember, keep those secrets out of any client-side code to stay secure. More information can be found here.
• Lastly, set up those allowlists! You’ll want to specify origins for the browser, contract addresses for scoped reads, and allowed methods to help minimize any potential attack surface. You can have up to 30 entries for each type, and they can be combined as AND across types or OR within the same type. For a deeper dive, check out this link: Docs.

---

Expansion APIs and features that can tilt your math

• Gas API: The EIP‑1559 fee endpoints will set you back about 80 credits for each call. If you start incorporating these into your fee estimation pipelines, you can expect a pretty predictable increase in read volume. Check it out here.
• Full Archive Access: Right now, it costs the same in credits as non-archive reads, but keep in mind that this could change down the line. More details can be found here.
• IPFS/Dedicated Gateway: Access is currently only available to pre-qualified customers. If you’re looking for subdomain gateways for your NFT or media projects, it’s best to apply sooner rather than later. Get the scoop here.
• Crypto Payments: These are on the table for custom plans (Enterprise level). You can find out more here.

---

Plan selection cheatsheet (fast mapping)

• Prototyping, Hackathon, or Internal Tool:
  • Core. Keep things under about 37.5k “80-credit” calls per day and around 6 calls per second. Make sure to use caching and avoid heavy debug/trace in production. Check out the details here: (docs.metamask.io)
• Small Production DApp (Single Chain), Light AA, Steady 25-50 Calls/sec:
  • Developer. This plan lets you enable Debug/Trace, offers 5 keys, Settings Override, and a solid 4k credits per second. More info here: (infura.io)
• Consumer App or Multi-Chain Launch; Log-Heavy Analytics; Hundreds of Calls/sec:
  • Team. You get 75M calls per day and 40k credits per second, plus unlimited keys and prioritized support. Dive into the details here: (infura.io)
• Exchange/Aggregator-Scale, Solana + EVM Multi-Chain, or AA at Volume:
  • Enterprise. This one’s all about custom throughput, autoscaling, SLAs, and crypto payments. Just don’t forget to confirm the DIN failover specifics. More info can be found here: (infura.io)
• On the Fence Between Tiers:
  • Consider snagging the $200 add-on for an extra 55M credits per month to help you bridge those gaps without jumping a whole tier--then keep an eye on your throughput. Check it out here: (infura.io)

---

7Block Labs’ emerging best practices for 2026

• Start by designing with “credits/second” in mind. The biggest reason for outages we see isn’t due to daily limits--it’s those per-second spikes. So, figure out your peak credits per second and consider moving up a tier if real-time performance is crucial. (docs.metamask.io)
• Go for server fan-out when it comes to WebSockets. You only need one backend subscription per topic, and then you can have multiple client subscribers through your infrastructure. This approach will really cut down on your subscription credit usage. (docs.infura.io)
• Keep an eye on those “expensive” queries. Make sure to tag things like eth_getLogs, Debug, Trace, and Bundler calls in your telemetry; budget for them separately, and try to run the heavier jobs during off-peak times. (docs.infura.io)
• Use the Decentralized Infrastructure Network (DIN) as a safety net, but don’t skip out on caching. DIN can help reduce related failures, but a solid caching strategy and backoff can keep your bills from ballooning. (theblock.co)
• Set up allowlists in your Continuous Integration (CI) process. Treat the allowed methods and origins for your key like code--if someone tries to add methods without updating the budget, make sure their pull requests don’t get merged. (docs.metamask.io)

---

Final checklist before you buy

• Break down your 30-day method mix into credits per day and credits per second instead of just focusing on "requests." Use the 80/255/300/1000/4950 benchmarks from the official table. (docs.infura.io)
• Check out the network coverage in “All endpoints” for each chain that’s on your roadmap. (docs.metamask.io)
• Figure out your main topology (env/surface) and set those per-key caps and allowlists right from day one. (docs.metamask.io)
• If you’re in a regulated space or an environment that’s always running, make sure to double-check DIN packaging and SLAs. (infura.io)
• If you find yourself hovering around 10-20% of a tier boundary, think about whether it makes more sense to grab some add-on credits or step up to a higher tier. Don’t forget to look at both daily and per-second headroom. (infura.io)

---

Bottom line

Infura’s pricing for 2026 is pretty straightforward once you start thinking in terms of credits instead of requests. If your workloads mainly consist of 80-credit reads and have a moderate workload size, the Developer plan usually works just fine. However, if you're dealing with heavy logs, receipts, traces, or using the Bundler, you’ll likely want to consider the Team plan as your starting point.

For those needing cross-ecosystem scalability or focusing heavily on Solana throughput, it’s best to explore the Enterprise option. Don’t forget to ask about DIN-backed failover and SLAs that align with your risk model. Check out the details here: (docs.metamask.io)

---

Description

Here's your go-to guide for everything you need to know about Infura’s pricing in 2026 and how to set up your API key. We'll break down credit costs by method, dive into throughput calculations, touch on DIN reliability, and give you some real-life examples to help you choose the best tier for your needs. Check out the details here: (docs.metamask.io).