How Much Does QuickNode Actually Cost? API Credits Explained (2026)

A team I talked to last quarter got a QuickNode bill 4× their plan price. Their traffic hadn't grown. What had changed: they'd integrated a marketplace add-on for Streams (real-time data subscriptions), which has its own credit consumption layered on top of normal RPC traffic. They saw "Streams" in their dashboard with a green checkmark and assumed it was included in the plan. It wasn't.

QuickNode's API Credit model is documented. Every method's credit cost is published. The rate card is even reasonably stable. But "documented" doesn't mean "predictable" once you account for: per-chain rate variations, add-on stacking, and the way different transaction patterns chew credits at wildly different rates.

This post is the actual math behind QuickNode's credit system, three concrete workload examples, and the budgeting traps that catch teams once or twice before they get them right.

How API Credits work

QuickNode charges per API Credit (sometimes called QC, for QuickNode Credit). Different RPC methods cost different credit amounts. The standard rate card, abbreviated:

Each plan includes a monthly allowance:

• Free: 50M credits/mo (Solana free tier has its own pool)
• Build $49/mo: 200M credits
• Scale $299/mo: 800M credits
• Enterprise: custom

Overage on Build and Scale is billed automatically — no plan-upgrade prompt. You set up payment, you authorize the recurring bill. If usage spikes, the next invoice reflects it.

That last point is the source of the surprise bills. Alchemy at least suggests an upgrade when you approach your CU limit; QuickNode lets you spend straight through.

Real workload pricing

Let me run three example apps through the credit math. Same shape as we did for Alchemy Compute Units in an earlier post, so you can compare apples-to-apples.

Workload A: simple wallet UI

100,000 DAU. Each session reads balance + recent transactions + token holdings:

• eth_getBalance × 1 → 10 credits
• eth_getTransactionCount × 1 → 30 credits
• eth_getTransactionReceipt × 5 (recent txs) → 125 credits
• eth_call × 3 (read ERC-20 balances) → 90 credits

Per session: 255 credits

100,000 × 255 = 25.5M credits/day = 765M credits/month

That's near Scale's 800M allowance — close, but technically fits if usage stays flat. If your DAU grows 10%, you'd be overage from one month to the next. Roughly $30-50/month in overage at the standard rate.

Workload B: DEX or analytics with chart history

100k DAU. Each session loads a price chart requiring log queries:

• eth_getLogs × 3 → 180 credits
• eth_call × 5 (route lookups, decimal reads) → 150 credits
• eth_getBlockByNumber × 2 → 160 credits

Per session: 490 credits

100,000 × 490 = 49M credits/day = 1.47B credits/month

Above Scale's 800M. You're paying overage on 670M credits, which at QuickNode's standard overage rate adds ~$200-300/month on top of the $299 base.

Workload C: indexer or trace-heavy analytics

Same 100k DAU but the app does trace lookups for debugging displays:

• debug_traceTransaction × 2 → 500 credits
• eth_call × 5 → 150 credits
• eth_getTransactionReceipt × 3 → 75 credits
• eth_getLogs × 2 → 120 credits

Per session: 845 credits

100,000 × 845 = 84.5M credits/day = 2.5B credits/month

Now you're at Scale + ~1.7B credits of overage. The bill is roughly $700-1,000/month for an app with the same user count as Workload A — that started at $299.

The pattern matches Alchemy almost exactly: same DAU, vastly different bills depending on which methods the code paths happen to use.

The QuickNode-specific budgeting gotchas

Most of these don't show up in the standard credit-cost table:

1. Marketplace add-ons stack on top

QuickNode's marketplace has add-ons for:

• Streams (real-time event subscriptions)
• KeyValue Store (per-key reads/writes)
• MEV Bundle Submission
• NFT API (per-call cost on top of RPC)
• DeFi API
• Crypto Marketplace Data

Each has its own credit consumption. Enabling Streams to track a busy contract can easily 2-3× your monthly credit usage without changing your RPC code at all. The dashboard shows usage but most teams don't realize until billing.

2. Method costs are per-chain (sometimes)

The standard rate card is for Ethereum. Solana methods have their own credit table — getProgramAccounts is 30 credits, getSignaturesForAddress is 30-150 depending on filter complexity. Aptos, Sui, and other non-EVM chains each have their own rate cards. If your workload is multi-chain, you need to check each chain's table.

3. Failed requests still cost credits (usually)

