Skip to main content

​
CLI First

​
How Credits Work

Every company has a credit balance. Operations deduct credits on use. New accounts start with 20 free credits on a 7-day starter trial.

​
Credit Costs

Each credit is worth $0.05 USD.

​
Fixed-Price Operations

SEO / AEO / queue are additionally metered against your plan quota (a separate per-primitive counter surfaced at GET /v1/users/:id/billing/usage) on top of the credit charge above.

​
Infrastructure (duration-metered)

Anything that runs a server you keep alive is billed by time, not per call — metered by a background scheduler (~every 2 minutes). An idle/stopped resource accrues nothing.
  • The hosted-runtime container is 1 vCPU / 2 GB by default, so a continuously-running hosted agent costs ≈ 1.7 + (2 × 0.18) = 2.06 credits/hour (~0.10/hrat0.10/hr at 0.05/credit).
  • Only claimed containers (your agent profile’s) are billed. The shared warm pool that keeps start-up latency low is platform overhead and is never charged to you.
  • Bring-your-own-runtime (you run the agent in your own harness with agentProfile.tools()) incurs no runtime_usage — you only pay for the API primitives the agent calls.
  • A claimed hosted container bills the same whether busy or idle (the task is up), so tear agent profiles down with revoke() when done — revoke releases the slot immediately.
  • Path A infrastructure is duration-metered, not per-operation. Provisioned managed Postgres, web hosting, and object-storage buckets cost us a recurring vendor fee for as long as they exist, so each is billed by time while ready. The queries, HTTP requests, and object operations against them are free — you pay for the running resource, not per call. naive down tears a resource down and stops its meter.
  • The three Path A rates above are not switched on yet. The meter ships at a rate of 0 for managed Postgres, web hosting and object storage, so a ready resource accrues no database_usage / web_usage / storage_usage today. The rates in brackets are what each is expected to cost when metering begins; we will announce pricing before any of them starts charging. The credit gate on provisioning and the out-of-credit suspension sweep both run regardless.
Path A infrastructure is credit-gated. Provisioning via naive up (managed Postgres, object storage buckets, web hosting) is blocked when your credits are exhausted, and when you run out, running infra is suspended: web deployments are disabled and the hosted runtime is stopped by its meter. Managed Postgres and bucket data persists (a stored resource can’t be “paused”), so it keeps metering until you tear it down — top up to re-enable web and resume; new provisioning unblocks immediately. Self-service compute tasks/services are not auto-stopped on exhaustion; their meter simply keeps debiting the (now-negative-gated) balance until you stop them.

​
LLM Calls

