AI Video Model Limits on each::labs: Duration, Resolution, Aspect Ratio and Pricing

A model family name tells you less than you might think. The route you actually call has its own contract: duration, output size, framing controls, and pricing. Two variants with nearly identical names can accept different inputs.

There is no universal maximum AI-video length. Some routes use a fixed duration. Others expose a short list of allowed values or a bounded range. Extension and continuation can produce a longer finished sequence, but they do not change the native duration of one generation request.

This reference describes the models exposed through each::labs. It does not assume that a provider's consumer application, direct API, and each::labs route offer the same controls.

AI video model limits are the request constraints attached to a specific callable route, including allowed duration, output resolution, aspect ratio, and pricing configuration. They belong to the route, not simply to the model family name.

Last checked: September 4, 2026.

Scope note: This edition contains the video-generation routes whose current limits could be verified from accessible each::labs first-party model records during this production pass. The live catalog should remain the source of truth for routes not yet represented here.

AI video model limits at a glance

Callable model	Type	Native duration	Resolution	Aspect ratios	Cost / billing basis	Constraint
Google Veo 3 (veo-3)	Text to video	8s	720p, 1080p; 4K on preview models	16:9, 9:16	$0.80–$3.20 / execution	4K is not documented as a universal mode on this route.
Google Veo 3 Fast (veo-3-fast)	Text to video	4s, 6s, 8s	720p, 1080p	16:9, 9:16	$0.40–$1.20 / execution	Price changes with duration and audio.
Google Veo 3 Image to Video (veo-3-image-to-video)	Image to video	4s, 6s, 8s	Up to 4K documented	16:9, 9:16	$0.20–$0.40 / sec	Audio changes the per-second rate.
Sora 2 Text to Video (sora-2-text-to-video)	Text to video	Up to 20s	720p, 1080p	16:9, 9:16	$0.10 / sec	The exact callable route matters more than a family-level maximum.
Sora 2 Text to Video Pro (sora-2-text-to-video-pro)	Text to video	Up to 20s	720p, up to 1080p	16:9 verified	$0.30 / sec; 1080p $0.50 / sec	Do not infer additional ratio values from sibling routes.
Sora 2 Image to Video (sora-2-image-to-video)	Image to video	4s, 8s, 12s, 16s, 20s	Up to 1080p	16:9 verified	$0.40–$2.00 / execution	Price scales with the selected duration.
Sora 2 Image to Video Pro (sora-2-image-to-video-pro)	Image to video	4–20s	Up to 1080p	16:9, 9:16	$0.30 / sec; 1080p $0.50 / sec	Input framing should match the intended output framing.
Seedance 2.0 Text to Video (bytedance-seedance-2-0-text-to-video)	Text to video	4–15s	Up to 1080p	16:9, 9:16, 4:3, 3:4, 21:9, 1:1	From $1.15 / unit	Longer configurations are separate from the normal 15s native cap.
Seedance 2.0 Image to Video (bytedance-seedance-2-0-image-to-video)	Image to video	4–15s	Up to 1080p	16:9, 9:16, 4:3, 3:4, 21:9, 1:1	From $1.15 / unit	Extension capability should not be reported as native duration.
Wan v2.6 Text to Video (wan-v2-6-text-to-video)	Text to video	Up to 15s	720p, 1080p	Aspect-ratio control exposed; complete enum not verified here	From $0.10	Keep the exact ratio enum tied to the live schema.
Wan v2.6 Image to Video (wan-v2-6-image-to-video)	Image to video	2–15s	720p, 1080p	16:9, 9:16, 1:1	$0.10–$0.15 / sec	Resolution changes the rate.
Wan v2.6 Reference to Video (wan-v2-6-reference-to-video)	Reference to video	2–15s	720p, 1080p	Aspect-ratio control exposed; 16:9 verified	$0.10–$0.15 / sec	Do not turn the example ratio into an invented full enum.
Pika v2.2 Text to Video (pika-v2-2-text-to-video)	Text to video	Up to 15s	720p, 1080p	Social-format ratios documented; complete enum not verified here	$0.04–$0.09 / sec	1080p uses the higher rate.
Pika v2.2 Image to Video (pika-v2-2-image-to-video)	Image to video	5–10s	720p, 1080p	Multiple social ratios documented; complete enum not verified here	$0.04–$0.09 / sec	1080p uses the higher rate.
Kling v3 Standard Text to Video (kling-v3-standard-text-to-video)	Text to video	3–15s	Up to 1080p	16:9, 1:1, 9:16	$0.14 / unit	4K belongs to a different callable variant.
MiniMax H3 Text to Video (minimax-h3-text-to-video)	Text to video	5–15s	2K-class / documented 1440p layer	21:9, 16:9, 4:3, 1:1, 3:4, 9:16, adaptive	$0.09–$0.13 / sec	This route calls the framing parameter ratio, not aspect_ratio.
Pixverse v5.6 Text to Video (pixverse-v5-6-text-to-video)	Text to video	5–10s	Up to 1080p	16:9, 9:16	$0.00627 / credit	Broader 4K wording elsewhere on the card is not used as the route limit.
Pixverse v5.6 Image to Video (pixverse-v5-6-image-to-video)	Image to video	5s, 8s, 10s	Up to 1080p	16:9, 9:16, 1:1, 4:3, 3:4	$0.00627 / credit	The route-specific 1080p statement takes precedence over contradictory 4K copy on the same page.

