Summary: Infura is the reliable gateway from Consensys for Ethereum and popular Layer 2 solutions. It offers HTTPS and WebSocket JSON-RPC, along with handy higher-level APIs like Gas and Trace. In this post, we'll dive into how Infura links your applications to Ethereum, highlight what's fresh since Dencun/EIP-4844, and explore practical patterns to create reliable and cost-effective web3 backends for both startups and enterprises.

Infura Blockchain APIs Key Features: What Is Infura and How Does It Connect to Ethereum?

Understanding Infura: A Practical Guide for 2026

When decision-makers dive into the world of blockchain infrastructure, they usually have a common goal: ship faster, fail less, and keep costs predictable while the tech keeps evolving. That’s where Infura steps in. It simplifies the whole node operation scene with stable, high-throughput APIs for Ethereum and a growing selection of Layer 2s and alternative Layer 1s. Plus, it throws in some handy services like gas estimation, traces, and account-abstraction bundling.

Here’s a practical, up-to-date guide from 7Block Labs that breaks down what Infura is, how it connects with Ethereum, and tips on making the most of it in 2026.

What Infura is (in practice)

At its heart, Infura serves as a managed access layer to Ethereum execution clients and related services. Your app communicates with Infura using standard JSON‑RPC over HTTPS or WebSockets, and Infura takes care of clustering, client diversity, scaling, archive data, and failover for you. For a lot of methods, you’ll get the same wire format as you would from a self-hosted node--just without the hassle of running one. Plus, Infura now offers higher-level APIs like:

Gas API (the same tool that powers MetaMask) gives you solid EIP‑1559 fee suggestions across a bunch of different chains. Check it out here.
Trace API (currently in open beta) lets you debug and analyze transactions and contracts. Dive in here.

And behind the scenes, Infura is working on decentralizing how requests are routed and supplied through the Decentralized Infrastructure Network (DIN). This just rolled out as an EigenLayer AVS, which aims to enhance crypto-economic security and allow anyone to participate as a provider for RPC. (theblock.co)

How Infura connects to Ethereum

1) Transport and endpoints

Your app connects via specific endpoints for each network:

HTTPS: This is used for stateless requests like eth_call, eth_getLogs, and eth_getBlockByNumber.
WSS: This is great for two-way subscriptions. You can use it for eth_subscribe options like newHeads, logs, and newPendingTransactions--just keep in mind that availability can differ by network. (docs.metamask.io)

Representative endpoints (don’t forget to swap in your API key):

For Ethereum Mainnet, you can use: https://mainnet.infura.io/v3/ and wss://mainnet.infura.io/ws/v3/.
If you're looking into Layer 2 solutions like Base, Optimism, Arbitrum, Linea, Polygon, or Scroll, each of them has its own hostname for both HTTPS and WSS. You’ll find the full lists and formats in the MetaMask Developer Services documentation. Check it out here: docs.metamask.io.

Notes that Matter in 2026:

Climate Change Initiatives
- Countries have ramped up efforts and are sharing innovations to combat climate change. For more details, check out our Climate Change Info.
Advancements in AI
- Artificial Intelligence continues to evolve, impacting various sectors from healthcare to education. The latest AI breakthroughs are summarized here: AI Innovations.
Remote Work Trends
- The remote work culture has solidified, with hybrid models becoming the norm. Explore insights on this shift: Remote Work Trends.
Mental Health Awareness
- There’s been a significant push towards mental health resources and destigmatization. You can find some helpful resources at Mental Health Support.
Sustainable Living Practices
- More people are embracing eco-friendly lifestyles, including zero waste and plant-based diets. Join the movement with tips from Sustainable Living.
Digital Privacy Concerns
- With ongoing discussions about data privacy, it's crucial to stay informed about your online footprint. Learn more about keeping your data safe here: Digital Privacy Tips.
Tech Integration in Education
- Schools are increasingly adopting tech tools for better learning experiences. Check out the latest in educational tech: EdTech Innovations.
Health Tech Innovations
- Wearable health tech is becoming more common, helping people track their fitness and well-being easily. Discover more about these innovations at Health Tech.
Cultural Shifts
- Society is seeing changes in cultural norms and values, with an increased focus on inclusivity and diversity. Read more on this topic: Cultural Shifts.
Economic Developments
- The global economy is evolving, with new markets emerging and industries adapting to new realities. Get the latest updates in our economic roundup: Economic Developments.

