Your indexer reads the latest Taiko block, writes its transfers to the database, and a few seconds later that block no longer exists. It was a preconfirmation, the batch it belonged to never landed in an L1 proposal, and the L2 head rewound. A standard eth_getBlockByNumber("latest") response carries no marker telling you the block was soft, so code that treats one confirmation as final will eventually record a deposit that never happened.
The provider list is the next surprise. Alchemy, QuickNode, Infura and OnFinality do not list Taiko mainnet as of September 2026, and Blast API, which did, shut down on October 31, 2025. The providers that serve Taiko are a different set from the ones you would pick for Base or Arbitrum, and they bill in units ranging from flat per-request pricing to compute units with a 50x chain multiplier on Taiko.
The chain also changed underneath those providers this year. The Shasta fork on April 2 rewrote the protocol and cut proposing costs by roughly 22x. On June 21-22, an attacker used an SGX signing key committed to the public taikoxyz/raiko repository to forge proofs and drain about $1.7M from the bridge. Block production halted and resumed around June 30, with bridge collateral restored 1:1 and the bridge under quotas (The Block, CoinDesk and The Defiant reported the details). The Unzen fork followed on August 6. Any node serving historical Taiko data has to handle all three eras correctly.
This comparison covers five providers that sell or support Taiko RPC, plus Spectrum Nodes, Pocket Network and Taiko's own public endpoint. Pricing is a list-price snapshot from 2026-09-29, normalized to dollars per million calls on a read-heavy mix, alongside archive, trace and WebSocket support.
Provider Comparison
| Provider | Free Tier | Entry Paid | Effective $/1M Calls | Archive on Taiko | WSS | Debug | Trace | getLogs Cap | Pricing Unit | Networks |
|---|---|---|---|---|---|---|---|---|---|---|
| Dwellir | 100K/day | $49/mo | $1.96 | Yes | Yes | Yes | Yes | 10,000 blocks (Growth) | 1 response | 140+ |
| Ankr | Freemium, 200M credits/mo (~1M calls) | $10 deposit | $20.00 | Not stated | Premium | Premium | Premium | Not stated | 200 credits/call | Not stated |
| dRPC | 210M CU (~10.5M calls, public nodes) | $6/1M req | $6.00 | Not stated | Yes | Growth | Growth | Not stated | 20 CU flat | 130+ |
| GetBlock | 50K CU/day | $49/mo | $27.22 | Yes | Yes | Dedicated only | Dedicated only | Not stated | 50 CU/call | 100+ |
| Tenderly | None for RPC | Contact sales | Not published | Not stated | Yes | Yes | Yes | Not stated | TU (~3.15/call) | Not stated |
"Not stated" means the provider's Taiko page does not confirm the feature either way. Ask before you rely on it.
Effective Price per Million Calls
One denominator for every provider: dollars per 1M Taiko calls under a read-heavy mix (mostly eth_call and receipts, with some eth_getLogs and sends; the full breakdown is in How to Compare Taiko Pricing), at the entry paid plan and at the best self-serve rate.
| Provider | Entry Paid Plan | Effective $/1M Calls | Best Self-Serve Rate |
|---|---|---|---|
| Dwellir | Developer $49 | $1.96 | $1.83 (Unlimited Node, 25 RPS) |
| dRPC | Growth, pay as you go | $6.00 | $6.00 |
| Spectrum Nodes | Starter $1.99 | $7.82 | $6.55 (Enterprise $500) |
| Ankr | Premium PAYG, $10 deposit | $20.00 | $16.67 (Deal, +20% credits) |
| GetBlock | Starter $49 | $27.22 | $19.95 (Pro, yearly billing) |
| Tenderly | Contact sales | Not published | Not published |

