The problem we kept running into

A product that generates images for its customers rarely uses only one model. It needs an image model, a text model for captions, perhaps a voice and a short video. Each model usually means another account, another key, another billing page, another error format and another invoice at the end of the month.

The costs are just as scattered. Finance gets five invoices in three formats. Engineering sees requests per provider, not spend per end customer. Nobody can answer a simple question quickly: what did customer 0482 cost us last month?

What Tovano does

What a call looks like

curl https://api.tovano.ai/v1/tasks \
  -H "Authorization: Bearer $TOVANO_API_KEY" \
  -H "Content-Type: application/json" \
  -H "X-Tovano-Customer: client-0482" \
  -d '{ "model": "image/demo-1", "input": { "prompt": "Product photo of a blue ceramic mug", "n": 2 } }'

When the task completes, it carries its own charge: "units": 2, "charged_micro": 40000, which is $0.040. The X-Tovano-Customer header tags the call with your own customer ID, so you can later ask the API for spend per customer.

Three promises

A failed task is never charged. When a task starts we reserve its estimated cost. When it completes we charge the real amount. When it fails we release everything. There is no partial charge for an error on our side or the provider's.

Prices are public and per unit. The price you see on the models page is the price you pay. There are no seat fees and no platform fees. Larger top-ups add bonus credits: 2% from $1,000, 5% from $2,500 and 8% from $10,000.

You stay in control of spend. Set a monthly spend limit for the organisation, get an email when the balance runs low, and turn on auto top-up if you never want a call to stop. When a limit is reached, the API answers with a clear 402 error instead of surprising you on the invoice.

What is available today

The catalogue at launch covers image, video, speech and text models, plus one agent job, agent/ad-kit-1, which writes ad copy with a text model and then makes a matching image, with each step charged on its own. The current list, with prices and input fields, is always on the models page and at GET /v1/models.

We are adding models every week. A new model appears in the same API with its own unit and price; your code does not change.

Getting started

1. Create an account and add credits under Billing.
2. Create an API key under API keys.
3. Follow the quickstart, or install the SDK with npm install tovano.

For a rollout at volume, write to sales@tovano.ai. We set up rate limits sized to your traffic, invoicing that fits your accounts team and a named contact for your engineers.

Three steps behind every charge

Every task moves through the ledger in three steps.

1. Reserve. When a task is accepted, we work out the most it can cost and hold that amount on your balance. For four images at $0.020 that is $0.080. For a chat request it is the input tokens plus the max_tokens you asked for.
2. Settle. When the task completes, we charge the real amount from the provider's result and release whatever was left of the reservation.
3. Release. When the task fails, the whole reservation is released. The task shows "status": "failed" and "charged_micro": 0.

The reservation is what makes the other guarantees possible. It means a request can only start if your balance covers it, and two tasks running at the same time can never spend the same dollar twice.

What you see in the API

Your balance has three parts:

{
  "object": "balance",
  "balance_micro": 84120000,
  "reserved_micro": 80000,
  "available_micro": 84040000,
  "currency": "usd"
}

available_micro is what new tasks can use. reserved_micro is held by tasks that are still running. When they finish, the reservation turns into a charge or goes back to your balance.

Why an estimate and not a guess

For most models the estimate is exact. An image model charges per image, and the number of images is in the request. A video model charges per second, and the duration is in the request. Speech is charged per 1,000 characters of the text you send.

Text is the one case where the final number is lower than the estimate. We cannot know how long the reply will be, so we reserve for the full max_tokens and settle on what the model actually wrote. Setting a sensible max_tokens keeps more of your balance available while many chat calls run at once.

Agent jobs

An agent job runs several models in a row, and each step is charged on its own as it completes. If a later step fails, the job fails as a whole and the steps that already ran are refunded. The ledger shows the charge and the matching refund, so the history stays complete and the net cost is zero.

The ledger is append-only

Every change to your balance is one row in the ledger: topup, charge, refund, grant or adjustment. Rows are never edited or deleted. Your balance is the sum of the rows. If you ever doubt a number, you can trace it back, one row at a time, under Billing in the dashboard.

Rounding

All amounts are integers in micro-dollars, a millionth of a dollar. When a charge works out to a fraction of a micro-dollar, for example a few tokens of text, it is rounded up to the next whole micro-dollar. That is the only rounding we do, and it is at most $0.000001 per task.

In short

• You can see the most a task will cost before it runs.
• You pay for what the model delivered, not for what it might have delivered.
• If it fails, you pay nothing, and the task says so.

Small prices, large volumes

A text model may cost $1.00 per million input tokens. A short prompt of 42 tokens therefore costs $0.000042. A busy product sends millions of such requests a day.

Floating-point numbers cannot represent most decimal fractions exactly. 0.1 + 0.2 is 0.30000000000000004 in almost every programming language. One such error is invisible. A billion of them, added up over a month, become a visible difference between your own records and ours. In billing, a difference you cannot explain is a support ticket, and often a lost customer.

Integers do not drift

With micro-dollars, the 42-token request costs 42. Four images at $0.020 cost 80000. Adding integers is exact, so the sum of a month of charges is exactly the number on the invoice. Our ledger stores every row as an integer and the balance is the integer sum of the rows.

