Infura Blockchain APIs: Key Features Every Architect Should Know

Infura’s platform has evolved from “hosted Ethereum nodes” into a multi-chain, MEV-safe, failover-ready API layer with security controls and storage rails that large-scale apps can depend on. This guide distills the architectural capabilities you should actually plan around in 2025 and how to put them to work.

Summary: An expert, practical breakdown of Infura’s newest capabilities—DIN-based decentralized RPC, gas/trace analytics, WebSocket reliability improvements, IPFS dedicated gateways and rate limits, security controls, and concrete implementation patterns—so decision‑makers can evaluate fit and design resilient, cost‑aware blockchain backends.

TL;DR for decision‑makers

Decentralized Infrastructure Network (DIN) is live as an EigenLayer AVS, turning RPC into a decentralized, verifiable marketplace protected by restaked ETH; pilot phases logged sub‑250 ms median latency and >7–13B monthly requests across 30+ networks. (theblock.co)
Gas and Trace APIs that power MetaMask are available via Infura, enabling accurate EIP‑1559 fees, block history analysis, and granular debugging/security analytics. (infura.io)
WebSocket reliability for new-heads/logs has been hardened; use WS for push and HTTP for historical backfills, with reconnection logic. (infura.ghost.io)
Dedicated IPFS gateways with subdomain isolation and known RPS ceilings; plan caching and multi-gateway fallbacks. (docs.metamask.io)
Clear, posted limits with credit‑based pricing and per‑second quotas; exceeding daily quota hard‑stops traffic and severs WS connections at 00:00 UTC reset. (infura.io)

1) DIN: decentralized RPC your uptime architecture can lean on

Traditional hosted RPC has a single-provider blast radius. Infura’s Decentralized Infrastructure Network (DIN) changes that by aggregating independent node operators under a verifiable marketplace model. In November 2025, DIN launched an AVS (Autonomous Verifiable Service) on EigenLayer mainnet to secure the network with restaked ETH (e.g., stETH), with permissionless onboarding for node providers, watchers, and restakers. (theblock.co)

What this means for architects:

Economic security and independent performance verification—reduces correlated outages when a single vendor hiccups. (theblock.co)
Production latency targets are competitive (pilot median <250 ms) and have scaled to billions of monthly requests across 30+ networks; foundational node operators include EverStake, Liquify, NodeFleet, Validation Cloud, and more. (theblock.co)
Access to “Decentralized by DIN” endpoints exists across plans; enhanced failover resilience is reserved for higher‑tier plans—validate the exact tiering during procurement as packaging evolves. (infura.io)

Practical angle:

Treat DIN endpoints as your primary and keep a second provider (or another DIN network) as a tertiary safeguard in critical flows (trading, bridging).
Prefer a “circuit breaker + gray health” model: degrade to read‑only or queue writes when both DIN and your backup are degraded rather than failing requests explosively.

Example: ethers v6 FallbackProvider combining DIN + backup

import { JsonRpcProvider, FallbackProvider } from "ethers";

const dinPrimary = new JsonRpcProvider(process.env.DIN_RPC_HTTPS, {
  staticNetwork: "mainnet",
});
const backup = new JsonRpcProvider(process.env.BACKUP_RPC_HTTPS);

const provider = new FallbackProvider(
  [
    { provider: dinPrimary, stallTimeout: 800, priority: 1, weight: 2 },
    { provider: backup, stallTimeout: 1200, priority: 2, weight: 1 },
  ],
  1 // quorum: first successful
);

// Health probe before enabling writes
await provider.getBlockNumber();

Tip: include WS providers in a parallel FallbackProvider for streaming, but keep HTTP(S) for idempotent reads and catch-up historical calls.

2) Multichain coverage—with concrete, production‑ready endpoints

Infura supports major L1s/L2s including Ethereum, Linea, Polygon, Arbitrum, Optimism, Avalanche, Base, BNB Smart Chain, and others, with both HTTPS and WebSocket transports. Endpoint formats are consistent and easy to templatize. (docs.metamask.io)

Examples you can paste into infra-as-code (swap YOUR-API-KEY):

# Base
HTTPS=https://base-mainnet.infura.io/v3/<YOUR-API-KEY>
WSS=wss://base-mainnet.infura.io/ws/v3/<YOUR-API-KEY>

