Alchemy vs QuickNode vs Infura in 2026: The Real Cost of Each Provider

General
1

After working with all three major providers across multiple projects, I’ve compiled the actual cost breakdown that nobody talks about. The sticker prices are misleading.

The Pricing Models

Alchemy (Compute Unit Model)

  • Free: 30M CUs/month (~1.2M basic calls)
  • Growth: $5 per 11M CUs (~$0.45/million)
  • Scale: Custom pricing

The Trap: CU pricing varies wildly by method:

  • eth_blockNumber: 10 CUs
  • eth_call: 26 CUs
  • eth_getLogs: 75 CUs (can spike with large ranges)
  • trace_* methods: 150+ CUs

If you’re doing lots of event indexing or debugging, costs explode.

QuickNode (Credit Model)

  • Build: $49/month, 80M credits, 50 RPS
  • Accelerate: $249/month, 450M credits, 125 RPS
  • Scale: $499/month, 950M credits, 250 RPS
  • Business: $999/month, 2B credits, 500 RPS

The Advantage: Faster average response times (86ms vs 207ms). Better for latency-critical apps.

Infura (Request-Based)

  • Free: 100K requests/day (3M/month)
  • Developer: $50/month, 200K requests/day
  • Team: $225/month, 1M requests/day
  • Growth: $1K/month, 5M requests/day

The Lock-In: MetaMask integration means many users’ wallets route through Infura by default.

Real-World Cost Comparison

For a typical dApp doing 5M requests/month with 20% being eth_getLogs:

Provider Estimated Cost Notes
Alchemy ~$180/month CU variability adds 30% buffer
QuickNode $249/month Predictable, faster
Infura $225/month Request caps can throttle

Hidden Costs

  1. Overage charges - All providers penalize spikes
  2. Archive node access - Often separate pricing
  3. Enhanced APIs - NFT/Token APIs cost extra on some plans
  4. Multi-chain - Each chain may count separately

Anyone have actual invoices to compare? I’m curious if my estimates match reality.

2

Great breakdown. Let me add the infrastructure team perspective on cost modeling.

The Budget Forecasting Nightmare

We’ve tried to model RPC costs for our finance team and it’s nearly impossible:

Alchemy CU Variability

Month 1: 50M CUs = $20
Month 2: 180M CUs = $75 (feature launch)
Month 3: 320M CUs = $130 (bug caused retry storms)

The compute unit model punishes you for things outside your control. A slow network day? More retries. A bug in your code? Exponential CU burn.

QuickNode Credit Predictability

QuickNode’s tiered model is actually easier to budget:

  • Pick a tier based on peak needs
  • Pay fixed monthly
  • Overage is expensive but rare

We switched to QuickNode primarily for finance’s sanity, not technical reasons.

Cost Optimization Tactics

  1. Batch requests - eth_call with multicall contracts
  2. Cache aggressively - Historical data doesn’t change
  3. Use websockets - Subscriptions vs polling
  4. Segment traffic - Critical vs non-critical endpoints

The Real Formula

Actual Cost = (Sticker Price) + (30% buffer) + (DevOps time to optimize)

That DevOps time is often the hidden killer. We spent 40 engineering hours last quarter just optimizing RPC usage.

3

For high-volume DeFi, these estimates are 10x low.

Our Actual Numbers

Our protocol does ~50M RPC calls/month. Here’s what we pay:

Provider Use Case Monthly Cost
Alchemy Primary API $2,400
QuickNode Liquidation bots $999
Self-hosted Archive queries $1,800 (infra)

Total: ~$5,200/month for RPC infrastructure.

The eth_getLogs Problem

Emma’s right about eth_getLogs being expensive. We do event indexing for our analytics dashboard, and that single feature costs us ~$800/month in CUs.

We’re now building a custom indexer with The Graph subgraphs to reduce this, but that’s another $400/month in hosting plus engineering time.

Price Per Transaction

When I break it down per on-chain transaction:

  • ~200K transactions/month through our protocol
  • $5,200 / 200K = $0.026 per transaction just for RPC

Add gas costs and we’re at $3-5 per transaction in infrastructure. DeFi margins are thin.

The Irony

We’re a “decentralized” protocol running on centralized RPC infrastructure from three VC-funded companies. The infrastructure layer is decidedly not decentralized.

4

The cost discussion is important, but let’s talk about reliability - that’s where the real cost appears.

Uptime SLA Reality

Provider Claimed SLA Actual Observed (2025)
Alchemy 99.9% ~99.7%
QuickNode 99.99% ~99.85%
Infura 99.9% ~99.5%

These are my observations across 5 different projects. Your mileage may vary.

The Cost of Downtime

Let’s do the math for a DeFi protocol with $50M TVL:

  • 0.1% downtime = 8.76 hours/year
  • During high volatility, 1 hour of RPC downtime could mean:
    • Missed liquidations: $50K-500K
    • Failed user transactions: reputation damage
    • Arbitrage losses: unquantifiable

The cheapest provider isn’t cheap if it goes down.

Security Considerations

  1. Single point of failure - One provider = one attack surface
  2. API key exposure - Leaked keys can rack up bills
  3. Rate limiting attacks - Competitors can exhaust your quota
  4. Data integrity - How do you verify RPC responses?

My Recommendation

Don’t optimize purely for cost. A multi-provider strategy with automatic failover is worth the premium. We use:

  • Primary: Best performance provider
  • Fallback: Different provider for redundancy
  • Verification: Self-hosted node for critical transaction validation