Stay updated and engaged with these important notes - they’re shaping our world in 2026!

So, Goerli is pretty much on its way out across the board; it's time to focus on Sepolia and Holesky for your testing needs. Infura has also pointed everyone in the direction of moving away from Goerli. You can check out more about it here.
When it comes to IPFS, just a heads up: new users can't create keys anymore since late 2024, but if you already have a key, you're still good to go. More details can be found here.
For Solana, access is a bit exclusive and only available to a select group of customers. You can read more about that here.

2) Authentication and security controls

API keys are great for tracking usage, and if you want, you can ask for a secret API key for server-to-server Basic Auth.
Allowlists are handy because they let you limit access based on address, JSON-RPC method, Origin, and User-Agent. You can set up detailed rules for each key. Plus, using a secret lets you bypass the allowlists for backend traffic while keeping client keys secure. (docs.metamask.io)
Just a heads up: don’t send the API key secret from browsers--CORS will block those authenticated requests. It’s better to route sensitive calls through your backend. (support.infura.io)
Quick note on free vs. paid tiers: the free plan gives you one key, but the paid options let you have more keys and controls. (docs.metamask.io)

3) Throughput and quotas

Infura uses a credit-based system with limits both daily and by the second, depending on your plan (according to help-center info from Nov-Dec 2025):

Core (Free): 6,000,000 credits per day; 2,000 credits per second
Developer: 15,000,000 credits per day; 4,000 credits per second
Team: 75,000,000 requests per day; 40,000 credits per second (support.infura.io)

Operational Transparency

Infura has a handy public status page where you can check out component uptimes and any incidents that pop up. Make sure to integrate this into your on-call runbook for easy access. Check it out here: infura.statuspage.io.

Features decision‑makers care about in 2026

Multichain coverage, maintained endpoints

Infura offers solid production endpoints for Ethereum and key Layer 2 solutions like Base, Optimism, Arbitrum, Linea, and Polygon. They also support networks like Blast, BSC/opBNB, Avalanche, Starknet, Scroll, and a bunch more. Everything’s nicely laid out with reliable URLs (HTTPS/WSS), which really helps keep things on track when networks decide to change names or retire testnets. Check it out here: (docs.metamask.io)

Real‑time subscriptions (WSS)

Use `eth_subscribe` over WSS for:

Real-time Updates: Get instant notifications for specific events as they happen on the blockchain. No more manual polling!
New Blocks: Stay in the loop with new block headers as they are mined. Perfect for tracking the latest changes.
Pending Transactions: Keep an eye on transactions that are yet to be confirmed. Great for monitoring your own transactions or just seeing what's coming through.
Logs and Events: Subscribe to specific smart contract events and logs. This is super useful for developers who want to know when certain actions occur.
New Pending Transactions: Want to see what’s being added to the mempool? This will keep you updated on those transactions waiting for confirmation.

Here’s how to set it up

You’ll want to use a WebSocket connection for this. Here's a simple example of how to do it:

{
  "jsonrpc": "2.0",
  "method": "eth_subscribe",
  "params": ["newPendingTransactions"],
  "id": 1
}

Just send that message over your WSS connection, and you’ll start receiving notifications for new pending transactions! Easy peasy.

Why use WSS?

Using WebSocket (WSS) is a game-changer because it keeps a constant connection open. This means you don’t have to keep hitting the server for updates, which saves bandwidth and improves responsiveness. Plus, you get real-time data, which is pretty nifty!

