Products
Data Access Portal API SQD Network Supported Chains
Development SDK SQD Cloud SQD 360
Solutions
By Use Case DeFi & Trading Analytics AI Agents Wallets & Payments Compliance All Solutions
By Industry Stablecoins RWA All Customers
Developers
Get Started Documentation Subsquid Subsquid Labs Dev Chat
Resources
Learn Guides Compare Blog Videos Changelog
Company About Ecosystem Brand Assets
Customers Pricing
Talk to us

SQD vs Infura

SQD vs Infura: indexed data layer or RPC node provider?

225+ networks · Sub-second streaming reads · Free public Portal, no key

Infura is a hosted RPC and node API provider, now part of MetaMask Developer, covering roughly two dozen networks with credit-metered pricing and a federated decentralization program (DIN). SQD is a decentralized indexed-data layer covering 225+ networks, serving decoded data over a streaming Portal API rather than per-call RPC. They solve different problems: use Infura for live RPC and writes, use SQD for high-volume historical reads and indexing.

Try the Portal Read Docs

Pick SQD if

  • → You need decoded, queryable data or to build a custom indexer, not raw JSON-RPC.
  • → You run high-volume historical reads or analytics where per-call credit metering gets expensive.
  • → You want broad multi-VM coverage (225+ networks across EVM, Solana, Substrate, Bitcoin, Hyperliquid) from one endpoint, plus the option to self-host.

Pick Infura if

  • → You need live JSON-RPC, transaction broadcasting, or wallet-style state reads; SQD is read-side data only and does not broadcast transactions.
  • → You are already in the MetaMask/Consensys ecosystem and want the default RPC backend with managed reliability and SLAs.
  • → Your workload is mainstream EVM RPC with modest read volume that fits comfortably inside the credit quotas.

Two different layers

Where SQD and Infura sit in your data stack

Infura sits at the node-access layer: it serves raw JSON-RPC and node APIs so applications can read and write to chains without running their own nodes. SQD sits one layer up, at the indexed read-side data layer, serving decoded, queryable historical and real-time data through a streaming Portal API. The two are complementary: a typical stack uses an RPC provider like Infura for writes and live state calls, and SQD for high-volume historical reads and analytics that would be slow or expensive over per-call RPC. Infura does not provide an indexing framework or decoded datasets; SQD does not aim to replace transaction broadcasting or wallet RPC.

  1. Apps & products
    Wallets Tax Payments KYC RWA
  2. Intelligence
    Comparison coming soon Comparison coming soon Comparison coming soon Comparison coming soon Comparison coming soon
  3. Protocol analytics
    Dune Comparison coming soon
  4. Indexed data
    The Graph Goldsky Envio Ponder Carbon Shyft Moralis Allium Bitquery SonarX
  5. Our focus
    Read-side infrastructure
    SQD decentralized, validated, multi-chain at source
  6. Node providers
    Alchemy QuickNode Infura· Helius Triton One Chainstack Blockdaemon Ankr

SQD optimizes for

  • ✓Decoded data at source: one endpoint, 225+ chains, queryable directly
  • ✓Multi-chain in one endpoint, not per-chain RPC metered by credits or request units
  • ✓A TypeScript SDK for custom indexing, plus a streaming Portal API
  • ✓Validated data with 6-step verification at ingestion
  • ✓Open source (Portal node AGPL-3.0) and self-hostable

Infura optimizes for

  • ✓Hosted JSON-RPC and node APIs across mainstream EVM networks
  • ✓Transaction broadcasting and live contract-state reads
  • ✓The default RPC backend for MetaMask, with managed reliability and SLAs
  • ✓WebSocket subscriptions for pending and mempool events

At a glance

Side-by-side comparison

