# Archive and trace RPC pricing across providers: what a year of Ethereum blocks costs to trace

> Archive and trace are the two features providers gate, weight or bundle differently. The published rules, one worked bill, and an honest account of where a flat request-rate plan is the expensive choice.

- Canonical: https://triport.io/blog/archive-and-trace-rpc-pricing-across-providers
- Published: 2026-11-05
- Updated: 2026-11-05
- Author: Triport Engineering
- Category: Comparisons
- Networks: Ethereum, Polygon, Robinhood

## TL;DR

- Archive is priced three ways: included in every plan (Alchemy's pay-as-you-go, QuickNode, Ankr), billed at double by block distance (Chainstack: 2 request units at 127 blocks behind the tip or more), or bundled in a plan tier. Trace is priced as a heavier method (Alchemy 20 to 40 CU, Infura 300 to 1,000 credits, QuickNode a 2x multiplier) or gated to a paid plan.
- Tracing one year of Ethereum, 2,628,000 blocks with trace_block, costs about $27 on Alchemy pay-as-you-go, about $65 on QuickNode Build, $49 on Chainstack Growth and about $53 on Ankr at the page's EVM rate. On Triport there is no call quota or credit meter to exhaust: at Pro's sustained 5 requests per second the whole job runs in about six days of steady tracing, at the flat $249, and you can burst above that rate.
- On Alchemy's and Chainstack's published meters, tracing alone is cheaper than Triport Pro even at Pro's sustained 5 requests per second; on QuickNode and Ankr rates the same volume costs more than $249. A flat plan makes sense when your read traffic already justifies it, because trace then adds nothing to the bill — no credit meter or call quota, only the per-second rate you can burst above.

Two words in provider marketing do most of the pricing work and say the least: "archive" and "trace". Archive means a node that keeps old state; trace means replaying a transaction to see its internal calls. Both are expensive to run, so providers handle them differently: some give them away, some charge double, some lock them to plan tiers, some publish a weight that you have to multiply yourself.

This post lays out the published rules (all read 2026-11-01, sources at the end), then prices one job on each: tracing one year of Ethereum blocks. The answer is not flattering to us in one respect, and we say where. For the concept of an archive node, see [the glossary entry](https://triport.io/learn/glossary/archive-node); the fact tables live in [the comparison hub](https://triport.io/compare).

## Archive: three ways to price the same word

**Included.** Alchemy's compute-unit page says archive data is free on all chains; it lists no separate weight for archive reads. QuickNode's pricing page marks archive data as included on every plan, including its free trial. Ankr's plan table lists "Full and Archive data" on all of its plans with no separate credit cost.

**Priced by distance.** Chainstack bills an EVM request as full (1 request unit, RU) if the block it touches is less than 127 blocks behind the tip and as archive (2 RU) at 127 or more. For `eth_getLogs` the block that counts is `fromBlock`. Twenty methods, including `eth_call`, `eth_getBalance`, `eth_getBlockByNumber` and `eth_getBlockReceipts`, are subject to this rule; `eth_getTransactionReceipt` is not. A historical job simply costs double per call.

**Bundled.** Archive is a property of the plan, and a lower plan gets less. Plan pages also tend to be inconsistent about this: Infura's pricing page shows archive on its free Core plan in one place and leaves the comparison cell empty in another, so we do not state a plan-by-plan claim for it.

The practical consequence: the word "archive" on a pricing page tells you whether you may ask, not what it costs to ask for old blocks or how far back the node goes. None of the pricing pages we read gives a block floor.

## Trace: a heavier method, a gate, or both

| Provider | Trace and debug availability | Weight on Ethereum |
|---|---|---|
| Alchemy | Trace API requires pay-as-you-go or enterprise | `trace_block` 20 CU, `trace_transaction` and `trace_filter` 40, `debug_traceTransaction` 40 |
| QuickNode | Not on the free trial; included from Build ($49) | 20 credits base; "Trace & Debug" falls under a 2× chain multiplier, so 40 by the page's rule; `trace_replayBlockTransactions` is in a 4× group |
| Chainstack | "Debug & trace APIs" on Growth ($49) and higher | 2 RU regardless of block age |
| Infura | Plan table not readable consistently | `trace_block`, `trace_transaction`, `trace_filter` 300 credits; `debug_traceTransaction` 1,000 |
| Ankr | Premium only; not on public or freemium | Page lists one EVM rate of 200 credits per request and no trace-specific weight |

Two notes. The QuickNode 40 is our multiplication of the page's two statements (20 credits for Ethereum standard methods, a 2× multiplier for Advanced APIs including Trace & Debug); the page does not print the product. Alchemy's own table also lists a "Throughput CU" column in which `debug_traceTransaction` is 1,000 against 40 billed, and gives no throughput value for `trace_block`.

## The worked bill: a year of Ethereum blocks

One year of 12-second slots is 365 × 7,200 = 2,628,000 blocks. Trace each once with `trace_block`:

| Provider and plan | Units | Money |
|---|---|---|
| Alchemy pay-as-you-go ($0.52 per 1M CU) | 52.56M CU | about $27.33 |
| QuickNode Build ($49, 80M credits, $0.62 per 1M over) | 105.12M credits | about $64.57 |
| Chainstack Growth ($49, 20M RU) | 5.256M RU | $49, inside the quota |
| Ankr Premium ($0.10 per 1M credits, 200 per request) | 525.6M credits | about $52.56, if the 200-credit rate applies |
| Infura | 788.4M credits | not computed |
| Triport Pro ($249, 5 requests per second) | no credit or call meter; rate-limited | flat $249; the 2,628,000 reads run in about 6 days at 5 rps sustained, burstable above |
| Triport Business ($499, 15 requests per second) | no credit or call meter; rate-limited | flat $499; the same reads run in about 2 days at 15 rps sustained, burstable above |

Infura's number is credits only: we did not find a price per credit we trust on the page. Ankr's depends on an assumption: its page prints one rate for EVM requests over HTTPS and does not break out trace, so the row may be too high or too low.

Metered billing wins on this job by a wide margin. The cheapest answer is Alchemy at about $27, and a backfill is the textbook case for pay-per-use: you buy 52.56M CU once and stop. On Triport the same job needs a Pro plan, and the sustained 5 requests per second stretches it to about a six-day run — there is no call cap or credit meter to exhaust, and you can burst above the sustained rate.

## Where a flat plan is still the right answer

The honest comparison for a standing workload is the ceiling. Triport Pro permits at most 5 trace requests per second, which is 12.96M `trace_block` calls in a 30-day month. On Alchemy's meter those calls would cost 259.2M CU, or about $134.78. Business permits 15 per second, 38.88M calls, which is about $404.35 on the same meter. The same cap volume on Chainstack is 25.92M RU, about $138 on Growth with overage at $15 per 1M. On those two meters tracing alone is cheaper than our plans at every volume our budget allows. On QuickNode it is 518.4M credits, about $287 on Accelerate with overage, and on Ankr's 200-credit rate about $259, both above $249. Which side of that you land on depends on weights that two of the four providers do not print.

The reasoning that makes a flat plan worth having is different. Trace is a category inside a plan you may already need for other reasons. If your read traffic would cost more than $249 on a metered plan, which on Alchemy's weights is about 18.4M `eth_call` a month or a sustained 7.1 per second, then trace on Triport adds nothing further to the bill, up to its sustained 5 requests per second and burstable above. The incremental price of tracing is zero — there is no call quota or credit meter counting down, only the per-second rate. If the reads do not justify the plan, they do not justify it for the trace either.

Tailing the live chain is a small number in any model. Tracing every new block is 216,000 calls a month: about $2.25 on Alchemy and 8.64M credits inside a QuickNode Build month. On Triport it is about 0.08 requests per second. The cost of live tracing is not what separates these plans; the backfill and the burst are.

## What Triport publishes about archive, and what it does not

We publish rate budgets for trace and debug (Ethereum: 5 requests per second on Pro, 15 on Business; Polygon trace: 3 and 10) and a per-chain statement about history. We do not publish a block floor for Ethereum archive state: the `eth_call` reference says historical reads are "subject to the node's archive depth". The chain registry lists Archive as a capability for Ethereum, which is a statement that it exists, not how deep.

Where we have measured, we say so. For Robinhood Chain the [archive page](https://triport.io/docs/robinhood/archive) gives measured floors (state from block 55,782,445 on the earliest channel, 56,772,445 on another, September 2026), says a full archive from block zero is not confirmed, and says debug methods are best-effort through a single operator with no availability SLA. Parity-style `trace_*` is not part of the Robinhood contract. Base has no frozen archive-state depth, and Tron does not support historical state for `eth_call` or `eth_getBalance`. Read the page for the chain you need before you buy.

## Probe before you buy

"Archive" is easy to verify, because history has a floor you can find by binary search. Pick an address that has held a balance since early in the chain, and ask for its balance at midpoints until the answer flips from success to error:

```ts
async function oldestServed(call: (block: number) => Promise<boolean>, head: number) {
  let lo = 0, hi = head; // invariant: hi is served
  while (lo < hi) {
    const mid = Math.floor((lo + hi) / 2);
    (await call(mid)) ? (hi = mid) : (lo = mid + 1);
  }
  return hi; // about 25 calls for a 24M-block chain
}
```

Twenty-five calls prices out as a rounding error on every plan above; on Chainstack each probe more than 127 blocks behind the tip counts as 2 RU. Run it against each candidate with the same address and the same method, and treat any error, whatever its message, as "not served".

## When this is the wrong approach

If you trace occasionally, such as a handful of transactions a day to debug reverts, none of the above matters; use whichever plan you already pay for. If you need deep history for many addresses or a ready-made index, such as internal transfers per address, a traced backfill is the wrong tool: use an indexed API or build the index once and keep it. If your backfill is a single event, a metered plan for one month costs less than a flat plan whatever the trace weights are. And if you need `vmTrace`-level opcode data, check that your provider offers it: Alchemy's trace page lists `vmTrace` as unavailable.

## Sources

All read 2026-11-01.

1. Alchemy, [Compute unit costs](https://www.alchemy.com/docs/reference/compute-unit-costs) (trace and debug weights, Throughput CU, free archive data), [Pricing](https://www.alchemy.com/pricing), [Trace API quickstart](https://www.alchemy.com/docs/reference/trace-api-quickstart) (requires pay-as-you-go or enterprise; `vmTrace` not available).
2. QuickNode, [Pricing](https://www.quicknode.com/pricing) (archive on all plans, trace and debug from Build) and [API credits, Ethereum](https://www.quicknode.com/api-credits/eth) (20 credits, 2× Advanced APIs, 4× Specialized calls).
3. Chainstack, [Pricing](https://chainstack.com/pricing/) and [Request units](https://docs.chainstack.com/docs/request-units.md): the 127-block rule, 2 RU for debug and trace, the list of 20 block-age methods.
4. Infura, [Credit costs](https://docs.infura.io/get-started/pricing/credit-cost/) and [Pricing](https://www.infura.io/pricing).
5. Ankr, [Service plans](https://www.ankr.com/docs/rpc-service/service-plans/): Premium-only trace, $0.10 per 1M credits, 200 credits per EVM request.
6. Triport, [trace_block](https://triport.io/docs/eth/json-rpc/trace_block), [Ethereum limits](https://triport.io/docs/eth/limits), [Polygon limits](https://triport.io/docs/polygon/limits), [eth_call](https://triport.io/docs/eth/json-rpc/eth_call) and [Robinhood archive depth](https://triport.io/docs/robinhood/archive).

## Try it

- Reference: [trace_block — Ethereum reference, tier and rate limit](https://triport.io/docs/eth/json-rpc/trace_block)
- Network: [Ethereum RPC — one key, JSON-RPC, trace and debug](https://triport.io/ethereum-rpc)