Conclusion

If you’re looking to get the most out of your Ethereum experience, leveraging eth_subscribe over WSS is definitely the way to go. Happy coding!

newHeads: This gives you the latest updates on chain progress and keeps you in the loop about any reorgs happening.
logs: Think of this as your event streams, complete with handy address/topic filters. Highly recommended for staying organized!
newPendingTransactions: This is like a firehose for the pending transaction pool, though it’s not available on all networks. You can check it out here.

Infura suggests that you filter your log subscriptions to cut down on unnecessary noise and save some cash. Also, make sure you’ve got reconnection and backoff strategies in place for those long-lived sockets. Check out the details here: (support.infura.io).

Archive and Trace data

Archive data: Infura has your back when it comes to digging into historical states. You can read data from far beyond 128 blocks on major networks, which is super handy for those past-state requests like eth_call and eth_getBalance at earlier heights. Check out more about it here.
Trace API (open beta for paying customers): If you’re a paying customer, you’ll love the Trace API! It gives you access to trace_block, trace_call, trace_filter, and trace_transaction, letting you explore step-by-step EVM traces, internal calls, and state diffs. This is great for diving deep into analytics, forensics, and debugging. Want to know more? Click here.

Gas API (MetaMask‑grade fee estimation)

The Gas REST API gives you access to both current and historical EIP-1559 estimates on various chains like Ethereum, Linea, Base, and Optimism. It’s the same tech behind MetaMask’s estimator and is now widely available through Infura. This really helps cut down on under- and over-pricing and supports better control during those crazy, volatile blocks. Check it out here: (infura.io)

Account Abstraction (ERC‑4337) bundler integration

Infura has teamed up with Pimlico's bundler, making it super easy to access standard 4337 JSON‑RPC methods on both Ethereum Mainnet and Sepolia. You'll find methods like eth_sendUserOperation, eth_estimateUserOperationGas, eth_getUserOperationReceipt, along with some handy pimlico_* helper methods. If you're working on a smart account experience--think gas sponsorship, batched actions, or session keys--you can start using these endpoints right now. Check it out here: (docs.metamask.io).

EIP‑4844 (Dencun) support: blob transactions and fees

After Dencun, Ethereum introduced something pretty cool: "blob-carrying" transactions, which are also known as type-3 transactions. These come with some new fields like max_fee_per_blob_gas and blob_versioned_hashes. Infura has jumped on board with this and now supports related methods (like eth_blobBaseFee), making it easier for Layer 2 solutions to post data cheaply to Layer 1. This really opens up some exciting possibilities for data availability.

Blobs themselves have a short life--around 18 days--and they're priced through a separate EIP-1559-style market that deals with “blob gas.” You can check out all the nitty-gritty details over at the official EIP documentation: (eips.ethereum.org).

Why It Matters to You:

Understanding the importance of this topic can really make a difference in your life. Here’s why you should care:

Impact on Daily Life: This isn't just some abstract concept; it directly affects how you go about your day-to-day routine.
Informed Decision Making: Being knowledgeable helps you make better choices, whether it’s about finances, health, or personal relationships.
Long-Term Benefits: The implications of this topic are long-lasting. Taking it seriously now could save you a lot of trouble down the road.
Community and Connection: Engaging with this subject can help you connect with others who feel the same way. You’re not alone in this!
Empowerment: Knowledge is power! The more you learn, the more equipped you’ll be to handle whatever life throws at you.

So, take a closer look and see how it relates to your own life. It could lead to some pretty neat changes!

Big reductions in L2 fees (often under a cent) and clear-cut DA costs.
If you're working on rollups or any features that need a lot of data: make sure to update your clients and SDKs to handle type-3 transactions, blob fee calculations, and KZG commitments where you create blobs on the client side. Libraries like ethers v6 have got you covered with blob fields and KZG hooks. Check it out here: (docs.ethers.org)

