Credits & Billing

Inodra uses a credit-based billing system. Every API call, webhook delivery, and stream event consumes credits from your monthly quota.

Credit Costs

Credits meter the work a request does, not the number of HTTP calls you make. A single read costs 1 credit. A request that reads many entities - a batch, a paginated list, a nested GraphQL query - costs credits in proportion to what it reads, because it does the work of that many single reads.

API Calls (gRPC)

Operation	Credits
Single read (GetObject, GetBalance, GetCheckpoint, …)	1
Batch reads (BatchGetObjects, BatchGetTransactions)	1 per key
Paginated lists (ListOwnedObjects, ListBalances, …)	1 per page item *
Transaction execution (ExecuteTransaction)	5
Transaction simulation (SimulateTransaction)	5

* Counted from the requested page size. When you do not set one, the server default (50) applies. Request only the page size you need.

Transaction execution and simulation cost 5 credits due to the higher computational resources required.

API Calls (JSON-RPC)

JSON-RPC currently bills flat per request: 1 credit for any read (single or batch), 5 credits for execute/dry-run/devInspect. Entity-based pricing will extend to JSON-RPC in a future update, announced in advance. New integrations should prefer gRPC or GraphQL - JSON-RPC is deprecated upstream by Mysten.

GraphQL

One GraphQL request is not one read. The server resolves each field and list item you select - one query can perform the work of dozens or hundreds of single reads under the hood. GraphQL is therefore priced by the nodes the server actually resolves, on the same scale as the other protocols:

Cost = base + (resolved nodes / 4), where base is 1 credit for a query and 5 for executeTransaction / simulateTransaction.

Example	Credits
{ chainIdentifier } or any other trivial query	1
Single object, a few fields	1-2
A page of 20 items, lean field selection	~12
A page of 25 versions with contents + nested transactions	~100

The two levers that drive your cost are page size and field selection. Selecting only the fields you need can make the same query 5-10x cheaper. Send the x-sui-rpc-show-usage: true header to see the server's resolved node counts in extensions.usage on your own responses, or use the cost estimator in the dashboard.

Archival reads

gRPC reads served from the archival tier (deep history that no longer lives on live nodes) cost 2x the normal rate. The multiplier applies based on which backend served your request - the response reports it, so the cost is predictable. A read the live node could serve costs the normal rate even if it is old.

Webhooks

Action	Credits
First delivery attempt	2
Each retry attempt (on failure)	1
Manual replay	2

Attempts are charged when the delivery is sent, regardless of the outcome.

Maximum cost per webhook event: 11 credits (2 for initial delivery + 9 retries at 1 credit each).

Warp Streams (WebSocket & SSE)

Action	Credits
Event delivered	2
Connection time	~48/min

Connection time is charged at 4 credits per 5-second interval to account for the persistent connection resources.

gRPC Checkpoint Streaming (SubscribeCheckpoints)

Action	Credits
Opening the stream	5
Per MB of data streamed	20
Minimum per message	1

Checkpoint streaming is billed based on data volume. A typical mainnet checkpoint averages ~950 KB (~19 credits). Using field masks to request only the fields you need significantly reduces costs.

Example costs for different field masks:

Field mask	Avg message size	Credits/message
Full checkpoint (no mask)	~950 KB	~19
Cursor only	~0.1 KB	1 (minimum)

Tip: If you only need specific events, use Warp streams or Webhooks instead of the checkpoint firehose. They cost only 2 credits per event and include field-level filtering.

Other gRPC Streams

Streaming methods other than SubscribeCheckpoints are billed per message, not by data volume:

Action	Credits
Opening the stream	1
Per message	2

gRPC Server Reflection

Server reflection costs a flat 1 credit per session, no matter how many descriptors the session requests. A grpcurl invocation that lists or describes services counts as one session.

Monthly Quotas

Plan	Credits/month	Rate limit (req/s)	Webhooks	Warp Streams
Free	1,000,000	10	1	1
Team ($49)	10,000,000	50	5	5
Growth ($199)	45,000,000	100	20	20
Professional ($499)	120,000,000	200	50	50
Business ($999)	250,000,000	500	100	100
Enterprise	Custom	Custom	Custom	Custom

Rate limits are the maximum request rate your plan allows on the shared gateways - they are not a reserved-throughput guarantee. Workloads that need guaranteed throughput or a latency SLA run on Enterprise dedicated capacity.

Overage

Paid plans (Team and above) can purchase additional credit packs, priced by your plan tier:

• Team: $10 per 1,000,000 credits
• Growth: $8 per 1,000,000 credits
• Professional: $7 per 1,000,000 credits
• Business: $5 per 1,000,000 credits
• Available as one-time purchases from the billing dashboard
• Added to your current billing period quota
• Resets on billing period rollover

What Counts as a Credit

• 1 entity read = 1 credit on gRPC - a batch of 200 keys costs 200, a single read costs 1
• GraphQL = base + resolved nodes / 4 - priced by the reads it performs under the hood
• JSON-RPC = flat 1 credit per request for now (entity pricing comes later)
• Archival-served gRPC reads = 2x
• 1 transaction execution/simulation = 5 credits
• 1 webhook/stream event = 2 credits
• 1 MB of checkpoint stream data = 20 credits
• Every request costs at least 1 credit and at most 25,000 - a pathological request bills at the cap instead of being rejected

Your responses always show the charge: HTTP responses carry X-Inodra-Credits-Charged and X-Inodra-Credit-Remaining headers; gRPC responses carry x-inodra-credits-charged in the trailing metadata, plus x-inodra-backend when a read was served from the archival tier.

Credits are not charged for:

• Failed requests that return server errors (5xx)
• Authentication failures
• Rate-limited requests (429)

Monitoring Usage

Track your credit consumption in real-time:

• Dashboard: The billing page shows current usage, remaining credits, and usage percentage
• API headers: Every response includes X-Inodra-Credit-Remaining, X-Inodra-Credit-Limit, and X-Inodra-Credit-Replenish-Date (when your quota resets, ISO 8601)
• Alerts: Dashboard warns when usage exceeds 70% and 90% of your quota

Quota Exceeded

When your monthly credit quota is exhausted:

1. API responses return 429 with "Credit quota exceeded". The response body and headers include your limit, the remaining balance, and the replenish date.
2. Active streams (Warp SSE/WebSocket and gRPC subscriptions) close at the next billing check. Warp connections send a quota_exceeded event before closing. New stream connections are rejected.
3. Webhooks continue to deliver. Their credits are recorded against the current period as overage, so your usage figure can exceed your quota.
4. Purchase a credit pack or wait for the next billing period. The next period always starts from zero.