There are two ways LLM usage is billed, both per-token and deducted after the call completes (after the final SSE event for streams):
  • The llm primitive & OpenRouter proxy (POST /v1/llm/chat/completions, naive.llm.chat(), and the /v1/proxy/openrouter/* drop-in). These route through OpenRouter, which returns the exact USD cost of each call. Naive bills that returned usage.cost × markup, converted to credits — so there’s no per-model rate table and pricing always tracks OpenRouter. See the LLM primitive.
  • Orchestration LLM calls (CEO agent / employees). These flow through the Anthropic/OpenAI/Google proxies and are billed per-token using the rates below, with cache read tokens billed at a discount and cache creation at a premium.

​
Audio Calls

The audio primitive bills the same way — exact reported USD cost × markup, converted to credits: Catalog, usage, and route-trace reads are free. Async transcriptions are charged once on the first poll that observes succeeded (keyed on the transcription id — no double-charge). Synthesis charges settle from the usage row after the audio streams. Very short calls can round below credit precision and cost nothing. Every rate below is the provider’s own list price × 1.25, converted at $0.05/credit. Anthropic OpenAI Google Cache reads are billed at the provider’s cache-read rate (a fraction of the input rate) and cache writes at 1.25× the input rate.
Models not in this table cannot be served on the direct proxies. If a model is not listed, Naive first looks up the provider’s real per-token price via OpenRouter’s catalogue and bills that × 1.25. If no published price can be found, the request is rejected with 400 unpriceable_model rather than billed at a guessed rate — a request that cannot be priced is never served. The llm primitive and the OpenRouter drop-in are unaffected: they bill the exact cost OpenRouter reports, whatever the model.
LLM costs are deducted automatically after each API call completes. For streaming responses, usage is extracted from the final SSE event and deducted post-stream. Built-in web search tool use is also billed when used.

​
Dynamic-Price Operations (Image/Video Generation)

Image and video generation costs are model-dependent and calculated dynamically. Use the pricing endpoints to preview costs before submitting:
Response:
unit_price_usd is fal.ai’s live price for that model in its own billing unit (per megapixel for flux/schnell, per image or per second elsewhere); the credit charge is that price × quantity × 2, with a 0.1-credit floor. Prices are read live per request, so a model whose price fal changes is billed at the new price with no release on our side. If fal cannot price a model at all, generation is rejected rather than billed at an assumed rate.

​
Two different “budgets” — don’t confuse them

Naïve has two independent ledgers. Keep them straight: An agent profile’s budget.cap is a combined cost ceiling: it caps the agent profile’s real-world spend (cards/trading) plus the platform credits it burns (LLM, search, compute, hosted runtime — counted at $0.05/credit) against one number. It is still distinct from your company-wide Naïve credit balance (the budget is per agent profile, in USD). A hard cap denies over-budget actions (and auto-stops the agent profile’s hosted runtime); a soft cap routes them to approval. See IaC policy and the Governance Gateway. A card’s spending limit is not spend. Issuing a card is still gated on its limit — a 250cardisrefused,orroutedtoapproval,undera250 card is refused, or routed to approval, under a 50 cap, because the limit is what the card puts at risk — but the limit itself is never written to tenant_spend_events. Only money that actually moves is: top-ups, trading notional, card swipes and metered primitive usage. A 50cardissuedandneverusedthereforeleavestheagentprofile′sspendat50 card issued and never used therefore leaves the agent profile's spend at 0, and cancelling it changes nothing, because nothing was charged.

​
Running out of credits

When a company’s credit balance is exhausted, new API calls return 402 insufficient_credits and hosted-runtime containers are automatically stopped by the meter (a runtime.stopped event with reason: out_of_credits) — so a non-paying account stops incurring cloud cost. Top up or upgrade to resume.

​
Sync vs Async Charging

Synchronous operations (email, search, URL read, quick research):
  • Credits deducted immediately when the operation succeeds
  • If it fails, no credits are charged
Asynchronous operations (images, video, thorough research):
  1. On submission: pre-check that balance ≥ estimated cost (returns 402 if not)
  2. Job runs in background
  3. On success: credits deducted and transaction recorded
  4. On failure: no charge
Concurrent async jobs can temporarily exceed your balance since pre-checks pass independently. The balance may go slightly negative — subsequent submissions will be blocked once balance drops below threshold.

​
Checking Your Balance

Returns your current balance, tier, and resource counts.

​
Usage History

Returns transaction history with action type, amount, and reference IDs. Every charge type appears here keyed by action_type — e.g. llm_call, audio_call, web_search, email_send, job_completion, compute_usage, runtime_usage, subscription_renewal, credit_topup. The dashboard’s GET /v1/dashboard/usage-summary groups the same ledger by action_type so you can see exactly where credits went (including infrastructure time).

​
Credit Responses

Every operation that costs credits includes the charge in its response:
For async jobs, the estimated cost is shown on submission:

​
Credit Enforcement

All billable operations check your credit balance before executing. When your balance drops to zero or below:
  • API primitives (email send, search, URL read) return 402 insufficient_credits
  • CEO runs are blocked with a credit pre-check (5 credits)
  • LLM proxy calls from the container are rejected, stopping agent work
  • The balance stops at zero. A settlement that arrives for more than the wallet holds — a metered charge nobody could pre-check, like an LLM call priced after the tokens are served — empties it to exactly 0.0000 and the remainder is forgiven. You are never billed into debt.
Credits are enforced at every layer — the API, the LLM proxy, and individual primitive endpoints.

​
Running Low on Credits?

When your balance hits zero, operations fail with an insufficient_credits error that includes available credit packs. You can buy more anytime:
Or upgrade your plan for more monthly credits:
See Billing & Credits for full details on plans and pricing.

​
Configuration reference (rates & metering)

The credit value and the duration-meter rates are deployment configuration. On the managed cloud these use the defaults below; self-hosters can override them via environment variables. Both duration meters tick every ~2 minutes, key each charge to a time window (<resource_id>:<windowStart>) so a double-tick can’t double-charge, and cap a single tick’s back-charge at 3 intervals if the scheduler was paused. Compute is gated on NAIVE_COMPUTE_*; hosted-runtime metering is gated on ORCH_CLUSTER (hosted runtime being enabled at all).