What That Costs at Volume
Plans step at fixed tiers, so monthly bills differ from the per-million rates. Same read-heavy mix, list prices, including each plan's list price for usage beyond its included calls.
| Provider | 10M req/mo | 50M req/mo | 100M req/mo |
|---|---|---|---|
| Dwellir | $49 | $174 | $299 |
| dRPC | $60 | $300 | $600 |
| Spectrum Nodes | ~$84 | ~$390 | ~$669 |
| Ankr | $200 | $1,000 | $2,000 |
| GetBlock | $349 | Custom (Enterprise from $999) | Custom (Enterprise from $999) |
| Tenderly | Not published | Not published | Not published |
At 10M requests, Dwellir's $49 is the lowest, with dRPC at $60 and Spectrum at about $84. Dwellir stays the lowest on list price at 50M and 100M, at $174 and $299 against dRPC's $300 and $600.
At Taiko's current 0.5 TPS, 10M requests a month is already a busy application, and the free tiers from Dwellir, dRPC and Ankr cover a lot of development and low-traffic production use. The larger columns matter for indexers that backfill Taiko's full history, where replaying roughly 920M lifetime transactions across three protocol eras generates volume quickly.
What Makes Taiko Different for RPC
Taiko Alethia is an Ethereum-equivalent based rollup, meaning Ethereum L1 proposers sequence it instead of a centralized sequencer. Chain ID is 167000 (0x28C58), gas is paid in ETH, and state transitions are secured by multi-proofs: two proofs per range drawn from SGX (Geth), SGX (Reth), SP1 and RISC Zero, with at least one ZK proof required since Unzen. L2BEAT rates it Stage 0, and the Security Council shrank from 9 to 5 members on September 22, 2026. The public testnet is Taiko Hoodi (chain ID 167013); Hekla was deprecated on September 30, 2025.
Standard EVM tooling works unchanged. The differences are in how blocks become final and what a node needs to run.
Three Finality Tiers
Since August 2025, whitelisted preconfirmers (Nethermind, Chainbound and Gattaca, one active operator per epoch) issue blocks roughly every 2 seconds. Those blocks then have to be included in an L1 proposal, which takes 12 seconds or more, and are finally proven and verified on L1. There is no 7-day challenge window.
| Tier | Typical latency | Can it revert? | Safe for |
|---|---|---|---|
| Preconfirmed | ~2 seconds | Yes, if the batch is not proposed to L1 | UI updates, optimistic display |
| Included in L1 proposal | 12 seconds or more | Only if Ethereum L1 reorgs | Most deposits and indexing |
| Proven and verified on L1 | After proofs land | No | Bridge withdrawals, settlement |