Micro-dollars are fine-grained enough for every unit we sell. The smallest real charge is a handful of tokens, which still comes to at least one whole micro-dollar after rounding up.

The fields

Handling micro-dollars in your code

Keep the integer for as long as you can, and turn it into text only for display.

// Sum charges as integers.
const total = tasks.reduce((sum, t) => sum + t.charged_micro, 0);

// Format only at the edge.
const usd = (micro: number) =>
  new Intl.NumberFormat("en-US", { style: "currency", currency: "USD", maximumFractionDigits: 6 }).format(
    micro / 1_000_000,
  );

usd(total); // "$0.08"

The SDK ships the same helper as formatUsd. In languages with arbitrary-precision integers, such as Python, nothing special is needed. In JavaScript, a regular number holds integers exactly up to about nine quadrillion micro-dollars, which is nine billion dollars, so plain numbers are safe for any single balance or invoice.

If you store our numbers in a database, use an integer column (BIGINT in most databases). Do not convert to a decimal dollar amount on the way in.

Re-billing your own customers

Many of our customers resell AI features and add their own margin. Do that in integers too: multiply, then divide once, and round in one place.

// 30% margin, rounded up to the next micro-dollar.
const resale = (micro: number) => Math.ceil((micro * 130) / 100);

When you convert to cents for your own invoice, round once at the end of the period, not per request. Rounding a million requests to the cent one by one creates exactly the drift that integers were supposed to prevent.

Without help, finding that number means logging every request, matching it with a provider invoice and adding it up per customer in a spreadsheet. With Tovano it is one extra header.

Tag every call

Send your own ID for the end customer with each request, either in the customer field of a task or in the X-Tovano-Customer header. It can be any text up to 128 characters: an account ID, a workspace slug, an order number.

curl https://api.tovano.ai/v1/tasks \
  -H "Authorization: Bearer $TOVANO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "image/demo-1",
    "input": { "prompt": "Studio shot of a leather wallet", "n": 4 },
    "customer": "client-0482"
  }'

The tag is stored on the task and on its charge. It is never shown to anyone else, and you can use a pseudonymous ID if you prefer not to send real account names.

Ask for spend per customer

curl "https://api.tovano.ai/v1/usage?group_by=customer&from=2026-11-01&to=2026-11-30" \
  -H "Authorization: Bearer $TOVANO_API_KEY"

{
  "object": "usage",
  "group_by": "customer",
  "total_micro": 51384210000,
  "data": [
    { "key": "client-0482", "tasks": 1820441, "failed": 312, "charged_micro": 9120400000 },
    { "key": "client-0517", "tasks": 940112, "failed": 87, "charged_micro": 5288030000 },
    { "key": "", "tasks": 20514, "failed": 9, "charged_micro": 102600000 }
  ]
}

The row with an empty key collects calls sent without a tag. Failed tasks are counted so you can spot a customer whose requests keep failing, but they add nothing to charged_micro.

The same view in the dashboard

The Usage page groups spend by model, by day, by project, by API key or by customer, and exports any view as CSV. The usage tables on monthly invoices stay per model, as your accounts team expects.

What teams do with it

• Usage-based pricing for their own plans. The monthly numbers per customer feed straight into their own billing system.
• Margin checks. Comparing what a customer pays with what they cost shows which plans need a new price.
• Fair-use limits. A nightly job reads the usage per customer and warns accounts that are far above their plan.

There is a step-by-step version of this in the guide Track spend per end customer.

An agent job does the chaining on our side. You send one request and get one task back. Inside it, each step is a task of its own, with its own model, units and charge.

The first agent job: Ad Kit

agent/ad-kit-1 takes a short brief and returns a headline, body copy and a matching image.

curl https://api.tovano.ai/v1/tasks \
  -H "Authorization: Bearer $TOVANO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "agent/ad-kit-1",
    "input": {
      "product": "Insulated steel water bottle, 750 ml",
      "audience": "commuters",
      "tone": "plain"
    }
  }'

It runs two steps:

A typical run costs about $0.022: a fraction of a cent for the copy and $0.020 for the image. You can choose other models for each step with text_model and image_model; the job then charges their prices.

One task, every charge visible

The finished task lists its steps:

{
  "id": "tsk_51ad0c7e93b2",
  "model": "agent/ad-kit-1",
  "status": "completed",
  "output": {
    "headline": "Cold at nine, still cold at five",
    "body": "...",
    "image": { "url": "https://files.tovano.ai/..." }
  },
  "charged_micro": 21588,
  "steps": [
    { "name": "copy", "model": "text/demo-chat-1", "status": "completed", "charged_micro": 1588 },
    { "name": "image", "model": "image/demo-1", "status": "completed", "units": 1, "charged_micro": 20000 }
  ]
}

The job's charged_micro is the sum of its steps. In your usage reports, the steps count under their own models, so the per-model numbers on your invoice stay correct.

When a step fails

If any step fails, the job fails as a whole. Steps that already completed are refunded in full, and the ledger shows each charge with its matching refund. As with every task on Tovano, a failed job costs nothing.

What comes next

We will add more agent jobs where chaining models is the common case, starting with product listings and short video ads. Each will publish its steps and a typical cost on the models page before you run it. If you have a chain you run often, tell us at hello@tovano.ai.

The guide Run an agent job walks through the request, the steps and the result in more detail.