A reverted eth_call or a query that hits a result limit still consumes credits — your fault for asking, not the provider's fault for refusing. ethers/viem's auto-retry logic compounds this: a single failed call retried 3 times costs 3× the credits, none of which got you data.

4. eth_getLogs cost is range-dependent in practice

The rate card lists 60 credits for eth_getLogs, but QuickNode rate-limits and re-charges for large block ranges. A 10,000-block log query is fine; a million-block query gets split server-side and you pay for each chunk. The 60-credit number is the "happy path."

5. WebSocket subscriptions burn credits per message

Every event pushed over a eth_subscribe connection counts as 1-3 credits depending on the subscription type. Long-lived subscriptions to noisy contracts can dominate your monthly usage without you tracking it explicitly.

The flat-rate comparison

Same three workloads against SwiftNodes' Growth plan:

The break-even between QuickNode Build ($49) and SwiftNodes Growth ($89) sits around 100M credits/month. Below that, QuickNode's lower base price wins. Above it, flat-rate pulls ahead quickly. Trace-heavy workloads are not even close — flat-rate is 10×+ cheaper.

When QuickNode is genuinely the right answer

I'm not trashing them — they have real wins. Cases where QuickNode is the better pick:

1. You actually use a marketplace add-on that nobody else offers — Streams for real-time event subscriptions is a legitimately good product, no direct flat-rate equivalent. If your architecture depends on it, the credit-meter trade-off is worth it.
2. Multi-chain non-EVM stack with heavy Aptos/Sui usage — QuickNode's coverage of newer non-EVM L1s is broader than most competitors. Their Solana support is also strong.
3. You want the marketplace ecosystem — third-party add-ons (NFT data, MEV tools, on-chain analytics) integrated through one dashboard is genuinely convenient when you need many of them.
4. Low-volume MVP — if you're under 50M credits/month and might never grow past it, the free tier is real and works.

How to forecast a QuickNode bill

The honest process:

1. Pull a representative day of your production RPC logs. Count calls by method.
2. Multiply each method count by its credit cost. Use the official rate card per-chain.
3. Add 20% buffer for retries — ethers/viem failed-call retries are real and the credit cost compounds.
4. List your active marketplace add-ons and add their per-feature credit usage. Streams especially is large.
5. Multiply by 30 for monthly.
6. Find the plan tier that covers the total. Add overage for anything past it.
7. Compare against SwiftNodes at the equivalent peak RPS by grabbing a free key and pointing 1% of traffic at it for a day.

That 20-minute exercise typically saves teams meaningful money on either platform. The mistake we see most often is: "I'll just use the Build plan because it covers most months" — and then traffic patterns change subtly and the overage starts running.

FAQ

How much does QuickNode cost per month? Plans run Free (50M credits/mo), Build ($49/mo, 200M credits), and Scale ($299/mo, 800M credits), with automatic overage beyond your allowance. The real cost depends on your method mix — a logs- or trace-heavy app can pay $550–1,000/month on a $299 plan (see the worked examples above).

What are QuickNode API credits? The billing unit: every RPC call costs a method-specific credit amount — cheap for eth_blockNumber, far more for eth_getLogs, traces, and archive queries — and marketplace add-ons consume additional credits on top. Exceed your monthly allowance and overage bills automatically.

Why is my QuickNode bill higher than expected? Three usual suspects: the method mix shifted toward expensive calls, a marketplace add-on (like Streams) is consuming its own credits on top of RPC traffic, or steady overage — traffic quietly outgrowing your plan with no upgrade prompt.

Is there a flat-rate alternative? Yes — flat monthly pricing limited by requests-per-second instead of credits, where every method costs the same. That's the model SwiftNodes uses; the comparison below has the numbers.

The takeaway

QuickNode's API Credits aren't deceptive, but they reward attention. Different methods cost up to 50× each other, marketplace add-ons stack on top, and the bill arrives without an upgrade-suggestion intermediate step. Teams running steady-state on Build often discover they've been paying Scale-equivalent overage for months.

If your workload is light, predictable, and you genuinely use QuickNode's marketplace, the credit system is fine. If you're hitting any combination of heavy logs queries, trace methods, or high call volume, flat-rate pricing produces dramatically cheaper bills and removes the budgeting variance entirely.

SwiftNodes is the flat-rate alternative to QuickNode — one number per month, no per-method costs, no marketplace add-on credit stacking. See the full QuickNode alternative comparison, how the major RPC providers stack up, or grab a free API key — no credit card, no KYC.