Taiko-Specific RPC Methods
taiko-geth exposes a public taiko_ namespace that includes taiko_headL1Origin and taiko_l1OriginByID, which maps an L2 block to the L1 block that included it. These methods tell you whether a block has moved past the preconfirmed tier. The taikoAuth_* methods are auth-only and meant for the driver. Before you commit to a provider, confirm its gateway passes the taiko_ namespace through. Both calls below work against Taiko's public endpoint as of September 29, 2026; run the same requests against your provider's URL.
# Latest L2 block the node has matched to an L1 proposal
curl -s https://rpc.mainnet.taiko.xyz \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"taiko_headL1Origin","params":[]}'
# L1 origin of a specific L2 block (block ID as a hex quantity).
# Returns "not found" for blocks with no stored L1 origin record.
curl -s https://rpc.mainnet.taiko.xyz \
-H "Content-Type: application/json" \
-d '{"jsonrpc":"2.0","id":1,"method":"taiko_l1OriginByID","params":["0xb75e00"]}'
The response includes l1BlockHeight and l1BlockHash, which you can check against your Ethereum node before treating the L2 block as L1-included.
Node Operations and Fork History
Running a Taiko node takes an execution client (taiko-geth, alethia-reth or Nethermind), the taiko-client driver, an L1 execution RPC and an L1 beacon endpoint. Self-hosting means paying for Ethereum access on top of the Taiko node. A managed provider carries that dependency for you.
Archive and trace nodes also have to replay pre-Shasta, Shasta and Unzen blocks with the correct rules for each era. Stale clients fork off the canonical chain, and Unzen requires taiko-geth v2.6.0 or later. A provider that fell behind on upgrades will serve wrong results for recent blocks or stop syncing.
Unzen brought Cancun, Prague and Osaka semantics to Taiko but disabled type-3 blob transactions on the L2, so tooling that defaults to blob transactions needs to send type-2 instead.
Network Activity
Taiko processes about 0.5 TPS, roughly one transaction per block, at a median gas price near 0.009 gwei. DefiLlama puts DeFi TVL at about $256K on September 29, 2026, down from a peak of about $1.75B on December 20, 2024, and L2BEAT reports $13.37M in total value secured. Lifetime transactions sit around 920M, a large share from 2024 campaigns. For most teams, request volume will be modest, so method coverage and finality handling matter more than price at scale.
What to Look for in a Taiko RPC Provider
- Does the gateway pass the
taiko_namespace through?taiko_l1OriginByIDandtaiko_headL1Originconfirm L1 inclusion. If the gateway blocks them, you need a second source of truth. - Which client version does the provider run? Anything below
taiko-gethv2.6.0 cannot follow Unzen. - Is archive and trace access available? Historical state across three protocol eras is only reliable on nodes that replayed each fork correctly, and trace is how you debug reverts.
- Is WebSocket supported? With 2-second preconfirmations,
eth_subscribebeats polling, provided your handler can process a rewind. - What does one call cost? Per-request plans charge every method the same, while weighted plans charge from 1 to 200 units per call depending on the method and the chain. Convert each plan with its published weights before comparing headline rates.
- Does the free tier include your methods? At 0.5 TPS, many Taiko apps fit inside a free or entry tier, but some free tiers exclude trace.
Plan redundancy with the June 2026 halt in mind. Multi-provider failover protects you from a provider outage, but during a protocol halt no provider has new blocks to serve.
How to Compare Taiko Pricing Across Unit Systems
Every headline rate in this comparison is quoted in a different unit. The only way to compare them is to convert each one to dollars per million calls for the methods a Taiko application actually makes, using the weight each provider assigns to the method.
Per-request billing. One response is one unit, whatever the method. Dwellir bills this way, and dRPC does in effect, with a flat 20 CU on every method. Dwellir's Developer plan works out to $1.96 per 1M calls included. dRPC Growth is a flat $6.00 per 1M calls, debug and trace included.
Compute units and credits. The provider charges per million units and gives each method a weight, so the cost of a call depends on the method.
- Ankr charges $0.10 per 1M API credits and 200 credits for every EVM call, debug included, a flat $20.00 per 1M calls.
- GetBlock puts Taiko in its 50x chain-multiplier group, so every standard
eth_*call costs 50 CU and debug or trace calls cost 100 CU, doubled again on archive-mode endpoints. At Starter's rate that is $27.22 per 1M calls and $54.44 per 1Mdebug_traceTransaction. - Spectrum Nodes charges 50 credits per
eth_*call on Taiko and 100 foreth_getLogsanddebug_trace*, which is $7.14 and $14.27 per 1M at the Developer plan's rate. - Tenderly weights
eth_callat 4 TU, writes at 20 and debug or trace at 40, but publishes no dollar rate, so there is no per-call figure to compare.
GetBlock lists debug and trace on dedicated Taiko nodes only, so its debug figure applies where that access exists.
The effective prices and monthly totals in the comparison at the top of this post use a read-heavy mix: 40% eth_call, 25% receipts, 15% eth_blockNumber, 10% eth_getLogs over small ranges, 5% eth_getBalance and 5% eth_sendRawTransaction, all on recent blocks. On that mix, Spectrum averages 55 credits per call, or $7.85 per 1M on Developer. GetBlock charges 50 CU for every call in the mix, so Starter's 90M CU covers 1.8M calls. On Ankr every call is 200 credits, so Freemium's 200M credits cover about 1M calls. Tenderly averages about 3.15 TU per call.
1. Dwellir

Dwellir serves Taiko mainnet over HTTPS and WebSocket at api-taiko-mainnet.n.dwellir.com, with archive state queries and transaction tracing. Billing is 1:1: one API response counts as one credit, whatever the method, so a debug_traceTransaction costs the same as an eth_blockNumber.
Key features:
- HTTPS and WSS endpoints on the same host
- Archive state queries and transaction tracing
- 1:1 response billing across all methods
eth_getLogswith a 10,000-block range on Growth- Unlimited Node for flat, unmetered billing on the same URL and key
- 140+ networks, crypto payment accepted
Pricing:
| Plan | Monthly Cost | Responses Included | RPS (Burst) | Effective $/1M Calls |
|---|---|---|---|---|
| Free | $0 | 100,000/day | 20 | $0 |
| Developer | $49 | 25M | 100 (500) | $1.96 |
| Growth | $299 | 150M | 500 (2,500) | $1.99 |
| Scale | $999 | 500M | 5,000 (10,000) | $2.00 |
| Unlimited Node | Monthly Cost | Calls Covered at Full RPS | Effective $/1M Calls |
|---|---|---|---|
| 25 RPS | $119 | 65M | $1.83 |
| 100 RPS | $479 | 260M | $1.84 |
| 250 RPS | $1,199 | 650M | $1.84 |
| 500 RPS | $2,399 | 1.3B | $1.85 |
| 1,000 RPS | $4,799 | 2.6B | $1.85 |
The 10,000-block eth_getLogs range is documented for Growth, so check Developer's limit before large backfills.
The 1:1 model fits Taiko's finality handling. Confirming L1 inclusion adds calls per block, whether taiko_l1OriginByID lookups or re-reads after a rewind, and each costs the same as any other read. At Taiko's current activity, many applications will fit inside the Developer plan's 25M monthly responses; measure your call volume on the free tier to confirm.
Best for: Teams that want archive, trace and WebSocket access on one per-request price, with a clear upgrade path to flat-rate throughput.
2. Ankr

