Plans and credits

Plans

History is the same on every plan: all of it, since genesis. Plans differ in volume, speed and streaming.

With no key you are on the keyless tier: 2 requests a second and 1,000 credits a day per IP. Agents get a Free key by signature, see Keys for agents.

How credits work

• Each method has a price in credits, listed below. Some methods add credits per item, for example one credit per transaction parsed.
• A successful call is charged. A call that returns an error is free. The charge is in the x-credits-cost header.
• On the Free plan the API stops when the month's credits run out and returns out_of_credits. Prepaid USDC credits keep it going, see Pay with USDC. Paid plans keep going and bill extra credits at the rate above, from prepaid credits first.
• The Free plan is for one person. One IP can make at most 3 new free accounts a day, and one network (IPv4 /24 or IPv6 /64) at most 10. All Free accounts used from one network share 7,500,000 credits a month and 1.5 times one key's requests a second. An address with no on-chain history gets 1,000 credits a day until it makes a transaction or tops up. Prepaid USDC credits are never pooled or capped by these rules.
• Requests a second are counted in two classes. Light calls cost 1 or 2 credits. Heavy calls cost 5 or more. A call over the rate gets a 429 with retry-after.
• MCP tool calls cost the credits of the method they run.
• A SQL run costs 20 credits plus 1 per 50 MB it reads, charged when it finishes. Reusing a recent identical result (max_age) costs 2. A run that hits its time, memory or read limit costs 10 plus 10 a second; a query rejected before it runs is free. Without a key, SQL runs one at a time with 15 s, 20 GB and 10,000 rows per run, from the keyless daily credits.
• Status, the registry, OpenAPI, llms.txt and account calls are free.

Pay with USDC

You can buy credits with native USDC on Sui mainnet, with no card and no plan. The rate is $3 per million credits, the same as the overage price on Developer and Business. 1 USDC buys 333,333 credits. The coin type is 0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC.

Prepaid credits never expire. They are spent only after the plan's monthly credits run out, so a Free account keeps working past 5M, and a paid plan's overage is paid from prepaid credits first.

Top up

Sign in, open Billing in your API account, pick an amount and sign one USDC transfer with your wallet. Credits land when the transaction is final, about a second. It is gasless where the network allows, so you need no SUI.

Any USDC transfer from your account's Sui address to the treasury is credited to that account automatically. It is matched by sender and counted once per transaction digest. Plain transfers of at least $0.01 count. The minimum top-up through the API is $1.

0x3d651ddf154835f6cd20e107a9a957b05cc701b9a492a7f680a0a4c3b5d8b0f1

These calls are free (0 credits). Auth is an API key or a dashboard session.

curl -X POST "https://api.tide.ad/v1/billing/topup" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{ "usd": 10 }'

# sign txBytes with your Sui key, then:

curl -X POST "https://api.tide.ad/v1/billing/topup/submit" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "content-type: application/json" \
  -d '{ "txBytes": "TX_BYTES", "signature": "SIGNATURE" }'

Auto top-up

Auto top-up uses sui::allowance. You grant tide's spender a limited allowance on chain. When your credits left (plan this month plus prepaid) fall under a threshold, tide draws USDC into the treasury, pays the gas itself, and credits your account. The spender may draw at most perDrawUsd per window and maxTotalUsd in all until the allowance expires. Sui enforces this, not tide.

1. POST /v1/billing/allowance with { maxTotalUsd, perDrawUsd, windowHours, expiresDays, thresholdCredits }. windowHours defaults to 1 and expiresDays to 90. It returns an unsigned grant transaction.
2. Sign and send it. This costs a little SUI gas. Allowances spend from the address balance, so the grant transaction can first move USDC coins into it (depositUsd).
3. POST /v1/billing/allowance/confirm with { digest }.

Change or pause it with PUT /v1/billing/autotopup and { enabled, thresholdCredits, drawUsd }. POST /v1/billing/allowance/revoke returns an unsigned revoke. Revoking on chain from any wallet stops tide for good. After 3 failed draws auto top-up turns itself off.

Pay per call

Agents can pay with no account. A request with no key that is over the keyless daily limit, or with a key that is out of credits, gets 402 Payment Required. The body lists every offer in accepts (x402 version 2) and every MPP challenge in mpp. The headers stay small: PAYMENT-REQUIRED (base64 JSON) carries the cheapest offer and WWW-Authenticate: Payment (MPP, method sui, intent charge) one challenge.

accepts lists the offers. Each has scheme exact, network sui:mainnet, amount (raw USDC, 6 decimals), asset, payTo (the treasury), maxTimeoutSeconds 600, and extra with nonce, expiresAt, credits, gasless and validDuring (chain, minEpoch, maxEpoch, nonce).

Pay with x402

1. Build a gasless transaction that sends exactly amount of the asset to payTo with balance::send_funds. Use gas price 0, budget 0, no gas coins, and a ValidDuring expiration from extra.validDuring (chain, epochs and the u32 nonce).
2. Sign it.
3. Retry the same request with the header PAYMENT-SIGNATURE (or X-PAYMENT) set to base64 JSON { x402Version: 2, accepted: <the offer>, payload: { signature, transaction } }.

tide checks the exact amount, the recipient, the single-use nonce and the expiry, submits the transaction, waits for finality, and answers the call. The response carries PAYMENT-RESPONSE (base64 { success, transaction, network, payer }) and X-Tide-Api-Key.

Pay with MPP

Pay the challenge, then retry with Authorization: Payment <credential> carrying the digest and a signed proof. tide returns Payment-Receipt.

curl -i "https://api.tide.ad/v1/coins/0x2::sui::SUI"
# HTTP/2 402
# payment-required: eyJ4NDAyVmVyc2lvbiI6Mi...   (base64 JSON, same object as the body)

# build and sign the payment for one offer in accepts, then:

curl -i "https://api.tide.ad/v1/coins/0x2::sui::SUI" \
  -H "PAYMENT-SIGNATURE: BASE64_PAYMENT"
# HTTP/2 200
# payment-response: eyJzdWNjZXNzIjp0cnVlLi4u
# x-tide-api-key: tide_...

Session key

Every payment's credits go to an account owned by the payer address. X-Tide-Api-Key is a key derived from that address, the same key every time, so one $1 or $10 payment buys a session of calls. Use it as Authorization: Bearer.

GET /v1/billing/offers (no key) returns the offers up front. POST /v1/billing/pay settles a payment without calling anything else and returns { digest, payer, credits, apiKey }.

Credits per method