What Is Infura? The Consensys RPC Behind MetaMask, DIN, and Ethereum, Explained

Nearly every time you tap "confirm" in MetaMask, your transaction doesn't go straight to Ethereum — it goes to Infura first. Infura is the hosted infrastructure, owned by Consensys, that runs the blockchain nodes so app developers don't have to; you send it a standard request, it queries the chain and hands back the answer — some of the most-used, least-visible plumbing in Web3. This guide covers what Infura does, how its 2026 credit pricing works, what the DIN decentralization push is really about, and the centralization tradeoffs you accept every time a default RPC does its job.

What Infura is, and who runs it

To read or write anything on a blockchain, you need a node — a machine running the network's software, synced to the full chain. Running one is slow, storage-hungry, and operationally annoying. Infura's entire value proposition is: don't. Instead you get an API key, point your app at an endpoint URL like https://mainnet.infura.io/v3/YOUR-KEY, and send JSON-RPC calls — the standard request format every Ethereum client speaks. Infura runs the nodes, handles the scaling, and returns the data over HTTPS or WebSocket.

Infura was founded in 2016 by Michael Wuehler, E.G. Galano, and others as a Consensys "spoke," and it hit real load early — during the October 2016 EIP-150 hard fork and the 2017 CryptoKitties congestion, when running your own node was painful. Consensys acquired it outright in October 2019. Today it sits alongside MetaMask and Linea in the Consensys stack, which is why MetaMask ships with Infura as its default RPC: same parent company, vertically integrated.

Along with its main rival Alchemy, Infura powers the large majority of Web3 RPC traffic — which is why "Ethereum is decentralized but its access layer isn't" names Infura first.

How it actually works

Infura is a read/write proxy between your app and the chain.

• Reads — balances, contract state, block data, event logs — are the bulk of traffic. Your app calls a method like eth_getBalance or eth_call, Infura hits a synced node, and returns the value. No signing, no fees paid to Infura beyond your plan.
• Writes — sending a signed transaction — go through eth_sendRawTransaction. Your wallet signs locally (Infura never holds your keys), then Infura relays the signed blob into the network's mempool. You still pay normal network gas in ETH; Infura's fee is your subscription, not the gas.

Beyond raw Ethereum mainnet, Infura provides dedicated endpoints for a wide set of chains: Linea, Base, Arbitrum, Optimism, Polygon, BNB Smart Chain and opBNB, Avalanche, Starknet, Scroll, Blast, Mantle, ZKsync, plus the standard testnets (Sepolia and network-specific ones). Each network gets its own hostname for HTTPS and WebSocket. It also runs an IPFS API and gateway for decentralized storage, and add-on APIs (gas estimation, transaction sending) layered on top of raw RPC.

The token question, and how you pay

First, the thing people search for: there is no Infura token. There has never been an INFURA coin, and anything trading under that name is a scam. Infura is a plain commercial service you pay for in dollars.

As of January 2026, billing runs on a credit model rather than raw request counts — a fairer way to charge, since a trivial eth_blockNumber and a heavyweight archive trace are not the same load. Each method has a fixed credit cost by computational weight: common JSON-RPC calls run around 80 credits, eth_getBlockReceipts and debug methods around 1,000 credits, and trace methods around 300 credits.

The tiers, at time of writing:

The Core limits were set to 3M/day and 500 credits/sec on January 7, 2026. Access to DIN-routed ("Decentralized by DIN") networks is available across plans, though the extra failover resilience is positioned toward Growth/Enterprise-tier customers. Legacy request-based billing remains only for Enterprise accounts.

DIN: the fix for the single-point-of-failure problem

Infura's biggest liability is philosophical: a decentralized network reached through one centralized company. If Infura goes down, an enormous share of dapps and wallets go down with it — and that isn't hypothetical (more below). DIN, the Decentralized Infrastructure Network, is Consensys' answer.

The idea is to turn the RPC layer into a marketplace of independent providers rather than Infura's own servers alone. DIN was announced with a roster of cornerstone partners including Microsoft, Tencent Cloud, and Chainstack (18 in the initial group), and has grown toward 50+ providers specializing in bare-metal nodes. The core feature is automatic failover: if one provider fails or is congested, the request seamlessly reroutes to another, so an app stays up even when any single operator doesn't.

Through 2024 DIN moved from proof-of-concept to production, handling requests across roughly a dozen networks. At Devcon in Bangkok (November 14, 2024) Consensys unveiled the next step: running DIN as an EigenLayer AVS (Actively Validated Service). In plain terms, that means DIN would borrow Ethereum's economic security through restaking — providers put staked ETH (and EIGEN) at risk as a bond for honest, reliable service — which in turn allows permissionless participation: new providers can join without Infura hand-picking each one. This is where the "no token, but token-adjacent" nuance lives — DIN's security model touches EigenLayer's tokens, but Infura issues nothing of its own.