# Arbitrum
HTTPS=https://arbitrum-mainnet.infura.io/v3/<YOUR-API-KEY>
WSS=wss://arbitrum-mainnet.io/ws/v3/<YOUR-API-KEY>

# Avalanche C-Chain
HTTPS=https://avalanche-mainnet.infura.io/v3/<YOUR-API-KEY>
WSS=wss://avalanche-mainnet.io/ws/v3/<YOUR-API-KEY>

Linea specifics: Infura supports Linea (including Linea-specific RPC methods and WS), which matters if you rely on finalized-tag behavior or Linea’s gas estimation nuances. (docs.linea.build)

Bonus: Emerging networks via DIN. For example, Unichain documents Infura JSON‑RPC access (initially Sepolia) through DIN partnership—helpful if you’re piloting on new rollups. (docs.unichain.org)

3) Archive and Trace APIs for analytics, compliance, and security

Two powerful “beyond RPC” capabilities:

Archive access: Infura exposes full historical Ethereum state (older than 128 blocks) so you can query balances, storage slots, and state at arbitrary historical blocks—useful for BI, audits, and stateful analytics. Infura announced free archive access (plan‑bounded), which many teams still overlook in cost planning. (infura.io)
Trace API (Open Beta): unlocks granular execution traces per transaction/block for debugging, MEV/security analysis, and invariants verification—without maintaining your own full tracing node. (infura.io)

Examples you can ship:

Querying historical balance (archive):

curl -s https://mainnet.infura.io/v3/$INFURA_KEY \
 -H 'Content-Type: application/json' \
 -d '{
  "jsonrpc":"2.0","id":1,"method":"eth_getBalance",
  "params":["0x742d35Cc6634C0532925a3b844Bc454e4438f44e","0xA3B1C2"]
 }'

Tracing a transaction for internal calls (Trace API):

curl -s https://mainnet.infura.io/v3/$INFURA_KEY \
 -H 'Content-Type: application/json' \
 -d '{
  "jsonrpc":"2.0","id":1,"method":"trace_transaction",
  "params":["0xYOUR_TX_HASH"]
 }'

Design tips:

Gate “heavy” trace calls behind a job queue and cache normalized results; these are more expensive per request than standard RPC.
Build a “proof of compliance” dataset for your auditors: snapshot traces for withdrawals/settlements and store the digest.

4) Gas API and MEV protection: reduce failed txs and slippage

Infura exposes MetaMask’s battle‑tested Gas API, delivering dynamic fee suggestions across EIP‑1559 networks with block‑history analysis and consecutive‑increase controls. This is the same estimator used by millions daily in MetaMask. (infura.io)

As of March 11, 2025, Infura began enabling private mempool routing for free‑tier developers to protect against harmful MEV strategies by sending eth_sendRawTransaction to a virtual mempool auctioned to trusted builders—keeping transactions out of the public mempool until inclusion. This reduces front‑running and sandwich risk for retail UX and B2B flows alike. (metamask.io)

Implementation pattern:

Pull suggested fees from Gas API (or fall back to eth_feeHistory when unreachable).
Add a “fast‑fail” threshold for baseFee spikes and dynamically scale maxFeePerGas.
Route signed transactions via Infura’s MEV‑protected path; fall back to standard eth_sendRawTransaction only under operational SLO breach, not by default. (metamask.io)

Example using ethers v6 after obtaining suggestions:

import { Wallet, parseGwei } from "ethers";

const signer = new Wallet(process.env.PRIVKEY!, provider);
const fee = await getSuggestedFeesSomehow(); // your Gas API client

const tx = await signer.sendTransaction({
  to: "0xabc...",
  value: 0n,
  data: "0x",
  maxFeePerGas: parseGwei(fee.maxFeePerGas),
  maxPriorityFeePerGas: parseGwei(fee.maxPriorityFeePerGas),
});
await tx.wait();

5) WebSockets that don’t flake under load (and how to use them right)

Infura’s WS stack has shipped reliability updates for new-heads, including reorg notifications and eliminating the historical “idle timeout,” making WS viable for production block/LOG subscriptions. Pair WS for live pushes with HTTP(S) for deterministic backfills. (infura.ghost.io)

Key practices:

Only subscribe over WS; eth_subscribe isn’t supported over HTTP(S). (support.infura.io)
Build reconnection with exponential backoff and re‑subscription of all active filters.
Use indexed topics to narrow event firehoses; keep a strict “fromBlock–toBlock” reconciliation loop to recover missed events during reconnects.

