> For the complete documentation index, see [llms.txt](https://docs.apismart.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.apismart.ai/models-and-pricing/model-pricing-and-billing.md).

# Model Pricing and Billing

Understand how ApiSmart bills text, image, and video models, including token-based pricing, per-image charges, video resolution and duration, and how to review your actual API costs.

ApiSmart uses a **pay-as-you-go** billing model. Charges are deducted from your available wallet balance based on the model and workload used for each API request.

Different model types use different billing methods:

| Workload         | Typical Billing Basis                        |
| ---------------- | -------------------------------------------- |
| Text generation  | Input and output tokens                      |
| Image generation | Successfully delivered images                |
| HappyHorse video | Video duration and resolution                |
| Seedance video   | Generated tokens, resolution, and input type |

Model availability and pricing may change over time. For production cost estimates, always verify the latest pricing shown in the ApiSmart Console or current model pricing interface.

### 💬 Text Model Billing

Text models are generally billed according to token usage.

A request may include:

* **Input tokens** — Tokens sent to the model
* **Output tokens** — Tokens generated by the model
* **Cached input** — Where supported, cached tokens may use a different price
* Other model-specific billing categories where applicable

A simplified calculation is:

```
Input cost
+
Output cost
=
Request cost
```

For example, if a model has separate input and output prices:

```
Input cost =
input_tokens ÷ 1,000,000 × input price

Output cost =
output_tokens ÷ 1,000,000 × output price
```

The exact pricing varies by model.

Because text model prices and available models can change, this documentation does not maintain a second static price table here. Check the current model pricing shown by ApiSmart before estimating production costs.

The public [ApiSmart pricing page](https://www.apismart.ai/pricing) also describes text API billing as pay-as-you-go based on actual input and output token consumption.&#x20;

### 🖼️ Image Generation Pricing

The current Seedream image model is:

```
doubao-seedream-5-0
```

Current documented pricing:

| Model                 |             Price |
| --------------------- | ----------------: |
| `doubao-seedream-5-0` | **$0.04 / image** |

#### How Image Billing Works

Image generation is billed according to the number of images actually delivered.

For example:

```
1 delivered image × $0.04 = $0.04
```

If a sequential generation request successfully delivers four images:

```
4 × $0.04 = $0.16
```

The response may include:

```json
{
  "usage": {
    "generated_images": 1,
    "output_tokens": 16384,
    "total_tokens": 16384
  }
}
```

For image billing, the final charge is based on the **actual delivered and deduplicated image results**, rather than blindly using the reported token count or an expected number of outputs.

This is particularly important when using sequential image generation, where one request can return multiple images.

### 🎬 Video Generation Pricing

Video pricing depends on the selected model family.

ApiSmart currently documents two different video billing models:

**HappyHorse** — billed by video duration and resolution\
**Seedance** — billed by generated tokens, with pricing affected by resolution and whether the request contains video input

***

### HappyHorse Pricing

Supported models:

```
happyhorse-1.0
happyhorse-1.1
```

Current documented pricing:

| Model            |            720p |          1080p |
| ---------------- | --------------: | -------------: |
| `happyhorse-1.0` | $0.145 / second | $0.27 / second |
| `happyhorse-1.1` | $0.145 / second | $0.24 / second |

The basic calculation is:

```
Video cost =
duration in seconds × price per second
```

For example, a 5-second `happyhorse-1.0` video at 720p costs:

```
5 × $0.145 = $0.725
```

#### Specify Resolution and Duration Explicitly

HappyHorse has important default billing behavior.

If no resolution setting is supplied, billing defaults to **1080p**.

If no `duration` is supplied, billing defaults to **5 seconds**.

For example, with `happyhorse-1.0`:

```
1080p × 5 seconds
=
$0.27 × 5
=
$1.35
```

For comparison, explicitly requesting 720p and 5 seconds costs:

```
$0.145 × 5
=
$0.725
```

For consistency across the ApiSmart documentation, HappyHorse request examples use:

```json
{
  "model": "happyhorse-1.0",
  "prompt": "A cinematic city at night",
  "duration": 5,
  "size": "720P"
}
```

The latest API specification also uses `size: "720P"` in its primary HappyHorse request examples.

> **Always specify the HappyHorse output size and duration explicitly.**\
> Relying on defaults can result in a higher charge than expected.

### Seedance Pricing

Supported models include:

```
doubao-seedance-2.0
doubao-seedance-2-0-fast
doubao-seedance-2-0-mini
doubao-seedance-2-5
```

Seedance is billed by the number of **generated tokens**.

Pricing also depends on:

* Model
* Resolution tier
* Whether the request includes video input

Current documented prices are shown below.

#### Without Video Input / With Video Input

Each table cell shows:

```
No video input / With video input
```

Prices are in **USD per 1 million generated tokens**.

| Model                      |           480p |           720p |          1080p |
| -------------------------- | -------------: | -------------: | -------------: |
| `doubao-seedance-2-5`      | $13.99 / $8.49 | $13.99 / $8.49 |  Not supported |
| `doubao-seedance-2.0`      | $10.40 / $6.30 | $10.40 / $6.30 | $11.50 / $6.90 |
| `doubao-seedance-2-0-fast` |  $7.49 / $4.49 |  $7.99 / $4.99 | $10.99 / $6.99 |
| `doubao-seedance-2-0-mini` |  $2.49 / $1.49 |  $2.79 / $1.69 |  $3.79 / $2.29 |

For example, the two values:

```
$10.40 / $6.30
```

mean:

```
$10.40 / 1M generated tokens
without video input

$6.30 / 1M generated tokens
with video input
```

#### Seedance Cost Formula

The calculation is:

```
Cost =
generated tokens ÷ 1,000,000 × applicable price
```

Generated token usage can be obtained from the completed video task response, including:

```
usage.completion_tokens
```

#### Resolution Defaults

If `resolution` is omitted from a Seedance request, billing defaults to the **720p tier**.

For example:

```json
{
  "model": "doubao-seedance-2.0",
  "content": [
    {
      "type": "text",
      "text": "A cat running along the beach at sunset"
    }
  ],
  "duration": 4,
  "resolution": "720p"
}
```

Seedance currently does not support `4k`.

Additionally:

```
doubao-seedance-2-5
```

supports only:

```
480p
720p
```

Requests using an unsupported resolution can return:

```
400 unsupported_resolution
```

### 📊 Billing Differences at a Glance

| Model Type | What Mainly Determines Cost?                       |
| ---------- | -------------------------------------------------- |
| Text       | Input/output tokens and model pricing              |
| Seedream   | Number of delivered images                         |
| HappyHorse | Resolution × duration                              |
| Seedance   | Generated tokens × resolution/input-specific price |

This distinction is important when reading **Usage Logs**.

A field such as `Consumption` should not always be interpreted as text tokens because different workloads use different billing units.

### 💳 Wallet and Balance

ApiSmart uses a prepaid wallet system.

After funds or wallet credits become available, API usage is deducted from the account balance according to the applicable model pricing.

The public pricing page currently distinguishes between the amount paid and the amount credited to the wallet, including promotional credits where applicable.&#x20;

If your available balance is insufficient, an API request may return:

```
402 insufficient_quota
```

Add funds before retrying the request.

For wallet details, see **Add Funds and Understand Wallet Credits**.

### 🔎 Review Actual Request Costs

To understand how much a specific request cost, open:

**Console → Usage Logs**

<figure><img src="https://3886476465-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F9rNjqyBvjfy7u1IjU03v%2Fuploads%2FwOQkyYYrOUx09fnk34Il%2F%E5%B1%80%E9%83%A8%E6%88%AA%E5%8F%96_20260822_200442.png?alt=media&amp;token=bf4a6e0a-799e-40a6-8896-0b34bdcfec5f" alt=""><figcaption></figcaption></figure>

Review the corresponding:

* Request ID
* Model
* Billing Mode
* Consumption
* Cost
* Status

For generated images and videos, you can also review [**Generated Media History**](/api-usage/generated-media-history.md).

Video history records include the actual cost of successful generations along with model, duration, and resolution information.

### ⚠️ Avoid Unexpected Costs

Before sending production requests:

1. Confirm the exact model.
2. Review its current pricing.
3. Explicitly specify HappyHorse `size` and `duration`.
4. Explicitly specify Seedance `resolution` where appropriate.
5. Check whether Seedance contains video input, because this can use a different rate.
6. Limit sequential image generation to the number of images you actually need.
7. Avoid automatically resubmitting a request after a client timeout without checking whether it already completed.

For synchronous image generation in particular, a client timeout does not necessarily mean the generation failed. The API specification recommends a client timeout of at least 90 seconds because generation may complete and incur a charge even if the client disconnects too early.

### 🔄 Pricing Changes

Model pricing, availability, supported resolutions, and provider configurations may change.

The API specification explicitly notes that final model pricing should follow the current online configuration and the price locked when the request is made.

For that reason:

> **Use the current ApiSmart Console or model pricing interface as the source of truth when estimating production costs.**

Do not rely on an old screenshot, cached documentation, or previously recorded model price for long-term budgeting.

### ✅ Billing Checklist

Before deploying an integration, confirm the model ID, current pricing, billing unit, and any model-specific defaults that affect cost.

After deployment, use [**Usage Logs and Costs**](/api-usage/usage-logs-and-costs.md) to monitor actual charges and investigate unexpected usage.

### ➡️ Next Steps

* [**Models and Model IDs**](/models-and-pricing/models-and-model-ids.md) — Find supported models and exact model IDs
* [**Usage Logs and Costs**](/api-usage/usage-logs-and-costs.md) — Review request-level consumption and costs
* [**Generated Media History**](/api-usage/generated-media-history.md) — Review image and video generation history
* [**Add Funds and Understand Wallet Credits**](/account-and-wallet/add-funds-and-understand-wallet-credits.md) — Manage your wallet
* [**Balance and Usage Limit Issues**](/troubleshooting/balance-and-usage-limit-issues.md) — Troubleshoot `402` and usage-limit problems