Dimension SQD Infura
What it is
Layer in the stack Different layers; often complementary. Indexed read-side data layer (decoded data lake) RPC / node access layer
Primary interface Streaming HTTP Portal API + TypeScript Squid SDK + Pipes SDK JSON-RPC over HTTPS/WebSocket + REST helper APIs
Indexing framework Infura is RPC; it does not provide an indexing SDK or decoded datasets. ✓ ✗
Decoded data out of the box Infura returns raw RPC responses; decoding is the developer's job. ✓ ✗
Coverage & Performance
Networks supported SQD per /chains catalogue; Infura per MetaMask developer docs endpoints page (its pricing page advertises 40+ networks). 225+ ~24 mainnets
Ecosystems Infura coverage is EVM-dominant. EVM, Solana, Substrate, Bitcoin, Hyperliquid Mostly EVM, plus Starknet and limited-access Solana
Read latency Not directly comparable; RPC latency is per-call, SQD figure is streaming read. Sub-second hot path; independent benchmark 27ms P50 / 48.5ms P90 Live RPC latency varies by request and plan throughput
Bulk historical reads Large historical scans over RPC consume many credits. Streaming, designed for high-volume backfills with zero egress fees Per-call RPC; archive reads consume credits like other calls
Live state / writes / broadcast Infura wins here; SQD is not an RPC endpoint. Not a goal; read-side data only Yes, full JSON-RPC including writes and tx broadcast
Architecture & openness
Open source Infura backend proprietary; only client helper libs are open (ISC-licensed). Pipes SDK MIT, Portal node AGPL-3.0 ✗
Self-hostable SQD: Squid SDK + Portal node; Infura is hosted only. ✓ ✗
Decentralization DIN is not fully decentralized today. Decentralized network of worker operators paid in SQD Federated DIN phase, 60+ partner providers, progressive decentralization stated as a goal
Data validation Infura relies on its node infrastructure correctness. 6-step cryptographic validation at ingestion Not published as a feature
Economics
Pricing model Network-based tiers, not per-call metered Credit-metered: each request costs credits by complexity, against a daily quota
Free tier Infura free tier requires an account and API key. Free public Portal, no API key, no card Core plan free: 3M daily credits, 500 cps
Egress fees High-volume reads draw down the credit quota. Zero egress No separate egress fee, but every read consumes credits
Token required for production DIN currently has no token; future tokenization is left open. ✗ ✗

Facts verified June 2026 against Infura’s public docs and product pages. Every cell value is cited in the Sources section at the bottom of this page.

Decision framework

Choose based on your workload

When SQD is the better choice

  • →Indexing decoded onchain data for an app or analytics backend.
  • →Backfilling large historical ranges where per-call RPC would burn through credits.
  • →Building on non-EVM chains like Substrate, Bitcoin, or Hyperliquid that Infura does not cover.
  • →Wanting an open-source, self-hostable data layer rather than a closed hosted RPC.
  • →Needing one endpoint spanning 225+ networks instead of stitching together RPC per chain.

When Infura is the better choice

  • →You need to send transactions or call live contract state, which SQD does not do.
  • →You want a single managed RPC vendor that is the default backend for MetaMask.
  • →Your app needs WebSocket RPC subscriptions to mempool or pending-state events.
  • →You are standardized on Consensys tooling (MetaMask, Linea) and want first-party support.

Most production teams use both: Infura for its layer, and SQD for the decoded data layer above it.

What changes, what stays

Where SQD replaces Infura, and where you keep both

SQD and Infura operate at different layers, so the practical move is to add SQD for read-side data while keeping Infura for what it does well. SQD replaces the pattern of polling Infura RPC in a loop to build or backfill datasets, which is slow and consumes credits per call. You keep Infura for live state reads, transaction broadcasting, and wallet RPC, where a node provider is the right tool. There is no code migration in the indexer sense, since Infura is not an indexing framework; you are offloading the high-volume read path to SQD's Portal API.

SQD replaces

  • →Looping JSON-RPC calls (eth_getLogs, eth_getBlockByNumber) to build or backfill historical datasets
  • →Custom decoding and re-org handling layered on top of raw RPC responses
  • →Credit-heavy archive-data scans for analytics

You keep Infura for

  • →Infura for transaction broadcasting and write calls
  • →Infura for live contract state reads and wallet RPC
  • →Infura WebSocket subscriptions for real-time pending/mempool events

The matrix above breaks the comparison down dimension by dimension. Every claim is cited in Sources.

The full SQD toolkit

What you get with SQD

SQD offers four products that share the same underlying data lake. Pick the layer that fits your workload.

Product What it does Best for
Portal API Sub-second multi-chain query API Real-time apps, trading, agents
Squid SDK TypeScript indexer framework Custom data products, GraphQL APIs
Pipes SDK Streaming ETL pipelines Warehouses, analytics, batch loads
SQD Network Decentralized data lake Open access, no vendor lock

Need a custom API? Build it with SQD. When a fixed, hosted endpoint doesn't fit, the Squid SDK and Pipes SDK let you build your own indexer or streaming pipeline in TypeScript over any of 225+ chains, shaped to your schema. The Squid SDK deploys to SQD Cloud, or self-host either.

