Top 8 Tempo RPC Providers 2026: Pricing and Performance Comparison

A single payment on Tempo generates 5-8 RPC calls: balance checks, TIP-20 memo lookups, policy registry queries, Fee AMM interactions for stablecoin gas, and settlement confirmation. Multiply that across thousands of concurrent transactions on a chain producing blocks every 500-600ms, and your RPC provider becomes the bottleneck for your entire payments stack.

Tempo went live on March 18, 2026 - a payments-focused EVM L1 backed by Stripe and Paradigm. Launch partners including Deutsche Bank, Mastercard, Visa, and Shopify are already integrating. The chain targets 100,000+ TPS with sub-$0.001 transaction fees and deterministic finality in 0.6 seconds.

Public endpoints cap out at roughly 100 requests per minute. That is not enough for production payments. This comparison breaks down the 8 RPC providers currently supporting Tempo mainnet, with pricing normalized so you can make a direct cost comparison.

What Makes Tempo Different for RPC

Tempo is not a typical EVM chain. The differences directly affect your RPC requirements.

No native gas token. Tempo replaces the standard gas model with a built-in Fee AMM that accepts any listed USD stablecoin. Your RPC provider needs to handle these non-standard fee transactions cleanly. Wallet integrations and transaction simulations that assume ETH-style gas will break.

Deterministic finality with no re-orgs. Tempo uses Simplex BFT consensus via Commonware, achieving finality in 0.6 seconds with zero chain reorganizations. A single block confirmation is final, which simplifies indexing. But your infrastructure must keep pace. A block every 500-600ms generates roughly 150,000 blocks per day, and falling behind on block ingestion is easy if your RPC connection is slow or unreliable.

Payment-native primitives. TIP-20 tokens extend ERC-20 with memo fields and compliance hooks. The Machine Payments Protocol (MPP), co-authored with Stripe, enables machine-to-machine payment streaming. Both generate higher RPC call density per workflow than a standard token transfer and both require WebSocket support for real-time event monitoring.

What to Look for in a Tempo RPC Provider

Not every criterion matters equally on Tempo. These factors carry the most weight for payment infrastructure:

• Latency - With 500-600ms block times, your RPC round-trip needs to stay well under that threshold. Providers with points of presence closer to Tempo validators have an edge.
• Archive node access - Financial services on Tempo face compliance and audit requirements. Archive nodes let you query historical state at any block height, which is essential for transaction reconciliation and regulatory reporting.
• WebSocket support - MPP streaming payments and TIP-20 event monitoring depend on persistent WebSocket connections, not polling. Confirm your provider offers stable WSS endpoints.
• Trace and debug APIs - debug_traceTransaction and related methods are critical for diagnosing failed payment flows in production. Not all free tiers include these.
• Pricing transparency - Some providers bill in "compute units" where a simple read costs 10-20 units but a debug_traceTransaction costs 40-300. On a payment chain generating dense RPC workloads, opaque pricing multipliers cause bill shock.
• Uptime SLAs - Banks and fintechs integrating with Tempo expect institutional-grade reliability. A 99.9% SLA allows up to 8.7 hours of downtime per year. A 99.99% SLA brings that down to 52 minutes.

How to Compare Tempo 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 payment backend actually makes, using the weight each provider assigns to the method on Tempo. Prices are a list-price snapshot from 2026-09-28.

Per-request billing. One response is one unit, whatever the method. Dwellir bills this way, and Chainstack does too on recent state (1 request unit per call, 2 for reads 127 or more blocks behind the tip and for every debug or trace call). Dwellir's Developer plan works out to $1.96 per 1M calls included, with overage at $2-5 per 1M. Chainstack Growth is $2.45 per 1M included, $15 per 1M overage.

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.

• Alchemy charges $0.525 per 1M CU. That is $13.65 per 1M eth_call, $31.50 per 1M eth_getLogs, $21.00 per 1M eth_sendRawTransaction, $10.50 per 1M eth_getTransactionReceipt or eth_getBalance, and $21.00 per 1M debug_traceTransaction.
• QuickNode assigns a flat 20 credits to every Tempo call, which is $10.00 per 1M calls at Business's overage rate and $12.40 at Build's. Debug and trace calls carry a 2x chain multiplier, $20.00 per 1M at Business's rate.
• Conduit's Pro plan includes 1B CU for $50, or $0.05 per 1M CU, with overage at $0.10 per 1M CU. Its weights run from 15 CU for eth_getTransactionReceipt to 75 for eth_call and eth_getLogs, 200 for eth_sendRawTransaction and 300 for debug_traceTransaction.
• dRPC assigns 20 CU to every method, so every call costs the same. The $49 Pro plan works out to $4.80 per 1M calls, Scale ($199) to $4.20, and pay as you go and overage to $6.00, with trace and archive included on paid plans.
• Validation Cloud weights Tempo methods at 20-80 CU and charges $0.35-0.50 per 1M CU depending on monthly volume.
• Tenderly weights eth_call at 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.