DIN doesn't make Infura trustless overnight, but it spreads the load — and the control — across many operators instead of one.

Where Infura sits in the market

The RPC-provider landscape has consolidated: Infura and Alchemy together power the large majority of Web3 traffic, the two names most apps reach for by default. The rest of the field — QuickNode, Chainstack, dRPC, Ankr, and a long tail of public endpoints — competes on price, chain coverage, or specialized features.

Infura is the older, more embedded option: it's the MetaMask default, its raw request latency benchmarks slightly faster than Alchemy's, and it owns the DIN decentralization narrative. Alchemy leaned the other way, positioning itself less as raw nodes and more as a full developer platform — enhanced APIs, webhooks, richer debugging, NFT tooling, and observability dashboards. For plain reads and writes, either is fine and switching is a URL change. The decision usually turns on the surrounding tooling, the specific chains you need, and where your credit budget stretches furthest. Because migration is so cheap, many production teams deliberately run two providers and fail over between them — a manual version of what DIN aims to automate.

Why it matters: the centralization critique

Infura is the clearest case study in Web3's convenience-versus-decentralization tradeoff. The convenience is real; so are the costs.

• Single point of failure. In November 2020, Infura suffered a major outage after a node-client version mismatch, and because so much of the ecosystem depended on it, MetaMask, Uniswap, Compound, and others degraded or broke at once. Some exchanges even paused ETH and ERC-20 withdrawals. A truly decentralized system shouldn't have a button that breaks that much at once.
• Data collection. Consensys' November 2022 privacy-policy update confirmed that when Infura is MetaMask's default RPC, it collects your IP and wallet address when you transact — enough to link on-chain activity to a network location. Consensys notes that switching to your own node or another RPC stops this collection, which is precisely why privacy-minded users change the default.
• Censorship and access. Infura has geo-blocked certain regions for compliance reasons (it drew heavy criticism over restricting access tied to sanctioned areas). A centralized RPC is a chokepoint a government or company can lean on.

None of this makes Infura "bad" — it makes it a control point, and the whole reason DIN exists is that a control point in a system that markets itself as trustless is a contradiction worth resolving. If you care about the broader picture of how Ethereum scales and stays credibly neutral, our best Ethereum L2s and what is DeFi guides give useful context.

How to actually use it

For a developer, getting started is genuinely quick:

1. Create an account and an API key at infura.io — the free Core tier is enough to build and test.
2. Pick your network endpoint — e.g. mainnet, Sepolia, Base, or Linea — each has its own URL with your key appended.
3. Wire it into your tooling. Point viem, ethers, web3.js, or your wallet's custom-RPC field at the endpoint. Frameworks let you drop the URL straight into a provider config, and any MetaMask install can have its default network URL swapped in settings.
4. Monitor credits. The dashboard shows credit consumption; watch for heavy methods (traces, archive queries) that burn credits fast, and cache reads where you can.

For an end user, "using Infura" usually means doing nothing — it's already the default in MetaMask. The one deliberate action worth knowing: in MetaMask's network settings you can replace the default Infura RPC with your own node or a different provider. That's how you opt out of the data collection and the single dependency, at the cost of doing your own reliability engineering.

The risks worth naming

• Dependency risk. Building solely on one RPC — Infura or any provider — means their outage is your outage. Serious apps use failover (which is exactly DIN's pitch) or multiple providers.
• Privacy leakage. Default RPC usage ties IP and wallet addresses together at the infrastructure layer. Fine for many, unacceptable for some.
• Centralized policy. Geo-blocking and compliance decisions are made by a company, not a protocol — your access can change without your input.
• Scam tokens. Repeat, because it matters: no official Infura token exists. Ignore any "INFURA airdrop" or coin.

Bottom line

Infura is the quiet backbone that made Ethereum usable at scale — a reliable, well-run RPC service that spared a generation of developers from running their own nodes and became the default path from MetaMask to the chain. That success is also the problem: a decentralized network reached mostly through one centralized company is a fragile and philosophically awkward arrangement, as the 2020 outage and the privacy-policy backlash both showed. DIN is the credible attempt to fix it — turning the RPC layer into a restaking-secured marketplace of many providers rather than a single chokepoint. Whether DIN delivers real decentralization or just redistributes it among big partners is the story to watch. Either way, understanding Infura is understanding how most people actually reach Ethereum today.

For related reading: best Ethereum L2s, what is DeFi, the MetaMask guide, and restaking and EigenLayer explained.

Related guides

• Best crypto RPC providers compared
• Alchemy: the Web3 developer platform and RPC
• dRPC: the decentralized RPC marketplace
• Lava Network: decentralized RPC access
• Helius: the leading Solana RPC

Not financial or security advice. Infura has no token; verify every endpoint and plan detail on infura.io, and never trust a link promising an "Infura" coin or airdrop.