> ## Documentation Index
> Fetch the complete documentation index at: https://docs.gengen.farm/llms.txt
> Use this file to discover all available pages before exploring further.

# List model prices

> Get current GENGEN unit prices for video, image, audio, and text models, with optional account-specific prices.

Use the GENGEN pricing API to retrieve the customer price catalog in a single
request. Each model includes its individual pricing specifications, so you can
display the rate for the applicable resolution, input type, or billing unit.

## Request

```text theme={"dark"}
GET https://gengen.farm/api/public/pricing
```

Without authentication, this endpoint returns standard customer prices. To get
the prices configured for your billing accounts, send your GENGEN API key in the
`Authorization: Bearer <GENGEN_API_KEY>` header. No request body or query
parameters are needed. This free request returns the full catalog without
pagination and requires no positive balance. It does not reserve funds or create
a generation task.

**Authorization** `string`

Optional. In **Try it**, enter `Bearer YOUR_GENGEN_API_KEY` to request your
billing accounts' prices. Include the `Bearer ` prefix. Leave this field empty
to request standard customer prices.

Accounts with a public-price display policy receive standard customer prices and
the same response fields as an anonymous request, even with a valid API key.
Their configured billing rates still apply to generation requests.

```bash cURL theme={"dark"}
curl --request GET \
  --url https://gengen.farm/api/public/pricing
```

```javascript Node.js theme={"dark"}
const response = await fetch('https://gengen.farm/api/public/pricing');
if (!response.ok) {
  throw new Error(`Pricing request failed: ${response.status}`);
}
const catalog = await response.json();
console.log(catalog.models);
```

```python Python theme={"dark"}
import json
from urllib.request import urlopen

with urlopen('https://gengen.farm/api/public/pricing', timeout=30) as response:
    catalog = json.load(response)

print(catalog['models'])
```

To include your billing accounts' prices:

```bash theme={"dark"}
curl --request GET \
  --url https://gengen.farm/api/public/pricing \
  --header "Authorization: Bearer $GENGEN_API_KEY"
```

## Response

HTTP `200` returns a JSON object. The example shows two models with illustrative prices. Fetch the endpoint for current values.

```json 200 theme={"dark"}
{
  "currency": "USD",
  "generatedAt": "2026-11-13T15:02:06.947Z",
  "models": [
    {
      "id": "wan-3.0-spicy",
      "name": "Wan 3.0 Spicy",
      "modality": "video",
      "prices": [
        {
          "priceRowId": "wan-3.0-spicy-480p-video",
          "basis": "480P output and reference video",
          "unit": "second",
          "priceUsd": 0.0350025,
          "originalPriceUsd": 0.065,
          "discountPercent": 46.15
        },
        {
          "priceRowId": "wan-3.0-spicy-720p-video",
          "basis": "720P output and reference video",
          "unit": "second",
          "priceUsd": 0.070005,
          "originalPriceUsd": 0.13,
          "discountPercent": 46.15
        },
        {
          "priceRowId": "wan-3.0-spicy-1080p-video",
          "basis": "1080P output and reference video",
          "unit": "second",
          "priceUsd": 0.14001,
          "originalPriceUsd": 0.26,
          "discountPercent": 46.15
        }
      ]
    },
    {
      "id": "seedream-5-0-260128",
      "name": "Seedream 5.0 Lite",
      "modality": "image",
      "prices": [
        {
          "priceRowId": "seedream-5-image",
          "basis": "Image generation",
          "unit": "image",
          "priceUsd": 0.0455
        }
      ]
    }
  ]
}
```

```json 503 theme={"dark"}
{
  "error": "Pricing is temporarily unavailable."
}
```

