Models

Use the models endpoints to discover which models your project can use, which parameters each one accepts, and what each one costs.

GET https://api.getimg.ai/v2/models
GET https://api.getimg.ai/v2/models/{model}

What these endpoints return

Every model comes back with its supported parameters and its currently effective pricing. Use them when you need to:

discover current model IDs
separate image models from video models
validate aspect_ratio, resolution, duration, and sound before you submit a generation
read the current price per billable unit

List models

import GetimgAI from "getimg-ai";

const client = new GetimgAI();

const models = await client.models.list();
console.log(models);

from getimg import GetimgAI

client = GetimgAI()

models = client.models.list()
print(models)

curl https://api.getimg.ai/v2/models \
  -H "Authorization: Bearer $GETIMG_API_KEY"

Filter by type

Use the optional type query parameter when you only want one category.

import GetimgAI from "getimg-ai";

const client = new GetimgAI();

const videoModels = await client.models.list({ type: "video" });
console.log(videoModels);

from getimg import GetimgAI

client = GetimgAI()

video_models = client.models.list(type="video")
print(video_models)

curl "https://api.getimg.ai/v2/models?type=video" \
  -H "Authorization: Bearer $GETIMG_API_KEY"

Use type=image for image models and type=video for video models.

Get a single model

Pass a model ID to read one model without fetching the whole list.

import GetimgAI from "getimg-ai";

const client = new GetimgAI();

const model = await client.models.retrieve("seedream-5-lite");
console.log(model.supported_resolutions);

from getimg import GetimgAI

client = GetimgAI()

model = client.models.retrieve("seedream-5-lite")
print(model.supported_resolutions)

curl https://api.getimg.ai/v2/models/seedream-5-lite \
  -H "Authorization: Bearer $GETIMG_API_KEY"

The response is a single model object.

{
  "id": "seedream-5-lite",
  "name": "Seedream 5 Lite",
  "type": "image",
  "supported_aspect_ratios": ["1:1", "16:9"],
  "supported_durations": [],
  "supported_resolutions": ["2K", "4K"],
  "supports_sound": false,
  "supported_references": { "reference_image": 14 },
  "pricing": {
    "currency": "USD",
    "rates": [
      {
        "resolution": "2K",
        "sound": "not_applicable",
        "billable_unit": "image",
        "unit_price": "0.1400"
      }
    ]
  },
  "created_at": "2026-04-17T10:20:30.000Z"
}

An unknown model ID returns 404 with error code not_found.

Response fields

Field	Type	Description
`id`	string	Model identifier to send as `model`
`name`	string	Display name
`type`	string	`image` or `video`
`supported_aspect_ratios`	array	Accepted `aspect_ratio` values
`supported_durations`	array	Accepted `duration` values in seconds. Empty for image models.
`supported_resolutions`	array	Accepted `resolution` values
`supports_sound`	boolean	Whether the model can generate audio
`supported_references`	object	Maximum reference image count per role
`pricing`	object	Currency and currently effective rates
`created_at`	string	When the model was added

Supported parameters and defaults

supported_aspect_ratios, supported_durations, and supported_resolutions are ordered. The first value is the default the API applies when you omit the parameter, so you can send a minimal request and still get a sensible result. Sending a value that isn’t in the list returns 400 with error code invalid_parameter.

Reference image roles

supported_references maps each role the model accepts to the maximum number of reference images for that role.

{
  "supported_references": { "first_frame": 1, "last_frame": 1 }
}

A role that isn’t in the object isn’t supported by that model. Use this to check a role before you submit rather than discovering it from a 400. See Generate images and Generate videos for how roles work.

Pricing

Each model carries the rates currently in effect for your project.

Field	Description
`currency`	Always `USD`
`rates`	Effective rates, ordered by unit price
`rates[].resolution`	Resolution the rate applies to, or `null` when the rate is resolution-independent
`rates[].sound`	`sound_on`, `sound_off`, or `not_applicable`
`rates[].billable_unit`	`image` for images, `video_second` for videos
`rates[].unit_price`	Price per billable unit, as a decimal string