225+

Networks indexed

27ms

Median Portal response

6-step

Validation at ingestion

+215 more

Frequently asked questions

Is Infura an indexer or an RPC provider?
Infura is an RPC and node API provider, not an indexer. It serves raw JSON-RPC responses so apps can read and write to chains without running their own nodes. It does not provide an indexing framework or decoded datasets. SQD is the indexed-data layer: it serves decoded, queryable data over a streaming Portal API, and provides the Squid and Pipes SDKs for building indexers.
SQD vs Infura: which should I use?
Use Infura for live RPC calls, transaction broadcasting, and wallet-style reads. Use SQD for high-volume historical reads, analytics, and building indexers where per-call RPC would be slow or credit-expensive. Many teams use both: Infura for writes and live state, SQD for indexed read-side data.
How many chains does Infura support compared to SQD?
Infura's MetaMask developer docs list roughly two dozen named mainnets, predominantly EVM chains plus Starknet and limited-access Solana (its pricing page advertises access to 40+ networks when testnets are included). SQD covers 225+ networks across EVM, Solana, Substrate, Bitcoin, and Hyperliquid through one Portal endpoint.
Is Infura free, and how does its pricing work?
Infura's Core plan is free with 3,000,000 daily credits and a 500 credits/second rate limit. Paid plans are Developer (US$50/month, 15M daily credits) and Team (US$225/month, 75M daily credits), with a custom Enterprise tier. Pricing is credit-metered: each request consumes credits based on computational complexity. SQD offers a free public Portal with no API key or card, and paid tiers that are network-based rather than per-call metered.
Can I self-host Infura?
No. Infura is a managed hosted service with no self-hostable node software; only client middleware libraries are open source. SQD is self-hostable (Squid SDK plus the AGPL-3.0 Portal node), and also offers managed SQD Cloud and a free public Portal.
Is Infura decentralized, and is there a token?
Infura runs the Decentralized Infrastructure Network (DIN) with 60+ partner providers, but its own page describes a federated phase with progressive decentralization as a stated goal rather than a fully decentralized network today. There is currently no token required. SQD runs a decentralized network of worker operators paid in the SQD token, though no token is required to use the public Portal in production.
Looking for an Infura alternative for high-volume historical data?
For large historical scans and analytics, fetching data over per-call RPC draws down Infura's credit quota quickly. SQD is designed for that case: a streaming Portal API with decoded data and zero egress fees, plus the Squid SDK to build custom indexers. You can keep Infura for live RPC and writes.
Sources & methodology (9 citations, verified June 2026)

Every comparison cell and statement about Infura is anchored to Infura’s own public documentation. Spotted something stale? Let us know.

What Infura is and coverage

  • Infura provides hosted blockchain RPC/node services and runs the DIN decentralization initiative; now part of MetaMask Developer, powered by Consensys. [Infura homepage]
  • Supported networks catalogue lists roughly two dozen named mainnets, predominantly EVM plus Starknet and limited-access Solana. [MetaMask developer docs, supported networks]

Pricing

  • Plans: Core (free), Developer US$50/month, Team US$225/month, Enterprise custom; credit quotas 3M/15M/75M daily and 500/4K/40K credits per second; 55M extra credits add-on for US$200/month. [Infura pricing page]
  • Credit-based pricing model: each request is assigned credit values by computational complexity against a fixed daily credit quota; tiers list 3M/15M/75M daily credits. [MetaMask developer docs, pricing]

Decentralization (DIN)

  • DIN is in a federated phase with 60+ partner providers and progressive decentralization stated as a goal; no token currently required. [Infura DIN page]

Indexing vs RPC positioning

SQD canonical facts

More comparisons

Compare SQD to other platforms

SQD vs Alchemy

Indexing vs RPC

SQD vs QuickNode

Read-side data vs RPC

SQD vs Chainstack

Indexed data vs RPC nodes

SQD vs Ankr

Streaming data vs decentralized RPC

SQD vs The Graph

225+ chains, TypeScript SDK

SQD vs Helius

Multi-chain vs Solana-only

Decoded data on 225+ chains, one endpoint

Free public Portal, open-source SDK, and 225+ chains indexed from day one.

Try the Portal Read Docs

Indexing more than 100M events a day or need a dedicated portal? Talk to sales.