What are Compute Units (CUs)? RPC Billing Explained

Have you ever loaded up API credits, fired off what felt like a handful of requests, and watched your balance drain way faster than expected? You're not the only one.

If you're evaluating RPC providers, you've probably seen pricing listed in "Compute Units" or "CUs" and it's not always obvious what that actually means for your bill.

TL;DR

Compute Units (CUs) measure the processing cost of blockchain RPC requests. Instead of charging per request, providers use CUs, so you pay based on actual resource usage.
Key points:

Simple calls (eth_blockNumber) = 1 CU; complex ones (debug_traceTransaction) = 500–1000+ CU
Estimate monthly usage by multiplying each method's CU cost by its call frequency
GetBlock plans range from free (50K CU/day) to $499/mo (600M CU/month)
Optimize by caching responses, batching requests, using WebSockets instead of polling, and narrowing eth_getLogs ranges

This guide explains how CU-based billing works, why providers use it instead of flat per-request pricing, and how to estimate your actual costs before you commit.

What are Compute Units(CUs)

Compute Units are units of measurement for computational resources such as Central Processing Units (CPUs), Graphics Processing Units(GPUs), and memory. It is used in cloud computing, AI, and blockchain to quantify and bill usage. In blockchain, it measures the amount of work a blockchain node performs to process your request.

Not all RPC methods are equal:

eth_blockNumber = 1 CU (trivial: just returns a number)
eth_getBalance = ~10 CU (reads current state)
eth_call = ~20-50 CU (executes smart contract logic)
eth_getLogs (large range) = ~100+ CU (scans many blocks)
debug_traceTransaction = ~500+ CU (replays entire transaction)

Instead of charging per request (where a simple eth_blockNumber and a heavy debug_traceTransaction would cost the same), CU-based pricing aligns your cost with the actual resources consumed.

Ready to access blockchain data with flexible pricing? Sign up for GetBlock and start building with our RPC endpoints today.

Why Providers Use CU Billing

Old model (per-request): Every API call costs the same. Problem: heavy methods subsidized by light ones, or light users subsidize heavy users.

CU model: Each method has a weight. You pay for actual compute consumption. This is fairer and allows providers to offer higher quotas for simple methods.

How CU Costs Vary

Method Category	CU Range	Examples
Lightweight reads	1–5 CU	eth_blockNumber, eth_chainId, net_version
State reads	10–30 CU	eth_getBalance, eth_getTransactionCount, eth_gasPrice
Contract calls	20–100 CU	eth_call, eth_estimateGas
Log queries	50–500+ CU	eth_getLogs (depends on block range)
Transaction submission	20–50 CU	eth_sendRawTransaction
Debug/Trace	200–1000+ CU	debug_traceTransaction, trace_block
Archive queries	Higher multiplier	Any method at a historical block

The exact CU cost per method varies by blockchain and provider. Check GetBlock's Compute Units page for specific costs.

How to Estimate Your Monthly CU Usage

Formula

Monthly CUs = Σ (method_CU_cost × calls_per_month)

Example: DeFi Price Feed Bot

Method	CU/call	Calls/day	Monthly CUs
eth_call (read prices)	30	10,000	9,000,000
eth_getBlockByNumber	15	1,440	648,000
eth_gasPrice	5	5,000	750,000
eth_sendRawTransaction	40	100	120,000
Total			~10.5M CU/month

This fits comfortably in GetBlock's Starter plan (50M CU/month, $49/mo).

Example: NFT Marketplace Backend

Method	CU/call	Calls/day	Monthly CUs
eth_call (metadata, balances)	30	50,000	45,000,000
eth_getLogs (transfer events)	100	5,000	15,000,000
eth_getTransactionReceipt	15	10,000	4,500,000
eth_blockNumber	1	86,400	2,592,000
Total			~67M CU/month

→ Starter plan (50M CU) is close but may need Advanced (220M CU, $199/mo) for headroom.

GetBlock CU Plans at a Glance

Plan	CU Allocation	Cost	Cost per 1M CU
Free	50K/day (~1.5M/month)	$0	$0
Starter	50M/month	$49/mo	$0.98
Advanced	220M/month	$199/mo	$0.90
Pro	600M/month	$499/mo	$0.83
Enterprise	Custom	From $999/mo	Negotiable
Dedicated	Unlimited	From $1,000/mo	$0 (unlimited)

Key policies:

Unused CUs roll over to the next month (if subscription is active)
Extra CU packages can be purchased without upgrading plans
Free plan CUs reset daily (no rollover)

CU Optimization Tips

1. Cache aggressively

Don't call eth_blockNumber every second if you can cache it for 12 seconds (one block).

2. Batch requests

Send multiple JSON-RPC calls in a single HTTP request:

[
     {"jsonrpc":"2.0","method":"eth_blockNumber","params":[],"id":1},
     {"jsonrpc":"2.0","method":"eth_gasPrice","params":[],"id":2}
]

3. Use WebSocket for real-time data

Instead of polling eth_blockNumber every second (2.6M CU/month), subscribe via WebSocket:

provider.on("block", (blockNumber) => {
     // React to new blocks without polling
});

4. Narrow eth_getLogs ranges

Wide block ranges in eth_getLogs consume significantly more CUs. Query smaller ranges.

5. Monitor your dashboard

GetBlock's dashboard shows CU consumption by method. Identify your heaviest methods and optimize those first.

CU vs Credits vs Requests: Provider Comparison

Provider	Billing Unit	Complexity
GetBlock	Compute Units (CU)	Clear tiers, CU cost per method documented
Alchemy	Compute Units (CU)	Similar concept, different weights
QuickNode	Credits	Method-weighted, it can be harder to predict
Chainstack	Requests	Simple per-request count (every call = 1)
Infura	Credits	Varies by method
Ankr	Credits	Pay-as-you-go model

Chainstack's request-based model is the simplest to understand, but CU-based models (GetBlock, Alchemy) are more fair; you don't pay the same for a cheap eth_blockNumber and an expensive debug_traceTransaction.

Not sure which plan fits your CU needs? Contact us — we can estimate based on your current usage.