To find the rate for a generation, match on the resolution and sound values you plan to send. For videos, not_applicable also acts as a fallback when no exact match exists. unit_price is a string so you can parse it as a decimal without floating-point rounding. Use your language’s decimal type rather than a float when you total costs.

An empty rates array means no active rates are configured for that model. It does not mean generation is free. Current rates are also listed on the Models page.

For what you have actually spent, see Billing.

Validate before you generate

Fetch the model and check your parameters against it. That turns a failed generation into a local check.

import GetimgAI from "getimg-ai";

const client = new GetimgAI();

const model = await client.models.retrieve("seedance-v1-pro");

const resolution = "1080p";
const duration = 10;

if (!model.supported_resolutions.includes(resolution)) {
  throw new Error(`${model.id} supports: ${model.supported_resolutions.join(", ")}`);
}
if (!model.supported_durations.includes(duration)) {
  throw new Error(`${model.id} supports: ${model.supported_durations.join(", ")}`);
}
if (!model.supports_sound) {
  console.log(`${model.id} has no sound, omitting the parameter`);
}

const { id } = await client.videos.generations.create({
  model: model.id,
  prompt: "A timelapse of clouds rolling over a mountain peak",
  resolution,
  duration,
  sound: model.supports_sound,
});

from getimg import GetimgAI

client = GetimgAI()

model = client.models.retrieve("seedance-v1-pro")

resolution = "1080p"
duration = 10

if resolution not in model.supported_resolutions:
    raise ValueError(f"{model.id} supports: {model.supported_resolutions}")
if duration not in model.supported_durations:
    raise ValueError(f"{model.id} supports: {model.supported_durations}")
if not model.supports_sound:
    print(f"{model.id} has no sound, omitting the parameter")

submission = client.videos.generations.create(
    model=model.id,
    prompt="A timelapse of clouds rolling over a mountain peak",
    resolution=resolution,
    duration=duration,
    sound=model.supports_sound,
)

To check a reference image role, read supported_references.

const maxFirstFrames = model.supported_references.first_frame ?? 0;

if (maxFirstFrames === 0) {
  throw new Error(`${model.id} does not accept a first frame`);
}

max_first_frames = model.supported_references.get("first_frame", 0)

if max_first_frames == 0:
    raise ValueError(f"{model.id} does not accept a first frame")

Image vs video models

Choose the model type based on the generation type:

Image models are for POST /v2/images/generations
Video models are for POST /v2/videos/generations

Sending an image model to the video endpoint, or the reverse, returns 400 with error code invalid_parameter.

How to choose a model

Start with these checks:

generation type: image or video
input shape: prompt only, reference image, first frame, or last frame
output needs: aspect ratio, resolution, duration, and sound

If your integration depends on a specific capability, read the model before you submit a generation and validate against its supported parameters. That keeps your production flow stable as model availability changes.

Where to check current availability

Use one of these sources:

GET /v2/models and GET /v2/models/{model} in your integration
the Models page in the dashboard

Avoid hardcoding a fixed model list, parameter set, or price in your integration. All of them can change.

Getting started

Generation

Concepts

What these endpoints return

List models

Filter by type

Get a single model

Response fields

Supported parameters and defaults

Reference image roles

Pricing

Validate before you generate

Image vs video models

How to choose a model

Where to check current availability

​What these endpoints return

​List models

​Filter by type

​Get a single model

​Response fields

​Supported parameters and defaults

​Reference image roles

​Pricing

​Validate before you generate

​Image vs video models

​How to choose a model

​Where to check current availability

​Related pages

What these endpoints return

List models

Filter by type

Get a single model

Response fields

Supported parameters and defaults

Reference image roles

Pricing

Validate before you generate

Image vs video models

How to choose a model

Where to check current availability

Related pages