Method by method, in dollars per 1M calls at each plan's included rate:

Conduit's included rate is the lowest here for receipts, and Conduit's overage doubles its unit rate once the 1B CU are used. Chainstack doubles the unit for reads 127 or more blocks behind the tip and for debug and trace calls.

The monthly totals later in this post use a mostly-reads payment mix: 40% eth_call, 25% eth_getTransactionReceipt, 15% eth_blockNumber, 10% eth_getLogs over small ranges, 5% eth_getBalance and 5% eth_sendRawTransaction, all on recent blocks. On that mix a Tempo call averages 25.9 CU on Alchemy ($13.60 per 1M calls), 53.75 CU on Conduit (eth_call and eth_getLogs 75 CU, receipts 15, eth_getBalance 20, eth_blockNumber 10, sends 200; $2.69 per 1M inside Pro's 1B CU), 43 CU on Validation Cloud ($15.05-21.50 per 1M) and 20 credits on QuickNode, so Build's 80M credits cover 4M calls and Business's 2B credits cover 100M.

1. Dwellir

Dwellir provides Tempo RPC with a 1:1 pricing model - every API response counts as one request, regardless of method complexity. No compute units, no multipliers. A debug_traceTransaction costs the same as an eth_getBalance.

Key features:

• 170+ supported networks
• Archive state on the shared Tempo endpoint: historical eth_call and eth_getBalance at early blocks returned results when tested on 2026-09-28
• trace, debug and txpool namespaces exposed on the Tempo endpoint, plus WebSocket
• Unlimited Node for flat, unmetered billing on the same URL and key
• European infrastructure, autoscaling on paid plans
• Crypto payments accepted on every paid plan

Pricing:

A dedicated Tempo node cluster lists at $4,300 per month with unlimited RPS and responses.

The 1:1 pricing model is directly relevant to Tempo workloads. Payment workflows that rely on trace APIs and memo lookups cost more on providers that apply compute unit multipliers to complex methods: a debug_traceTransaction is one credit here, 40 CU on Alchemy and 300 CU on Conduit. At the Scale tier, $2 per million overage requests is among the lowest overage rates in this comparison.

Best for: Teams that need predictable costs at scale, especially those running compliance-heavy payment infrastructure where trace and debug calls are frequent.

2. Chainstack

Chainstack differentiates with SOC 2 Type II certification and a 99.99% uptime SLA. These credentials matter when your Tempo integration serves regulated financial institutions.

Key features:

• Archive nodes and WebSocket included
• Trace API on paid plans
• SOC 2 Type II certified
• 99.99% uptime SLA
• Unlimited Node add-on option (flat-rate RPS billing)

Pricing:

A request under 127 blocks behind the tip costs 1 RU; 127 or more blocks behind costs 2 RU as an archive read, and debug and trace calls cost 2 RU regardless of block age. Chainstack's Tempo API reference documents debug_* and trace_* methods.

Chainstack uses straightforward request-based pricing without compute unit multipliers, and its included rates sit close to Dwellir's. Overage costs run higher: $15 per million calls on the Growth tier compared to $5 at Dwellir Developer or $12.40 at QuickNode Build. The SOC 2 certification and formal SLA make Chainstack worth evaluating for teams where compliance documentation is a hard requirement from institutional partners.

Best for: Teams building for regulated financial institutions that require SOC 2 certification and formal uptime SLAs as part of vendor qualification.

3. dRPC

dRPC offers 210M compute units per month at 100 RPS on its free tier, making it a strong option for development and testing on Tempo.

Key features:

• 130+ supported networks
• Archive nodes and WebSocket included
• Trace API on paid plans
• AI-driven load balancer
• MEV protection on paid tiers
• Accepts crypto payments
• 99.96% uptime listed on paid tiers

Pricing:

Every method costs a flat 20 CU, so 210M free compute units cover about 10.5M Tempo calls on public nodes, and the keyless Tempo endpoint answered when tested on 2026-09-28. Paid plans charge the same for any method: $4.80 per million requests on the $49 Pro plan (300 RPS), $4.20 on Scale (600 RPS), and $6 on pay as you go and overage. That is higher than the included rates at Dwellir, Chainstack and Conduit, and lower than QuickNode, Alchemy and Validation Cloud on the payment mix.

Best for: Teams in early development that want maximum free-tier capacity, or workloads up to 600 requests per second on a self-serve plan without enterprise contracts.

4. Conduit

Conduit is primarily known as a rollup deployment platform (OP Stack, Arbitrum Orbit) and runs Tempo RPC endpoints through Conduit Nodes. Its docs describe Conduit as a design partner on Tempo alongside Stripe and Paradigm.

Key features:

• HTTP and WebSocket on Tempo mainnet and testnet
• Full history from genesis on all supported networks, on every plan
• debug_* methods priced in the CU table; trace_* methods not listed
• Spend limits on paid plans

Pricing:

Conduit weights eth_call and eth_getLogs at 75 CU, eth_sendRawTransaction at 200 and debug_traceTransaction at 300, so a Tempo call averages 53.75 CU on the payment mix. Inside Pro's 1B CU that is $2.69 per 1M calls, and above it autoscaling at $0.10 per 1M CU makes it $5.38. The free tier stops at 100M CU with an HTTP 403 rather than billing overage.

Best for: Teams already using Conduit for rollup deployments who want to consolidate their multi-chain RPC under one provider.

5. Tenderly

Tenderly runs Tempo node RPC at tempo.gateway.tenderly.co (HTTPS and WSS) alongside its development toolkit: simulation, execution traces, monitoring and alerting.

Key features:

• 80+ supported networks
• Public Tempo gateway (answered when tested on 2026-09-28)
• Transaction simulation and debugging
• Dev tools and monitoring enabled on Tempo; Virtual TestNets (forks) not listed as supported on Tempo
• Real-time alerting

Pricing: Sales-led. Node RPC is available on paid plans only, and the Free plan has no Node RPC access. No public dollar prices were published on 2026-09-28.

The payment mix averages about 3.15 TU per call, but without a published dollar rate Tenderly cannot be placed on the same scale as the other providers. Archive on Tempo is not stated. Tenderly's real value is its development tooling: simulating payment transactions and tracing them before deploying.

Best for: Development and QA teams that need to simulate and debug Tempo payment flows before production deployment and can negotiate pricing with sales.

6. Validation Cloud

Validation Cloud offers a straightforward compute-unit model with volume-based discounting and zero rate limits on the paid Scale tier.

Key features:

• 20+ supported networks
• Zero rate limits on Scale tier
• Volume-based pricing discounts
• Tempo mainnet with full history, HTTPS and WSS, plus Debug and Trace APIs

Pricing:

On Tempo, eth_call, eth_getTransactionReceipt and eth_getBalance cost 40 CU, eth_blockNumber 20, and eth_getLogs, eth_sendRawTransaction and debug_traceTransaction 80. The payment mix averages 43 CU per call, so the free 50M CU covers about 1.2M calls and the rate falls from $21.50 to $15.05 per 1M calls as volume grows. Network coverage is limited at 20+ chains compared to 70-150+ at larger providers, but if your focus is Tempo, that may not matter.

Best for: Teams with highly variable traffic patterns that need unlimited RPS without negotiating enterprise contracts.

7. QuickNode

QuickNode supports Tempo with its credit-based pricing model and adds Streams and Webhooks on paid tiers - useful for building event-driven payment notification systems.

Key features:

• 79+ supported networks
• Archive (no pruning) and WebSocket on Tempo
• Debug and Trace APIs on paid plans
• QuickNode Streams and Webhooks (paid tiers)
• Support for Tempo memo fields, batch transfers, and compliance tools

Pricing:

Effective price is the plan cost spread over the Tempo calls its credits cover. Every Tempo method costs 20 credits, and debug and trace calls cost 40.

QuickNode Streams provide push-based data delivery rather than constant polling, which suits Tempo payment monitoring well. At 20 credits per call, the credit totals overstate Tempo request capacity by 20 times. At the Business tier ($999/month), 2B credits cover about 100M Tempo calls with RPS capped at 500, compared to Dwellir's 5,000 RPS (10,000 burst) at the same price point.

Best for: Teams that want event-driven infrastructure (Streams and Webhooks) alongside standard RPC for building payment notification and monitoring systems.

8. Alchemy

Alchemy is a day-1 Tempo mainnet partner with dedicated tooling for TIP-20 tokens and Tempo's payment primitives. The platform uses compute units (CU) for billing, where method complexity determines cost per call.

Key features:

• 100+ supported networks
• Archive data and WebSocket included
• Tempo-specific SDKs for TIP-20 and payment primitives
• Debug API live on Tempo; Trace API listed as "Request support" (not live on Tempo)
• Day-1 Tempo launch partner with dedicated integration support

Pricing:

The free tier's 30M compute units cover about 1.2M Tempo calls on the payment mix, not 30M. eth_getLogs costs 60 CU, or $31.50 per 1M log queries, and the mix lands at $13.60 per 1M calls on Pay as You Go. Debug and Trace APIs are not on the Free plan. Alchemy's Tempo-specific tooling is a genuine advantage for teams building directly on TIP-20 and MPP.

Best for: Teams that want Tempo-native SDKs and are willing to work within a compute unit billing model for access to Alchemy's broader developer platform.

Provider Comparison

Effective Price per Million Calls

One denominator for every provider: dollars per 1M Tempo calls under the payment mix, at the entry paid plan and at the best self-serve rate, with overage alongside.

What That Costs at Volume

Plans step at fixed tiers, so monthly bills differ from the per-million rates. Same payment mix, list prices.

At 10M requests, Dwellir's $49 ties Chainstack and dRPC's Pro plan, with Conduit at about $50; dRPC's free tier also covers about 10.5M calls on public nodes. At 50M and 100M, Dwellir's metered plans are the lowest list price in this comparison, and the Unlimited Node at 50M is $119 if average traffic stays under 25 RPS and $479 for the 100 RPS tier. Figures marked "~" depend on the method mix: on Alchemy, Conduit and Validation Cloud a log-heavy, write-heavy or eth_call-heavy workload costs more, while Dwellir, Chainstack (recent blocks), dRPC and QuickNode (non-debug calls) bill the same for every method.

Choosing the Right Provider

For most teams building on Tempo, the decision comes down to three scenarios.

Best all-round choice: Dwellir. The 1:1 pricing model eliminates the guesswork that comes with compute unit billing. This is particularly important on Tempo, where payment workflows generate a dense mix of reads, trace calls, and memo lookups. At the Scale tier, 5,000 RPS with 10,000 burst and $2/M overage gives substantial headroom for production payment systems. Historical state and the trace and debug namespaces are on the same endpoint, and the Unlimited Node starts at $119 for 25 RPS.

Best for Tempo-native tooling: Alchemy. As a day-1 launch partner with dedicated TIP-20 and MPP SDKs, Alchemy offers the deepest Tempo-specific developer experience. If your team is building directly on Tempo's payment primitives and values integrated tooling over pricing simplicity, Alchemy is the strongest alternative.

Best for development and testing: dRPC or Tenderly. dRPC's 210M CU free tier at 100 RPS covers about 10.5M Tempo calls on public nodes, the most generous sandbox here. Tenderly adds transaction simulation and debugging on Tempo, useful for teams building complex payment logic that needs thorough testing before going live.

Frequently Asked Questions

What is the best Tempo RPC provider?

Dwellir offers the best all-round choice for Tempo with 1:1 pricing that eliminates compute unit complexity. This is particularly important on Tempo where payment workflows generate a dense mix of reads, trace calls, and memo lookups. For Tempo-native tooling, Alchemy is the strongest alternative as a day-1 launch partner.

What is Tempo blockchain?

Tempo is a payments-focused EVM Layer 1 backed by Stripe and Paradigm that launched on March 18, 2026. It targets 100,000+ TPS with sub-$0.001 transaction fees and deterministic finality in 0.6 seconds. Unique features include no native gas token (accepts any listed USD stablecoin), TIP-20 tokens with memo fields, and the Machine Payments Protocol (MPP) for machine-to-machine payment streaming.

Are there free Tempo RPC endpoints?

Yes. dRPC offers 210M free compute units monthly at 100 RPS, Conduit provides 100M free compute units, Alchemy includes 30M free compute units, Validation Cloud includes 50M free compute units, and Dwellir provides 100K free requests per day. Tenderly's Free plan has no Node RPC access. These tiers are suitable for development and prototyping.

What RPC performance does Tempo require?

Tempo produces blocks every 500-600ms, so RPC round-trip latency must stay well under that threshold. A single payment generates 5-8 RPC calls. Production payment infrastructure needs stable WebSocket connections for MPP streaming payments, archive nodes for compliance and audit requirements, and trace/debug APIs for diagnosing failed payment flows.

Related Resources

• RPC Providers Without Compute Units - Why transparent pricing matters for Tempo's dense payment workloads
• Self-Hosted vs Managed RPC Nodes - Evaluate whether to run your own Tempo infrastructure or use a managed provider

Getting Started

Tempo mainnet launched on March 18, 2026. Provider support, documentation, and tooling will evolve rapidly as the ecosystem matures. The providers listed here all support Tempo today, but feature depth and stability will vary as the ecosystem matures.

If you are evaluating Tempo RPC for production payment infrastructure, test latency and reliability across 2-3 providers with your actual workload patterns. Free tiers exist across most options - use them.

Ready to build on Tempo? Get started with Dwellir's Tempo RPC endpoints or contact the Dwellir team to discuss infrastructure requirements for your payment integration.