A family name is a poor unit of comparison. One family can contain Standard, Pro, Fast, image-to-video, text-to-video, reference, transition, or higher-resolution routes. The limits often change at exactly those boundaries.

How to read the table

Native duration is the length supported by that generation route. A continuation or extension operation may produce a longer sequence, but it does so through additional generation work.

Resolution needs a little more care. Where the current request schema exposes a resolution field, its allowed values are the strongest source. Some routes instead document an output resolution without exposing a resolution control in the example request. Those are not quite the same claim.

Aspect ratio varies in both values and naming. One route may expose aspect_ratio; another may call the field ratio. auto can also be a real value rather than shorthand for “every ratio.”

Canberk's production note: The field name is not the contract. I've learned not to treat normalized parameters as interchangeable because the JSON looks familiar. A unified API removes a lot of integration syntax. It cannot make two underlying models attach the same meaning to duration, framing, or resolution.

Cost / billing basis keeps the model's actual pricing unit attached to the number. Some routes bill per second. Others expose a per-unit price, an estimated execution range, or provider-style credits. Converting all of them into one invented credit would make the table cleaner and the comparison less accurate.

What “maximum duration” actually means

“How long can an AI-generated video be?” does not have one useful universal answer.

One model may only accept eight seconds. Another may accept 4, 8, 12, 16 or 20. Another allows any integer within a defined range. A continuation feature can then take an existing output and generate what happens next.

If an eight-second route can be extended repeatedly, its native limit is still eight seconds. You made several generation requests that happen to form one sequence.

That affects cost and latency as well as terminology. Every additional generation can mean another billed inference, another wait, and another place for motion or continuity to drift.

For this table, duration belongs to the exact callable route. Extension stays separate unless it is explicitly identified.

Resolution is a constraint, not a quality score

If an application needs a particular output size, resolution can rule out a route before you evaluate anything subjective.

A 1080p requirement may push you away from a lower-resolution route or force an upscale step later. The route with the largest dimensions, though, is not automatically the better model.

This reference treats 720p, 1080p, 2K and 4K as technical capabilities, not quality rankings.

There is also an evidence boundary. A schema allowing a resolution establishes what the API accepts. It does not mean we independently downloaded and inspected every generated file. Request compatibility and delivered-file compliance are different tests.

Aspect ratio is often a hard requirement

For a vertical-video product, explicit 9:16 support may matter more than a model's reputation.

If a route only exposes landscape framing, you either change models or add a crop or reframe step downstream. The same applies to square product assets and ultrawide outputs.

The exact enum matters. So does the parameter name.

For example, one current route uses ratio while many others expose aspect_ratio. Code that assumes every model normalizes to the same key can miss a valid model before it even starts comparing values.

Pricing: keep the billing rule attached to the number

A price without its billing basis is easy to misread.

$0.10/sec, $0.14/unit, $0.00627/credit, and “from $1.15” describe different contracts. Duration, resolution, audio, or another setting may change what the request finally costs.

That is why this reference does not use one universal Credits column.