Resilience and decentralization via DIN

DIN’s EigenLayer AVS Launch: Transforming RPC into a Verifiable, Economically Secured Marketplace

So, what’s the deal with DIN’s EigenLayer AVS launch? Well, it's pretty exciting because it’s all about turning RPC into something way more reliable and secure. Here’s what that means in simpler terms:

Verifiable Marketplace: You can trust that the services you’re using are legit and match up with what they claim to provide.
Economic Security: There’s real financial backing here, which helps keep everything stable and secure.
Enhanced Accessibility: Users will have a smoother experience accessing services, thanks to improved processes and features.

In a nutshell, DIN is stepping up the game by making this marketplace not just more secure but also way more user-friendly!

Easy onboarding for node operators and watcher roles without any permissions needed
Ongoing performance incentives and potential slashing mechanisms
Smart routing and failover systems built right into the Infura/MetaMask pathways

This helps lower the risk of problems when a single provider goes down and also boosts service level objectives (SLOs) when scaled up. (theblock.co)

Optional MEV protection path

As of March 11, 2025, Infura has rolled out MEV protection for Ethereum transactions sent through eth_sendRawTransaction. This upgrade helps safeguard developers on the free tier from common sandwich and frontrunning attacks by utilizing private routing with trusted builders. It’s a big win for consumer wallets and retail users. Check out more details over at metamask.io!

Practical integration patterns with code

Here are some tried-and-true snippets that your teams can easily tweak to fit their needs.

Connect with ethers v6 (HTTPS) and get the latest block

import { JsonRpcProvider } from "ethers";

const provider = new JsonRpcProvider(
  `https://mainnet.infura.io/v3/${process.env.INFURA_API_KEY}`
);

const n = await provider.getBlockNumber();
console.log("L1 block:", n);

You can find the endpoints for other networks by checking out the docs’ hostnames, like base-mainnet.infura.io or optimism-mainnet.infura.io. For more info, head over to docs.metamask.io.

import WebSocket from "ws";
import ReconnectingWebSocket from "reconnecting-websocket";

const url = `wss://mainnet.infura.io/ws/v3/${process.env.INFURA_API_KEY}`;

const ws = new ReconnectingWebSocket(url, [], { WebSocket, maxRetries: 1e9 });

ws.addEventListener("open", () => {
  // newHeads (new blocks)
  ws.send(JSON.stringify({
    jsonrpc: "2.0", id: 1, method: "eth_subscribe", params: ["newHeads"]
  }));
  // logs (filtered)
  ws.send(JSON.stringify({
    jsonrpc: "2.0", id: 2, method: "eth_subscribe",
    params: ["logs", { address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
                       topics: ["0xddf252ad..."] /* Transfer() */ }]
  }));
});
ws.addEventListener("message", (m) => console.log("event", m.data));

Check out the address and topic filters for your logs, and don’t forget to keep an eye out for those “removed: true” occurrences during reorgs. You can find more details here.

Page through event history safely (eth_getLogs)

When you're dealing with big log pulls, it's important to break them up into pages. Try to keep your requests between 2,000 to 5,000 blocks each. Most providers have a limit of 10,000 results, so sticking to this range will help you dodge timeouts and those unwieldy oversized responses.

async function getLogsPaged(provider, filter, step = 2000) {
  const latest = BigInt(await provider.send("eth_blockNumber", []));
  const from = BigInt(filter.fromBlock || "0x0");
  const to = filter.toBlock === "latest" ? latest : BigInt(filter.toBlock);
  const all = [];
  for (let i = from; i <= to; i += BigInt(step)) {
    const pageTo = i + BigInt(step) - 1n > to ? to : i + BigInt(step) - 1n;
    const logs = await provider.send("eth_getLogs", [{
      ...filter,
      fromBlock: "0x" + i.toString(16),
      toBlock: "0x" + pageTo.toString(16),
    }]);
    all.push(...logs);
  }
  return all;
}

