Compute Units

Every request costs Compute Units (CU) — a weight that reflects how much work the method puts on a node. Light lookups cost 1 CU, heavy scans up to 75. Your plan sets the price per CU (Billing); the free plan meters usage but bills nothing.

How metering works

• Weight is per (chain, method) — the full current matrix is below; any (chain, method) pair not listed costs 1 CU.
• The meter matches the JSON-RPC method field (for REST chains, the final path segment).
• Cached responses (X-Cache: HIT) are still metered — the weight pays for the API call, not only node I/O.
• Batch requests are metered per inner call.
• WebSocket streams are free after the handshake (WebSockets).
• Each project has a daily CU quota (default 100,000). Exceeding it returns JSON-RPC -32005 (compute unit quota exceeded) until the 24-hour window rolls over.
• Methods in the heavy class (eth_getLogs, debug_*/trace_*, …) also consume the per-plan heavy-method budget, independent of CU.

Method weights

Current live values (weights are operator-tunable; this table tracks the deployed defaults).

EVM — Ethereum, BNB Smart Chain, Polygon, Avalanche C-Chain

Identical weights on /eth, /bsc, /polygon, /avax:

CU	Methods
0	eth_chainId · net_version · net_listening · web3_clientVersion
1	eth_blockNumber · eth_gasPrice · eth_maxPriorityFeePerGas
5	eth_feeHistory · eth_getBalance · eth_getTransactionCount · eth_getTransactionByHash · eth_getTransactionReceipt
10	eth_getBlockByNumber · eth_getBlockByHash · eth_getCode · eth_getStorageAt
15	eth_call · eth_estimateGas
20	eth_sendRawTransaction
75	eth_getLogs

(/eth additionally prices eth_sendTransaction at 20 CU — moot in practice: nodes hold no accounts, sign locally and use eth_sendRawTransaction.)

Bitcoin

CU	Methods
1	getblockcount · getbestblockhash · getblockhash · getblockchaininfo · getnetworkinfo · estimatesmartfee
5	getmempoolinfo · gettxout
10	getblock · getrawtransaction
20	sendrawtransaction

Litecoin & Dash

CU	Methods
1	getblockcount · getbestblockhash · getblockchaininfo · getnetworkinfo
10	getblock · getrawtransaction
20	sendrawtransaction

Bitcoin Cash and Liquid currently meter every method at 1 CU.

TRON (REST, /tron/wallet/<method>)

CU	Methods
0	getnodeinfo
1	getnowblock
5	getaccount · gettransactionbyid · gettransactioninfobyid
10	getblockbynum · getblockbyid
15	createtransaction
20	broadcasttransaction · broadcasthex · triggersmartcontract

XRP Ledger

CU	Methods
0	server_info · fee
1	server_state · ledger_current
5	account_info · tx
10	ledger
20	submit · submit_multisigned

NEAR

CU	Methods
0	status · network_info
5	block · chunk · tx
10	query · EXPERIMENTAL_tx_status
20	broadcast_tx_async · broadcast_tx_commit

Sui

CU	Methods
0	sui_getReferenceGasPrice
1	sui_getLatestCheckpointSequenceNumber · sui_getTotalTransactionBlocks
5	sui_getObject · sui_getTransactionBlock
10	sui_multiGetTransactionBlocks
15	sui_dryRunTransactionBlock · sui_devInspectTransactionBlock
20	sui_executeTransactionBlock

TON (JSON-RPC form, POST /ton)

CU	Methods
0	getConfigAll
1	getMasterchainInfo
5	getTransactions · lookupBlock · getShardBlockProof
10	runGetMethod
20	sendBoc · sendBocReturnHash

Everything else

Stellar, Cosmos Hub, Aptos and Cardano currently meter all methods at 1 CU/call, as does any method not listed above on any chain. Weights may be introduced per method over time — the tables here follow the deployed values.

Reading your usage

Per project, last 24 h / day / month:

curl "https://api.nodes.koshelek.ru/api/v1/projects/$PROJECT_ID/usage?period=day" \
  -H "Authorization: Bearer $TOKEN"

{
  "project_id": "1ea310a1-...",
  "total_cu": 2,
  "request_count": 2,
  "period": "24h",
  "by_chain": {
    "btc": { "cu": 1, "request_count": 1 },
    "eth": { "cu": 1, "request_count": 1 }
  }
}

period accepts day (default 24 h) and month (last 30 days). The figures come from the billing ledger, which is kept for 400 days. The dashboard's Usage page renders the same data as charts; the tenant-wide money view is on Billing.

Usage API — buckets, quota windows, limits

GET /api/v1/usage is the full picture: every call (served, refused, over a WebSocket stream) sliced the way you need, the current quota windows exactly as the gateway enforces them, and the limits in force.

# this project, last 24 h, by chain and method
curl "https://api.nodes.koshelek.ru/api/v1/usage?project_id=$PROJECT_ID&period=24h&group_by=chain,method" \
  -H "Authorization: Bearer $TOKEN"

# every project of your tenant, per hour over an explicit window, one key only
curl "https://api.nodes.koshelek.ru/api/v1/usage?from=2026-09-01T00:00:00Z&to=2026-09-03T00:00:00Z&group_by=hour&key=$KEY_ID" \
  -H "Authorization: Bearer $TOKEN"

