Open app

Billing.

How plans, credits, and limits behave. Current prices live on the pricing page; this page explains what happens to your money and when.

Billing method
You pay when a memory is saved, never when it is used.

Every saved memory is the billable unit. A turn sent to /turns or /turns/batch is one memory, and turns sent with context_only=true are billed the same way. A document sent to /documents is cut into pieces of up to 2,048 characters, and each piece is billed as one memory, including with extract=false. Recall is free, always, for everyone, on every plan: ask a thousand questions a day and the bill does not move. All payments are processed by Paddle, our Merchant of Record, and the exact terms are in the Terms of Service and Refund Policy.


Personal plans
A monthly memory allowance, and a choice about what happens past it.

Personal accounts subscribe to a plan with a monthly allowance of saved memories. The Free plan's allowance is a hard cap: when you reach it, saving pauses until the next monthly cycle. Nothing is lost when that happens; everything already saved stays permanent and recall keeps working without limits.

Paid plans include a larger allowance and can go past it with usage-based overage, billed per additional memory at the rate on the pricing page. Overage is on by default when you subscribe. You can turn it off at checkout, or later with the Allow overage switch in Billing. With overage off, your plan stops saving at its allowance, the same way Free does. With overage on, saving never pauses and each memory past the allowance is billed at the overage rate.


Developer credits
Prepaid balance, drawn down per saved memory. No monthly fee, no seats.

Developer accounts top up a credit balance with any amount from $5 to $10,000 per top-up. Each saved memory deducts the per-memory rate from the balance; a batch of 50 turns deducts 50 memories' worth. Every charge and top-up appears in your ledger on the Credits screen, and credits stay available as long as your account is active.

Creating tenants, listing them, and recalling memories never consume credits. Only saving does.


When the balance runs out
Saving pauses. Nothing else changes.

If a save arrives and your credit balance cannot cover it, the API answers with 402 payment_required:

Response · 402
{
  "success": false,
  "http_status": 402,
  "code": "payment_required",
  "message": "Insufficient credits. Add credits to continue ingesting."
}

A key that reaches its own spending limit gets the same code, payment_required, with the message "This API key has reached its credit limit ($N).", where $N is that key's limit. The message is the only way to tell the two cases apart.

Handle it like any other stable error code: pause your ingest path, alert whoever tops up the account, and retry after adding credits. Everything already stored is untouched, and recall keeps answering throughout.

Charges stay honest. A memory is charged when it is accepted. If the save itself fails on our side, the charge is refunded to your balance automatically; in a batch, only the failed share is refunded, and the turns that succeeded stay saved and charged.

Per-key spending limits
One runaway agent cannot drain the whole balance.

Every API key can carry its own spending limit, set or cleared in the dashboard on the key's detail view. A key that reaches its limit starts receiving 402 on saves, while every other key, and the rest of your application, keeps running against the shared balance. A key's limit counts everything it has ever spent, net of refunds, so it does not reset each month.

A practical setup: give each service or agent its own ingest key with a limit sized to its expected usage, and keep admin keys, and any key without a limit, off production paths entirely.


payment_required vs cap_reached
Two codes, one promise: stored memories and recall are never touched.
CodeWho sees itWhyIt ends when
402 cap_reachedPersonal accountsThis save would go past the plan's monthly allowance and overage is off. A batch or document that would cross it is rejected whole.The next monthly cycle starts (the 1st of the month, UTC), or you upgrade. On a paid plan, turning overage on also ends it.
402 payment_requiredDeveloper accountsThe credit balance, or the key's own limit, cannot cover the save.Credits are added, or the key's limit is raised or cleared.

Both codes answer with HTTP 402, so branch on the code field, not the HTTP status.

In both cases the failure is on the save only. Nothing is deleted, nothing expires, and recall answers normally the entire time.