Most providers have limits on the results or block ranges when it comes to eth_getLogs, so it's a good idea to use paging. Check out the details here.

Fetch live EIP‑1559 suggestions via Gas API (REST)

import axios from "axios";

const chainId = 1; // Ethereum Mainnet
const { data } = await axios.get(
  `https://gas.api.infura.io/v3/${process.env.INFURA_API_KEY}/networks/${chainId}/suggestedGasFees`
);
console.log(data); // { low: {...}, medium: {...}, high: {...}, ... }

Try using this instead of the basic eth_gasPrice; it’s MetaMask’s production estimator available through their API. Check it out here: (docs.metamask.io).

Run a transaction trace (open beta)

curl -X POST https://mainnet.infura.io/v3/$INFURA_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "trace_transaction",
    "params": ["0x<txHash>"]
  }'

Traces track internal calls and state changes, which are super helpful for audits, spotting fraud, and doing analytics. Check it out here: (docs.metamask.io)

Submit an ERC‑4337 UserOperation to Infura’s bundler

# Example: send a UserOperation to an ERC-4337 bundler (Mainnet/Sepolia)
curl -X POST https://mainnet.infura.io/v3/$INFURA_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{
    "jsonrpc":"2.0","id":1,"method":"eth_sendUserOperation",
    "params":[ { "sender": "0x...", "nonce": "0x0", "initCode": "0x", "callData": "0x",
                 "callGasLimit":"0x...", "verificationGasLimit":"0x...",
                 "preVerificationGas":"0x...", "maxFeePerGas":"0x...",
                 "maxPriorityFeePerGas":"0x...", "paymasterAndData":"0x", "signature":"0x" },
               "0x0000000071727De22E5E9d8BAf0edAc6f37da032" ] }'

Infura acts as a proxy to Pimlico’s infrastructure and comes with handy helper methods like pimlico_getUserOperationStatus. Make sure your EntryPoint addresses are kept up-to-date (for example, use 0x…7032 for v0.7). You can check out more details here.

Account for Dencun/EIP‑4844 blob fees

When you're working on type-3 transactions, be sure to read the blob base fee and adjust the max_fee_per_blob_gas to match. If you're using libraries like ethers v6, you can take advantage of transaction.blobVersionedHashes and the KZG hooks for handling commitments and proofs.

const blobBaseFee = await provider.send("eth_blobBaseFee", []);
// Set tx.maxFeePerBlobGas relative to blobBaseFee

Blobs hang out on the consensus layer and get pruned after about 18 days, so when you're planning for retrieval and audits, keep that timeframe in mind. Check out the details over at (eips.ethereum.org).

Emerging best practices (what’s new since 2024)

Make it a habit to build for EIP‑4844 right off the bat. If you’re running a rollup or posting data to L1, make sure to update your clients and monitoring tools to get a grip on blob fee dynamics and short retention. And when budgeting, think blob gas instead of calldata. (eips.ethereum.org)
Before you sign anything, definitely check out the Gas API. Set up some floor and ceiling logic, and don’t forget those consecutive-increase guards. If the Gas API is acting up and unreachable, you can always fall back to eth_feeHistory. (docs.metamask.io)
When it comes to user experience, go with WSS subscriptions, but keep a polling fallback just in case. Disconnects and reorgs are a reality, so make sure you’ve got reconnection and idempotent handlers in place. (docs.metamask.io)
For any log history queries, remember to page them out. Split by block ranges and tighten those address/topics. It’s quicker, cheaper, and helps you dodge those pesky result ceilings and timeouts. (therpc.io)
Check out the Trace API for tackling fraud, analytics, and support. It can seriously cut down on your ops time when you’re debugging tricky failures or sorting out false positives. (docs.metamask.io)
If you’re dealing with retail-facing transaction flows, definitely switch on MEV protection. Route eth_sendRawTransaction through Infura’s protected path and only fall back if there’s a serious SLO breach. (metamask.io)
Make your keys more secure by using allowlists and keeping secrets safe. Create keys specific to each environment (dev/stage/prod), limit methods and origins, and stash those secrets server-side to steer clear of CORS issues. (docs.metamask.io)
Plan for a decentralized RPC setup. With DIN now live on EigenLayer as an AVS, make sure your SLAs and incident playbooks are aligned to leverage multi-provider failover and hold on to crypto-economic accountability. (theblock.co)

