> ## Documentation Index
> Fetch the complete documentation index at: https://abstract-pbc.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Usage and billing units

> What a robot chunk is billed from: prompt tokens, cached tokens, and actions.

Every action chunk carries a `usage` object.
The chunk is billed from that object, at the rates on Platform's [Models](https://platform.abstract.inc/) page.

```json theme={"theme":"css-variables"}
{
	"prompt_tokens": 699,
	"prompt_tokens_details": { "cached_tokens": 0 },
	"completion_tokens": 30,
	"total_tokens": 729
}
```

## Units

| Unit on Models | Field | Meaning |
| - | - | - |
| Input, per 1M tokens | `prompt_tokens` minus `cached_tokens` | Model tokens the chunk encoded afresh, from its frames and its instruction. |
| Cached input, per 1M tokens | `prompt_tokens_details.cached_tokens` | Model tokens the chunk reused from earlier chunks of the same episode. |
| Output, per 1M actions | `completion_tokens` | Action rows the model computed. |

`completion_tokens` counts the whole chunk the model computed.
A smaller `action_horizon` returns fewer rows but does not lower `completion_tokens`.

| Model | `completion_tokens` per chunk | `cached_tokens` |
| - | - | - |
| `allenai/molmoact2` | 30 | 0 |
| `microsoft/rho` | 25 | 0 |
| `perceptron/isaac-0.5` | 30 | 0 |
| `xiaomi/xiaomi-robotics-1` | 30 | 0 |
| `verne/v0.5` | 18 | Memory and text reused from earlier chunks: 296 after the first chunk |
| `runway/praxis-1` | 21 | The instruction's text tokens, after the first chunk |
| `black-forest-labs/flux-3-action` | 32 | 0 |
| `physical-intelligence/pi0.5` | 30 | 0 |

Read `usage` from each answer. Do not compute it yourself.
A JPEG count is not a token count.

## Verne estimate

Verne V0.5 costs $0.80 per million fresh input tokens, $0.08 per million cached input tokens and
$28.00 per million action rows. A chunk reads 488 input tokens: 192 for the present frame, 168 for
its packed memory and 128 for the padded instruction. After the first chunk, the memory and
instruction count as cached, so a call costs about $0.00068.

The listed **\$4.09/hour estimate** is 6,000 calls of 18 rows at 30 Hz. It counts billed action
rows, not GPU time or robot uptime.

## Praxis-1 estimate

Praxis-1 costs $0.80 per million fresh input tokens, $0.08 per million cached input tokens and
$28.00 per million action rows. The first chunk of an episode reads 312 input tokens for its
frame, plus the instruction and one for the pose. Every later chunk reads 2,184 for the frames
of the chunk just run, plus the instruction, which then counts as cached, and two for the poses:
2,201 for a 15-token instruction, about $0.0023 a call.

The listed \*\*$12.02/hour estimate is normalized to 30 Hz**, like the other rate cards: 5,143
calls of 21 rows. The checkpoint runs at 15 Hz, so an hour of its motion is half that many calls,
about $6.01. Neither counts GPU time, robot uptime or the pauses between chunks.

## Xiaomi estimate

Xiaomi costs $0.70 per million input tokens, $0.07 per million cached input tokens and \$3.00
per million action rows. Its current adapter reports no cached tokens. Image size and instruction change the
input count, so read it from each answer.

The listed \*\*$1.584/hour estimate is normalized to 30 Hz**, like the other rate cards.
Its input is three 640×360 JPEGs and the instruction “Inspect the object on the table.”
The model resizes each view to 512×288: 432 image tokens plus 68 text and template tokens,
500 input tokens in all, no cache, and 30 action rows per call. At those rates, a call costs
$0.00044 and 3,600 calls cost \$1.584.

The checkpoint's native cadence is **25 Hz**. At the same inputs, 3,000 full chunks contain
one hour of action rows and cost \$1.32. Both estimates count billed action rows, not GPU time
or robot uptime.

## FLUX estimate

FLUX costs $2.00 per million fresh input tokens, $0.20 per million cached input tokens and
\$90.00 per million computed action rows. It resets its state on every request, so it
reports **zero cached tokens**.

Input tokens are 340 for the combined camera frame, 1 for the state, the padded positive text
context, and 80 for the padded empty negative text context. They are not a JPEG count or the
unpadded instruction length. The positive text context is capped at 8,192 tokens, so a call has
at most **8,613 input tokens**. Separately, the API limits instructions to 512 characters.
The model's 2,720 predicted video tokens are not billed as action rows.

With three 640×360 views and “put the cube in the bowl”, a synthetic test call
reports **501 input tokens, no cache and 32 action rows**, costing $0.003882 per call.
The **$13.10175/hour estimate is normalized to 30 Hz\*\*: 3,375 full chunks at that input mix.
At the checkpoint's native **15 Hz**, 1,687.5 full chunks contain an hour of action rows and
cost approximately **\$6.55**. These estimates count billed action rows, not GPU time or
robot uptime. A different instruction changes the input count.

An instruction refused by FLUX's prompt filter returns HTTP 403 `flux_content_blocked`
before billing or inference. An answer refused by the output filter returns HTTP 502
`flux_output_blocked` with no action rows and is not billed.

## How a chunk is metered

1. Before the model runs, the API reserves the chunk's maximum cost against your available API credit and monthly spend limit.
2. If that reservation would cross the spend limit, the API returns HTTP 429 `spend_limit_exceeded`. If available credit cannot cover it, the API returns HTTP 402 `insufficient_credit`. The model does not run.
3. When the answer arrives, the API settles the chunk from its `usage`, at the rates fixed when the request was submitted.
4. A chunk the model never delivers, because of an error, a mid-stream failure or a closed connection, costs nothing.

A request missing required camera frames is refused before inference and is not billed.
`POST /v1/end_session` is also unmetered.

Accounts granted a credit exemption do not hold credit, but still have a hard monthly spend limit.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.