The current each::labs model-detail response can include a nullable cost object with the currency, pricing type, amount, unit, estimate, and a description of the billing driver. That is pre-run guidance. Once an execution finishes, metrics.cost is the settled value. See each::labs pricing for the current pricing model.

Canberk's production note: I would not use the model-card price as the only production-cost metric. Retries, rerolls, and downstream media processing can all change what one usable asset costs. That is a different unit-economics question. Here, the narrower job is to report the callable route's pricing basis accurately.

Generation cost is also separate from each::video billing and limits. Trimming, transcoding, compositing, and other deterministic media operations follow their own billing model.

Why the same model can have different limits elsewhere

A model name can refer to several surfaces:

• a consumer application;
• a provider API;
• an each::labs route;
• Standard, Pro, or Fast variants;
• text-to-video and image-to-video routes;
• a separate high-resolution variant;
• continuation or extension.

Those surfaces do not have to expose identical controls.

This is why “Model X supports 4K and 20 seconds” is often underspecified. The 4K control may belong to one variant while the 20-second control belongs to another.

For implementation work, the callable slug is the useful unit.

Check a model's limits programmatically

The public model catalog is available at GET /v1/models. It returns each model's slug and request_schema, and it does not require authentication. See the List Models API documentation.

One detail matters if you want the whole catalog: 500 is the maximum page size, not a guarantee that there are at most 500 results. Paginate until a page contains fewer items than the requested limit.

import requests

BASE_URL = "https://api.eachlabs.ai"
PAGE_SIZE = 500

def list_all_models():
    offset = 0

    while True:
        response = requests.get(
            f"{BASE_URL}/v1/models",
            params={"limit": PAGE_SIZE, "offset": offset},
            timeout=30,
        )
        response.raise_for_status()

        page = response.json()

        for model in page:
            yield model

        if len(page) < PAGE_SIZE:
            break

        offset += len(page)

for model in list_all_models():
    print(model["slug"])

Do not then assume that every video route contains properties called duration, resolution, and aspect_ratio.

Inspect the model's own schema:

import json
import os
import requests

slug = "kling-v3-standard-text-to-video"

response = requests.get(
    f"https://api.eachlabs.ai/v1/models/{slug}",
    headers={
        "Authorization": f"Bearer {os.environ['EACHLABS_API_KEY']}",
    },
    timeout=30,
)
response.raise_for_status()

model = response.json()

print(json.dumps(model["request_schema"], indent=2))
print(json.dumps(model["cost"], indent=2))

The current model-detail path is GET /v1/models/{slug}. The older query form, GET /v1/model?slug={slug}, is deprecated.

The model version field is deprecated as well. It should not be used to distinguish the limits in this reference. The slug and current request schema are the useful identifiers.

How we keep this reference current

A limits page becomes wrong quietly.

New routes arrive. Old routes stay callable. Pricing changes. A resolution mode appears. And a newer model does not automatically make the previous one irrelevant: an older route may still fit a product better on price, latency, behavior, or an integration that is already in production.

For hard request constraints, this page should use this source order:

1. the model's current request_schema;
2. structured model cost metadata;
3. the current each::labs model card for interpretation;
4. editorial descriptions only where they do not conflict with the contract.

When two first-party descriptions disagree, the table should not pick the larger number. It should use the API contract or mark the value unresolved until that contract can be checked.

FAQ

How long can AI-generated videos be?

There is no universal maximum. Native duration belongs to a specific callable route. Current routes range from fixed short clips to selectable values and bounded ranges; continuation features can build longer sequences through additional generations.

Does 4K always mean native 4K generation?

No. 4K can refer to a preview mode, a separate callable variant, a route-specific capability, or an upscale path. The exact route needs to establish what the number means.

Does higher resolution cost more?

Sometimes. Several current routes change rate by resolution, while others bill by duration, execution, unit, credits, or additional settings such as audio.

Are the listed prices final?

Not necessarily. The model-detail API can return an estimated cost or pricing rule before execution. metrics.cost on the completed execution is the settled amount.

Why does another site show a different limit for the same model?

It may be describing another API surface, consumer app, variant, or extension feature. This page is scoped to the exact route callable through each::labs.

How do I retrieve current limits through the each::labs API?

List models with GET /v1/models, then inspect the exact model's request_schema. Do not assume the same parameter names or enum values across every model.