Ankr offers Taiko on a Freemium plan and paid access through its Premium plan.
Key features:
- Freemium plan with 200M credits per month
- WebSocket access on Premium
- Debug and trace methods on Premium
- Up to roughly 1,500 RPS on Premium
Pricing:
| Plan | Monthly Cost | Included | RPS | Effective $/1M Calls |
|---|---|---|---|---|
| Freemium | $0 | 200M credits (~1M calls) | ~30 | $0 |
| Premium PAYG | $10 minimum deposit | Usage-based | ~1,500 | $20.00 |
| Deal | $500-3,000 | Credits +20% bonus | ~1,500 | $16.67 |
Ankr charges $0.10 per 1M credits and 200 credits for every EVM call, debug included, so Premium works out at $20.00 per 1M calls whatever the method. Deals add 20% bonus credits, which brings the rate to $16.67 per 1M. Only GetBlock costs more per call among the metered providers here, which matters less at Taiko's current volumes than it would on a busier chain.
Best for: Teams already on Ankr for other chains, or anyone who wants a credit-based free tier for light development traffic.
3. dRPC

dRPC routes Taiko traffic across a decentralized network of node operators, with endpoints at https://taiko.drpc.org and wss://taiko.drpc.org.
Key features:
- Multi-operator routing with failover
- HTTPS and WSS endpoints
- Flat 20 CU per method on Growth, debug and trace included
- 5,000 RPS on Growth
- 130+ networks; Enterprise plans from 300M requests per month
Pricing:
| Plan | Monthly Cost | Included | RPS | Effective $/1M Calls |
|---|---|---|---|---|
| Free | $0 | 210M CU (public nodes, ~10.5M calls) | 100 | $0 |
| Growth | $6/1M requests | Pay as you go | 5,000 | $6.00 |
| Enterprise | Custom, from 300M req/mo | Volume discounts | Unlimited | Custom |
dRPC's flat rate of $6.00 per 1M calls covers every method, billed from the first request with no bundled allocation. The free tier is large at roughly 10.5M calls a month, but it routes to public nodes and excludes trace, debug and filter methods, which rules it out for eth_newFilter or revert diagnosis.
Best for: Teams that want a second provider for failover without a monthly commitment, or that value multi-operator routing over unit price.
4. GetBlock

GetBlock added Taiko on December 29, 2025, with shared and dedicated mainnet nodes over HTTPS and WSS in Frankfurt, New York and Singapore.
Key features:
- Shared and dedicated Taiko mainnet nodes
- Archive access
- Debug and trace on dedicated nodes
- Three regions: Frankfurt, New York, Singapore
- 100+ networks
Pricing:
| Plan | Monthly Cost | CU | Calls Covered | RPS | Effective $/1M Calls |
|---|---|---|---|---|---|
| Free | $0 | 50K/day | ~1,000/day | 20 | $0 |
| Starter | $49 | 90M | 1.8M | 250 | $27.22 |
| Growth | $99 | 185M | 3.7M | 300 | $26.76 |
| Advanced | $199 | 385M | 7.7M | 450 | $25.84 |
| Scale | $349 | 700M | 14M | 600 | $24.93 |
| Pro | $499 ($399 yearly) | 1B | 20M | 800 | $24.95 ($19.95 yearly) |
| Premium | $699 | 1.6B | 32M | 800 | $21.84 |
| Enterprise | from $999 | Custom | Custom | Custom | Custom |
Effective price is the plan cost spread over the Taiko calls its CU cover.
Taiko sits in GetBlock's 50x chain-multiplier group, so every standard call costs 50 CU and debug or trace calls cost 100 CU. The CU totals on the pricing page therefore overstate Taiko call capacity by 50 times, and the cheapest self-serve rate is $19.95 per 1M calls on Pro with yearly billing. Dedicated full nodes start at $1,000 a month and archive nodes at $1,500, with debug and trace on dedicated only. The Singapore region helps if you need a Taiko endpoint close to Asian users.
Best for: Teams that need a Taiko node in a specific region, or a dedicated node with a published starting price.
5. Tenderly