| Field | Type | Description |
| - | - | - |
| `currency` | string | Price currency, currently `USD`. |
| `generatedAt` | string | ISO 8601 UTC response-generation time. This is not a price-change timestamp or pricing version. |
| `models` | object\[] | Models with published customer prices. |
| `models[].id` | string | Model identifier used in API requests. |
| `models[].name` | string | Model display name. |
| `models[].modality` | string or null | Model category, currently `video`, `image`, `audio`, or `reasoning`; `null` if unspecified. |
| `models[].available` | boolean, optional | Currently returned for Kling 4.0 to indicate whether new generation is enabled. Its prices remain listed when this value is `false`. |
| `models[].prices` | object\[] | Individual rates for this model's pricing specifications. |
| `models[].prices[].priceRowId` | string | Stable identifier for this model and pricing specification across standard and account-specific catalogs. |
| `models[].prices[].basis` | string | Description of the specification or usage component to which this rate applies. |
| `models[].prices[].unit` | string | Billing unit for the rate, such as `second`, `image`, or `1M tokens`. Preserve the returned unit when displaying the price. |
| `models[].prices[].priceUsd` | number | Final USD price per indicated billing unit. Uses the account-specific price when configured, or the standard customer price otherwise. |
| `models[].prices[].originalPriceUsd` | number, optional | Customer unit price before the discount. Omitted when no discount is shown. |
| `models[].prices[].discountPercent` | number, optional | Percentage reduction from the original customer price. For example, `46.15` means 46.15% off. |
| `billingScope` | string, optional | Returned for account-specific catalogs. `personal` or `shared` identifies the preferred paying account whose prices appear in `models`. Omitted for public-price display. |
| `fallbacks` | object\[], optional | Additional paying accounts in billing priority order, currently the personal fallback for a shared-wallet member. Omitted when there is no fallback or public-price display applies. |
| `fallbacks[].billingScope` | string | Billing scope of this fallback, currently `personal`. |
| `fallbacks[].models` | object\[] | The same model and price structure as `models`, using this fallback account's prices. |

## Using the prices

For time-priced video tasks, retrieve the successful task by ID and match
`usage.priceRowId` to a price row for the same model. For a per-second rate,
multiply `usage.billableSeconds` by `priceUsd`. A Wan 3.0 task can return:

```json theme={"dark"}
{
  "priceRowId": "wan-3.0-720p-video",
  "resolution": "720p",
  "outputDurationSeconds": 5.25,
  "inputVideoDurationSeconds": 2.5,
  "billableSeconds": 7.75
}
```

MiniMax H3 uses three terms. Multiply `billableOutputSeconds` by the
`priceRowId` rate, `inputVideoDurationSeconds` by the `referenceVideoPriceRowId`
rate, and `billableReferenceImageCount` by the `referenceImagePriceRowId`
rate, then add the results. BytePlus video enhancement uses a per-minute rate:
multiply `outputDurationSeconds / 60` by the `priceRowId` rate.

To reproduce a historical charge, use the rates effective for that task and
paying account. A later catalog request returns current prices.

The account-specific rules below apply when `billingScope` is present. Accounts
with a public-price display policy receive standard rates without payer catalogs.

* A configured account price replaces the standard price for that specification,
  including when the account price is zero. Those rows omit `originalPriceUsd`
  and `discountPercent`; all other rows keep their standard pricing and discounts.
* An authenticated request resolves the accounts that can pay for your API calls.
  `models` uses the preferred paying account's prices. Shared-wallet members see
  the wallet owner's prices here, including that account's inherited public rates.
* Shared-wallet members also receive their personal prices in `fallbacks`. A
  generation that falls back to personal payment uses those rates. The catalog
  follows billing priority even when a wallet has no available balance, since a
  free specification can still use that wallet. The actual payer is determined
  when the generation reserves funds, using its required amount and applicable
  credits. This catalog does not predict that decision.
* A model can have several rates. Match the applicable `basis` and `unit`; do not
  use the first row as a universal price for that model.
* `1M tokens` means one million tokens. For a per-1,000-token display, divide
  `priceUsd` by 1,000 and label the converted unit accordingly.
* Unit prices are not fixed quotes for a complete generation. A request can incur
  several usage components, and final charges depend on actual billable usage.
* Hidden or retired models are excluded. Inclusion in this list does not replace
  the endpoint's generation availability, input, or account checks.
* Responses use `Cache-Control: no-store`. Fetch again when you need an updated
  catalog; `generatedAt` does not guarantee that a previously fetched price still applies.
* The JavaScript example is for a server environment. Browser cross-origin access
  is restricted to the GENGEN documentation origin; call from your backend when
  integrating this endpoint into another website.

An invalid or malformed key returns HTTP `401`. A revoked or expired key returns
HTTP `403`. If key validation fails because the service is unavailable, the
endpoint returns HTTP `500`; if pricing cannot be loaded, it returns HTTP `503`.
Retry service errors later. Do not treat an error response or a missing price as
a zero price.


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