Compliance and governance: rate limits and monitoring

Get a good grasp on your plan quotas right from the start (both per-second and daily limits). It's super important to size your ingestion, indexing, and alerting jobs carefully to avoid going over budget and triggering those annoying throttles. Check out the details here.
Integrate the Infura status page into your operations workflows. Make sure to set up alerts for any endpoint issues and consider failing over to partners that support DIN when you can. You can find more info here.

Quick start checklist for CTOs

Pick your endpoints: Start with the main L1 and then choose your target L2s from the endpoints catalog that’s been maintained. Check it out here.
Set up API keys: You'll need one key for each environment. Just enable the networks and services you need, and don’t forget to configure the allowlists. Get the details here.
Integrate the Gas API: Make sure to set your policy for fee bumps and timeouts. You can find the info here.
Use WSS for critical user experiences: For those essential flows, implement reconnection logic and have polling as a backup. You can read more about it here.
Add the Trace API: This is great for your investigation toolkit (note, it’s a paid feature). More info is available here.
For smart accounts: Don’t forget to link up with the ERC‑4337 bundler if you’re going that route. More details can be found here.
If you’re posting DA to L1 or working with L2s closely: Make sure to test type‑3 transactions and how blob fees are handled. Check it out here.
Document your quotas and SLOs: Keep everything organized and subscribe to status updates to stay in the loop. You can monitor that here.

Why teams choose Infura now

Velocity: Get the benefits of standard JSON-RPC along with familiar SDKs that feature higher-level APIs where it really matters (like Gas and Trace).
Reliability: Enjoy the strength of operational maturity combined with DIN-backed decentralization and failover capabilities. (metamask.io)
Future-proofing: We’ve got you covered with top-notch support for Dencun blobs, ERC-4337 bundling, and ever-evolving testnets. (docs.metamask.io)

At 7Block Labs, we combine these building blocks with delivery strategies--like gas policies, event ingestion pipelines, and AA wallet user experiences--to help you get value faster and reduce risks during production cutovers. If you're looking into an Infura-based reference architecture, we can compare it to other options or even hybrid setups (a mix of self-hosted and provider) for those compliance-focused workloads.

References and footnotes

Check out the official EIP‑4844 spec and learn about blob fee mechanics here: (eips.ethereum.org)
Curious about the Dencun/4844 effects on L2 fees and blob retention windows? Get the scoop at (info.etherscan.com)
Don't forget to look into the maintained Infura endpoints and the quirks of the network (like IPFS/Solana availability). Dive into the details here: (docs.metamask.io)
Need info on the Gas API and developer documentation? We've got you covered: (infura.io)
Exciting news! The Trace API is in open beta for paying customers, find out more here: (docs.metamask.io)
If you’re using WebSockets, check out subscription behaviors and guidance here: (docs.metamask.io)
Learn about DIN on EigenLayer AVS for a decentralized RPC supply and accountability at (theblock.co)
Keep track of plan quotas, including daily and per‑second credits, right here: (support.infura.io)
And don’t miss the MEV protection announcement from March 11, 2025! Check it out here: (metamask.io)

7Block Labs

At 7Block Labs, we’re all about helping startups and enterprises take their web3 systems to the next level. Whether you need a fresh perspective on your Infura rollout or a solid migration plan for your Dencun-aware infrastructure, we’re here for you. Let’s connect and chat about what you need!