Tenderly offers Taiko mainnet node RPC at taiko-mainnet.gateway.tenderly.co with WebSocket support, eth, debug and trace namespaces, and Tenderly's simulation methods.
Key features:
debugandtracenamespaces- Simulation methods exposed over RPC
- WebSocket endpoint
- Debugger and monitoring tooling
Pricing: Sales-led. Node RPC is on paid plans only, and Tenderly does not publish dollar prices for it. Billing uses Tenderly Units:
| Method type | TU cost |
|---|---|
| Read | 1 TU |
Compute (eth_call) | 4 TU |
| Write | 20 TU |
| Debug and trace | 40 TU |
Effective $/1M calls: not published, so Tenderly cannot be placed on the same scale as the other providers.
The read-heavy mix averages about 3.15 TU per call. Simulation is Tenderly's main draw on Taiko. After the June 2026 incident and two protocol forks in four months, simulating contract interactions against current state before deploying is a sensible check. Trace calls cost 40 times as many units as reads, so get a quote against your actual method mix.
Best for: Development and QA teams that want simulation and debugging on the same endpoint they call.
Also Serving Taiko
Spectrum Nodes lists Taiko mainnet on chain-agnostic credit plans. On Taiko it charges 50 credits per eth_* call and 100 for eth_getLogs and debug_trace*, so the read-heavy mix averages 55 credits per call: $7.85 per 1M calls on Developer ($9.99 for 70M credits), $7.17 on Business and $6.55 on Enterprise ($500 for 4.2B credits). A $1.99 Starter plan (14M credits, $7.82 per 1M calls) sits below Developer, and the free plan's 10M credits cover about 180K Taiko calls. Spectrum is not on Taiko's provider list and makes no archive or trace claim for the chain.
Pocket Network serves Taiko free at https://taiko.api.pocket.network through decentralized suppliers, with no paid Taiko tier published.
Taiko's own public RPC at https://rpc.mainnet.taiko.xyz is rate-limited without a published number, and the Taiko docs direct production users to a third-party provider. None of these free endpoints carries an SLA, and all are shared with every other anonymous user of the chain.
Choosing the Right Provider
Best all-round choice: Dwellir. Archive, tracing and WebSocket share one 1:1 price, so the extra calls Taiko's finality model requires (L1-origin lookups and re-reads after a rewind) cost the same as any read. At $1.96 per 1M calls on the Developer plan, it is below dRPC's $6.00 and Spectrum's $7.82 on the read-heavy mix, and debug calls cost the same $1.96. The Unlimited Node offers a flat-rate path from $119 a month once traffic is steady.
Best for failover: dRPC. dRPC's multi-operator routing and $6.00 flat pay-as-you-go rate make it a low-commitment second provider. It covers a provider outage, though no provider protects against a protocol-level halt.
Best for simulation and debugging: Tenderly. Two forks and a bridge incident in four months make pre-deployment simulation against current Taiko state a sensible habit. Tenderly exposes simulation over the same RPC interface, at a price you will need to request.
Getting Started
Before you commit to a Taiko provider, run three checks on a free tier or trial. Call taiko_l1OriginByID and taiko_headL1Origin to confirm the gateway passes the taiko_ namespace through. Trace one transaction from each era (before April 2, between April 2 and August 6, and after August 6, 2026) to confirm the node replays pre-Shasta, Shasta and Unzen blocks correctly. Then decide which finality tier each part of your application waits for, and build the rewind handling for anything that acts on preconfirmed blocks.
Building on Taiko? See Dwellir's Taiko endpoints for connection details, create a Dwellir account to start on the free tier, or talk to the Dwellir team about archive and throughput requirements for indexing workloads.
For comparisons on other networks, see Top Arc RPC Providers and Best RPC Node Providers of 2026.
Sources
Provider pricing checked on 29 September 2026.
- Dwellir Taiko network page and Dwellir pricing
- Ankr Taiko docs, Ankr service plans and Ankr pricing
- dRPC Taiko chainlist and dRPC pricing
- GetBlock Taiko nodes and GetBlock plans and limits and GetBlock compute units
- Spectrum Nodes pricing
- Tenderly Taiko RPC reference
- Pocket Network Taiko endpoint (
taiko.api.pocket.network) - Taiko documentation - finality, preconfirmations, node requirements, public RPC guidance
- taiko-geth -
taiko_namespace methods - L2BEAT Taiko - Stage 0, total value secured, Security Council change
- DefiLlama Taiko - DeFi TVL
- The Block, CoinDesk and The Defiant - June 2026 bridge exploit, halt and recovery reporting