Parameter	Meaning
project_id	one of your projects; omitted = all of them
period	24h (default) · 7d · 30d — rolling; today · month — the quota windows (UTC)
from, to	RFC 3339 window instead of period, up to 92 days (usage events are kept for 90)
group_by	comma list of hour, day, chain, method, key, project, transport, status (≤ 4; hour/day exclusive)
chain, method, key, transport	filters (key = the API key id from GET /projects/{pid}/keys)
limit	rows cap, default 500, max 5000 — totals are never capped

{
  "tenant_id": "…", "project_id": "1ea310a1-…", "projects": 1,
  "from": "2026-09-04T13:30:00Z", "to": "2026-09-05T13:30:00Z", "period": "24h",
  "group_by": ["chain", "method"],
  "totals": { "requests": 8, "billed_requests": 6, "billable_units": 13, "errors": 2, "rejected": 1,
              "cache_hits": 1, "request_bytes": 800, "response_bytes": 2000,
              "ws_connections": 1, "ws_messages": 12, "avg_latency_ms": 11.4 },
  "rows": [
    { "chain": "eth", "method": "eth_call", "requests": 4, "billed_requests": 3, "billable_units": 9,
      "errors": 2, "rejected": 1, "cache_hits": 1, "avg_latency_ms": 17.3, "…": "…" }
  ],
  "truncated": false,
  "history_from": "2026-09-02T11:50:54Z",
  "current_period": {
    "rolling_24h": { "from": "2026-09-04T14:00:00Z", "to": "2026-09-05T14:00:00Z",
                     "billable_units": 157, "requests": 51, "cu_limit": 100000, "cu_remaining": 99843, "cu_percent": 0.157,
                     "over": false, "enforced": true, "enforced_by": "rpc-proxy (per project)" },
    "today":       { "from": "2026-09-05T00:00:00Z", "to": "2026-09-06T00:00:00Z",
                     "billable_units": 150, "requests": 50, "cu_limit": 0, "over": false, "enforced": false, "requests_limit": 100000 },
    "month":       { "from": "2026-09-01T00:00:00Z", "to": "2026-10-01T00:00:00Z",
                     "billable_units": 1149, "requests": 149, "cu_limit": 3000000, "cu_remaining": 2998851, "cu_percent": 0.04,
                     "over": false, "enforced": false }
  },
  "quota_projects": [
    { "project_id": "1ea310a1-…", "cu_per_day": 100000, "cu_per_month": 3000000, "rps_limit": 10, "has_quota_row": true,
      "cu_used_24h": 157, "cu_remaining": 99843, "cu_percent": 0.157, "over": false }
  ],
  "limits": { "tier": "premium", "requests_per_second": 0, "requests_per_minute": 100, "requests_per_hour": 5000,
              "requests_per_day": 100000, "heavy_per_minute": 60, "rps_limit": 10,
              "cu_per_day": 100000, "cu_per_month": 3000000, "projects_with_quota": 1,
              "blocked_methods": ["eth_sendRawTransaction"] },
  "source": { "rows": "usage_events", "current_period": "cu_hourly" }
}

How to read it:

• requests counts calls — HTTP requests (one per JSON-RPC batch item), REST calls, JSON-RPC calls over a WebSocket stream. billed_requests / billable_units are the subset the ledger charged; errors are requests not answered with success (node errors and refusals alike); rejected are the ones the gateway refused or could not serve (quota, scope, revoked key, upstream down).
• A WebSocket stream shows up as ws_connections (streams opened), ws_refused (handshakes refused) and ws_messages (notifications pushed to you); the stream itself is free. With group_by=method its bookkeeping rows appear as WS:connect, WS:message, WS:disconnect. Bytes count every part of a stream once (calls, client frames, notification windows); the WS:disconnect row carries the stream's totals and is not added again.
• current_period.rolling_24h is the quota window the gateway enforces: the CU ceiling is checked per project over a rolling 24 hours at hour granularity (the current hour plus the 23 before it), not over the calendar day. cu_percent ≥ 100 on a project means its new calls get quota_exceeded; quota_projects lists every project in scope with its own ceiling and consumption — the tenant-wide bar is their sum and can look fine while one project is already refused (projects_over counts them and sets over on the sum). A project without a quota row still has a ceiling (the default, has_quota_row: false). On an enforced window cu_limit: 0 means blocked: the gate's arithmetic refuses every call costing CU (over: true, cu_percent: 100); only on the informational windows does cu_limit: 0 mean "no limit configured". over = the next call costing ≥ 1 CU is refused (consumption has reached the ceiling); 0-CU methods always pass.
• today is the UTC calendar day — the window of your plan's requests_per_day (the gateway's request counter, which counts every request, not only billed ones); month is the UTC calendar month against cu_per_month, which is recorded but not enforced. Both are for information (enforced: false).
• limits are the request rate of your plan (per second/minute/hour/day, heavy-method cap), the per-project rps and the CU quotas summed over the projects in scope (defaults included); method allow/block lists only for a single project.
• history_from is the oldest per-request event of the scope: usage events exist since September 2026 and are kept for 90 days — older ones are deleted, so a window reaching further back is not "no traffic". Compute units are also in the billing ledger (kept for 400 days), which GET /projects/{id}/usage and the Billing views read.

Budgeting tips

• eth_getLogs at 75 CU dominates most EVM bills — narrow block ranges and prefer event-indexing services for large scans.
• Static lookups (eth_chainId, net_version, server_info, status) are free (0 CU) — call away.
• Cached short-TTL methods (eth_blockNumber, eth_gasPrice, getblockcount) are cheap and fast; don't build your own cache for them.
• Submits/broadcasts are the priciest common class (20 CU) and are never cached — batch reads, not sends.