Minimal reconnection loop (web3.js 1.x):

const Web3 = require("web3");
const ws = new Web3(process.env.MAINNET_WSS);

let sub;

function subscribe() {
  sub = ws.eth.subscribe("newBlockHeaders")
    .on("data", async (header) => {
      // backfill from lastProcessed+1 .. header.number
    })
    .on("error", (e) => {
      setTimeout(subscribe, 2500); // backoff
    });
}

subscribe();

6) IPFS and Filecoin rails: dedicated gateways with clear ceilings

For content addressing, Infura provides:

IPFS API with documented throughput: 150 RPS for write endpoints (add/pin/dag.put), and up to 1500 RPS for authenticated reads; dedicated gateways have a 100 RPS read ceiling per gateway. (docs.metamask.io)
Dedicated IPFS gateway subdomains to isolate your traffic and improve cache hit‑rates: choose unique subdomains, up to 20 per account. (docs.metamask.io)

Example dedicated gateway URL pattern:

https://<YOUR-SUBDOMAIN>.infura-ipfs.io/ipfs/<CID>/<path?>

Operational reality: plan for gateway diversity. Even robust gateways encounter intermittent degradation; we observed recent dedicated gateway incidents (degraded performance/outage windows) in September and October 2025. Build multi‑gateway fallback (e.g., fail over to a public gateway for anonymous reads or to a second dedicated subdomain) and cache content aggressively at your CDN edge. (isdown.app)

Upload example (pinning via API):

curl -X POST -u "$IPFS_PROJECT_ID:$IPFS_PROJECT_SECRET" \
  -F file=@./asset.png \
  https://ipfs.infura.io:5001/api/v0/add?pin=true

7) Security controls you can enforce at the API edge

Infura exposes project‑level security features that materially reduce key abuse in client‑side apps:

Project Secret for authenticated RPC over Basic Auth (don’t embed in public clients).
JWT Required mode with configured public keys to validate signed JWTs per request; use this to grant time‑boxed access to partner apps or controlled frontends.
Per‑project rate caps: per‑second and per‑day thresholds to limit blast radius if a browser key leaks.
Allowlists: origin, user‑agent, and even address‑level whitelisting for methods that take an address param. (infura.ghost.io)

Basic Auth example (server‑side only):

curl --user :$INFURA_API_SECRET \
  https://mainnet.infura.io/v3/$INFURA_API_KEY \
  -H 'Content-Type: application/json' \
  -d '{"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1}'

JWT flow sketch:

Your backend issues short‑lived JWTs for the browser, signed by your private key.
Infura verifies against your configured public key; reject if missing/invalid.
Rotate JWT keys per environment; add replay/nonce if you’re paranoid.

8) Monitoring, limits, and credit math (so nothing stops at 3 a.m.)

Credit‑based pricing/limits are explicit and automatable:

Plans and pricing (Dec 2025): Core (Free), Developer ($50/mo), Team ($225/mo), Enterprise (custom). Add‑on credits: $200 for +55M credits. (infura.io)
Daily credit quotas and per‑second caps: Core 6,000,000 credits/day and 2,000 credits/sec; Developer 15,000,000/day and 4,000/sec; Team 75,000,000/day and 40,000/sec. When you hit the daily cap, HTTP returns 402 and WS connections are severed until the 00:00 UTC reset. (support.infura.io)
Subscribe to service health via email/SMS/Slack/webhook/RSS on the public status page, and track per‑service uptime (e.g., Ethereum Mainnet HTTPS/WebSocket). (support.infura.io)

Architect’s checklist:

Budget “heavy” calls (trace, debug) as premium credits; batch them off the hot path. (infura.io)
Use dashboard alerts at 75%/85%/100% utilization and configure per‑key caps for frontends. (support.infura.io)
Post‑mortem on production: correlate your error budget with status page components (e.g., Mainnet HTTPS vs WS) to improve failover routing rules. (infura.statuspage.io)

9) Production patterns we deploy at 7Block Labs

A reference design that scales while containing risk and spend:

Dual‑plane access
- Write plane: DIN primary + private mempool routing enabled, strict rate caps, circuit breakers, and deferred write queues on SLO breach. (theblock.co)
- Read plane: FallbackProvider across DIN + backup; WS for push (newHeads/logs), HTTP for backfills; block‑range reconciliation jobs to guarantee no‑loss event ingestion. (infura.ghost.io)
Gas strategy
- Prefer Gas API hints; sanity‑check with feeHistory; dynamically clamp maxPriorityFee based on mempool load. (infura.io)
Analytics and compliance
- Persist normalized traces for withdrawals/settlements; expose a signed proof API to auditors. (infura.io)
IPFS content ops
- Dedicated gateways per product surface; 60s CDN TTL; automatic gateway failover and CID prefetch; schedule pin audits; watch status feeds. (docs.metamask.io)
Security posture
- JWT Required for browser keys; Origin allowlist; per‑key daily caps below the plan limit; rotate secrets quarterly; segregate projects per environment/team. (infura.ghost.io)

10) Practical snippets to save you time

Initialize a project‑scoped provider with Basic Auth (server‑side):

import fetch from "node-fetch";

const url = `https://mainnet.infura.io/v3/${process.env.INFURA_KEY}`;
const auth = Buffer.from(`:${process.env.INFURA_SECRET}`).toString("base64");

const body = {
  jsonrpc: "2.0",
  method: "eth_blockNumber",
  params: [],
  id: 1,
};

const res = await fetch(url, {
  method: "POST",
  headers: {
    "Content-Type": "application/json",
    Authorization: `Basic ${auth}`,
  },
  body: JSON.stringify(body),
});
console.log(await res.json());

Resubscribe to all logs for a contract with topic filters:

import { WebSocketProvider, id } from "ethers";

const wss = new WebSocketProvider(process.env.MAINNET_WSS!);
const contract = "0xC0..."; // your address
const topics = [ id("Transfer(address,address,uint256)") ];

async function start() {
  wss.on("block", async (n) => {
    // Pull logs since lastBlock+1 up to n with HTTP provider for reliability
  });

  await wss.subscribe("logs", { address: contract, topics });
}

start();

Pin IPFS JSON and read via dedicated gateway:

CID=$(curl -s -u "$IPFS_PROJECT_ID:$IPFS_PROJECT_SECRET" \
  -F file=@metadata.json https://ipfs.infura.io:5001/api/v0/add?pin=true \
  | jq -r .Hash)

curl -I "https://mybrand.infura-ipfs.io/ipfs/$CID"

11) Reality check: uptime and incident planning

Even with DIN and HA, you should assume partial degradations and plan user‑visible behaviors. Infura’s public status page exposes per‑component uptime (e.g., 90‑day Ethereum HTTPS, WS, filters, debug/trace). Subscribe your on‑call rotation and automation to these feeds; we’ve seen real incidents (e.g., IPFS dedicated gateway degradations in Sep/Oct 2025) that justify multi‑path retrieval strategies. (infura.statuspage.io)

12) Quick evaluation rubric (architect’s worksheet)

Networks: Does Infura cover your L2s today (Linea/Base/Arbitrum/Optimism), and do you need DIN for emerging chains like Unichain? (docs.metamask.io)
Writes: Will MEV‑protected routing materially improve your settlement quality? (metamask.io)
Analytics: Do you require historical state/trace at scale (compliance, BI)? If yes, architect batching and archival storage now. (infura.io)
Rate limits: Model credit burn with headroom; configure per‑key caps and alerts before launch. (support.infura.io)
Storage: Map IPFS gateway ceilings and plan cache/fallback; pin everything that must survive vendor outages. (docs.metamask.io)

Final take

If you need multichain reach, strong analytics, and real resilience, Infura in late‑2025 is no longer “just an RPC provider.” DIN decentralizes the supply side, the Gas/Trace stack gives you operational clarity, and the security/rate controls let you expose keys to browsers without losing sleep. Combine DIN with disciplined caching, WS/HTTP split‑brain design, and IPFS gateway failovers, and you’ll ship Web3 backends that survive market‑open Mondays and mainnet upgrades alike. (theblock.co)

References:

DIN overview and plan details; DIN AVS launch and performance claims; early access and partners. (infura.io)
Gas API availability and design goals; MetaMask announcement. (infura.io)
MEV protection rollout (Mar 11, 2025) and behavior. (metamask.io)
WebSocket reliability improvements and subscription guidance. (infura.ghost.io)
IPFS dedicated gateways and rate limits. (docs.metamask.io)
Pricing, credits, and quotas; rate‑limit behavior. (infura.io)
Status feed/subscriptions and recent incidents. (support.infura.io)
Linea support; endpoint catalog; Unichain via DIN. (docs.linea.build)