First Last Frame to Video API: FL2V Integration Guide

The short answer: FL2V is a two-image video API pattern

“First last frame to video” (FL2V, also written FLF2V, first-and-last-frame-to-video, or “start and end frames”) describes one API pattern: you send a model two images — the frame the video starts on and the frame it ends on — plus a text prompt, and it returns a video that transitions smoothly from the first image to the last. The prompt describes the motion in between: a building changing from day to night, a product morphing into its next version, a character walking from one pose into another.

This is not one vendor’s feature. Alibaba’s Wan models expose it as the kf2v family, Google’s Veo documentation covers it as first-and-last-frame generation, Kling ships it as a start/end frames mode, and MiniMax, PixVerse, and Vidu all have dedicated FL2V model routes. If you integrate through an aggregator, one request shape covers several of them.

Two things to know before the details. First, every FL2V API is asynchronous: submit a task, poll for its status, download the finished video — there is no synchronous “give me a video now” call. Second, prices and model availability change fast; everything model- or price-specific in this guide was read from the cited pages on August 6, 2026. Modellix, where this article lives, is an AI media API aggregator and has a commercial interest in the route comparison later in this guide — the numbers are presented so you can check them yourself.

What an FL2V API takes in and returns

The request surface is small and consistent across providers. A typical FL2V request body:

Field	What it is	Notes
first_frame_image	Start frame — the first frame of the output video	Public URL or base64 data URI
last_frame_image	End frame — the final frame of the output video	Same format; most providers require both
prompt	Description of the transition / motion	Optional on some routes (Hailuo 02), required on others
duration	Output length in seconds	e.g. 5–8s on Veo, 5s fixed on Wan 2.2, up to 15s on PixVerse v6
resolution / quality	Output tier	360p–1080p typically; Veo 3.1 adds 4K
generate_audio_switch	Optional audio synthesis	PixVerse v6/c1 routes
seed	Reproducibility	Optional on most routes

The output is a video URL (plus resolution and duration metadata), delivered through a task result endpoint. The images themselves need to be reachable by the API — a public URL is the default, and several routes also accept base64 data URIs so you do not need to host the frames.

The boundary with image-to-video (I2V) matters. A single-image I2V call animates one starting image and lets the model invent the ending. FL2V constrains both ends, which is what makes it useful for shots where the ending is the point: before/after comparisons, product morphs, reveal-style ad hooks, storyboard completion, time-lapse transitions. If you only have one image, you want I2V, not FL2V — most FL2V routes reject single-image input.

One practical constraint applies across providers: the two frames should be visually consistent. Kling’s official guide warns that large differences between the start and end frames cause a “lens switch” — the model cuts rather than transitions. Keep the subject, composition, and lighting comparable, and match the frame dimensions.

Figure 1: The first-last-frame-to-video pattern — two images plus a prompt become a transition video; the API is asynchronous (submit → poll → download).

Which models and providers support first-last-frame video

The table below maps the FL2V-capable routes you are most likely to evaluate. Vendor docs are primary sources; the Modellix routes are what the aggregator actually exposes through its unified API.

Provider	Model / route	How it is exposed	Key facts (as of 2026-08-06)
Alibaba	Wan 2.1/2.2 kf2v family	Official Model Studio API	wan2.2-kf2v-flash / wan2.1-kf2v-plus; fixed 5s duration; 480P–1080P; region-locked endpoints; 24h task/URL validity; billed per second
Google	Veo 2 / Veo 3.1	Official docs	4/6/8s durations; 720p/1080p/4K; also available through aggregators such as fal.ai
Kling	Start & End Frames mode	Consumer feature; API via aggregators	Official guide stresses similar frames; no first-party API doc as of this writing
MiniMax	Hailuo 02 FL2V	Official FL2V task API + Modellix route	6s or 10s; 768P/1080P; optional first frame (last-frame-only mode); 15 camera-control instructions
PixVerse	v6-fl2v / c1-fl2v	Official docs + Modellix routes	Up to 15s; 360p–1080p; optional audio; see our dedicated PixVerse first-last-frame (FL2V) guide for the endpoint deep dive
Vidu	Q3 Pro FL2V / Q3 Turbo FL2V	Modellix routes	540p–1080p; Turbo trades detail for speed
Alibaba (multimodal)	Wan 2.7 I2V	Modellix wan2.7-i2v route	first_frame + last_frame task mode alongside audio/clip modes

Two observations before you pick. First, the naming is a mess — the same technique is called FL2V, FLF2V, first-and-last-frame, first/last frame, and start/end frames, and Alibaba’s own model id is the less obvious kf2v — a naming-consistency trap worth knowing. When you read a model card, match it by the parameter shape (two image fields + prompt), not the acronym. Second, aggregators widen the catalog: fal.ai, Segmind, and Modellix all resell FL2V routes from several vendors behind one API — fal.ai’s Kling O1 page is one example — which is how you get to “one request shape, many models” without maintaining several vendor SDKs.

How the FL2V API call works: submit, poll, retrieve

All FL2V APIs share the same lifecycle. You authenticate, submit a task with the two frames and the prompt, receive a task_id, poll the task endpoint until the status is terminal, and download the video from the result URL. The differences between providers are the endpoint paths, the field names, and the billing unit — not the shape of the flow.

A concrete example against the Modellix unified API, using the pixverse/v6-fl2v route:

curl --request POST \
  --url https://api.modellix.ai/api/v1/pixverse/v6-fl2v \
  --header 'Authorization: Bearer YOUR_MODELLIX_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "first_frame_image": "https://example.com/start.png",
    "last_frame_image": "https://example.com/end.png",
    "prompt": "The building lights come on one by one as dusk settles",
    "duration": 5,
    "quality": "720p"
  }'

The response contains the task handle — note there is no video in it yet:

{
  "code": 0,
  "message": "success",
  "data": {
    "status": "pending",
    "task_id": "task-pixverse-fl2v-001",
    "model_id": "pixverse/v6-fl2v",
    "get_result": {
      "method": "GET",
      "url": "https://api.modellix.ai/api/v1/tasks/task-pixverse-fl2v-001"
    }
  }
}

Poll that get_result.url until the status leaves pending/processing. A minimal Python flow:

import json
import time
import urllib.request

API = "https://api.modellix.ai/api/v1"
KEY = "YOUR_MODELLIX_API_KEY"

def submit_fl2v(first_frame, last_frame, prompt, duration=5, quality="720p"):
    body = json.dumps({
        "first_frame_image": first_frame,
        "last_frame_image": last_frame,
        "prompt": prompt,
        "duration": duration,
        "quality": quality,
    }).encode()
    req = urllib.request.Request(
        f"{API}/pixverse/v6-fl2v", data=body,
        headers={"Authorization": f"Bearer {KEY}", "Content-Type": "application/json"},
    )
    with urllib.request.urlopen(req) as resp:
        return json.load(resp)["data"]["task_id"]

def wait_for_video(task_id, timeout=180):
    url = f"{API}/tasks/{task_id}"
    req = urllib.request.Request(url, headers={"Authorization": f"Bearer {KEY}"})
    deadline = time.time() + timeout
    while time.time() < deadline:
        with urllib.request.urlopen(req) as resp:
            data = json.load(resp)["data"]
        if data["status"] == "success":
            return data["result"]["resources"][0]["url"]
        if data["status"] in ("failed", "cancelled"):
            raise RuntimeError(f"task {task_id} {data['status']}")
        time.sleep(3)
    raise TimeoutError(task_id)

The same two functions work for every Modellix route — swap the path to /minimax/hailuo-02-fl2v or /vidu/viduq3-turbo-fl2v and keep the field names that route documents.

Three operational details save debugging time:

• Results expire. Modellix stores generated results for 7 days (the REST API guide states this explicitly); Alibaba’s Wan reference gives task ids and video URLs a 24-hour validity. Download to your own storage promptly.
• Errors are structured. The unified API returns {"code": <http status>, "message": "<category>: <detail>"}. 400 means fix the parameters, 401 a bad key, 402 insufficient balance, 404 a missing task or model, 429 a rate limit (respect X-RateLimit-Reset), and 500/503 are retryable with exponential backoff.
• Webhooks are available. If you would rather not poll, configure a webhook URL and receive the task result asynchronously — the submit call stays the same.

For the input-prep side of the pipeline: if your source is an existing video and you need its first and last frames, a two-line ffmpeg invocation extracts them — ffmpeg -i input.mp4 -vf "select=eq(n\,0)" -frames:v 1 start.png and ffmpeg -sseof -0.1 -i input.mp4 -frames:v 1 end.png — which covers most “first and last frame extractor” cases without extra tooling.

What first-last-frame video costs

FL2V is billed per second of output on most routes, with the rate tiered by resolution. That makes the unit cost predictable — but only if you compare the same duration and the same quality tier. The prices below were read from the live Modellix model pages on August 6, 2026; they change, so treat them as a snapshot, not a quote.

Route (Modellix)	540p	720p	1080p
vidu/viduq3-turbo-fl2v	$0.0322/s	$0.0506/s	$0.0598/s
vidu/viduq3-pro-fl2v	$0.0414/s	$0.0920/s	$0.1104/s
minimax/hailuo-02-fl2v	—	$0.0540/s (768P, 6s)	$0.1060/s (1080P, 6s)
pixverse/v6-fl2v	$0.0805/s	$0.1035/s	$0.2070/s
pixverse/c1-fl2v	$0.0920/s	$0.1150/s	$0.2185/s

Rates per second, without audio, from the Modellix model pages on August 6, 2026. Hailuo 02 bills by duration/resolution pairs — 6s or 10s at 768P or 1080P ($0.0672/s at 10s/768P, $0.1200/s at 10s/1080P; 10s caps at 768P, 1080P caps at 6s) — so its row shows the 6s rates; PixVerse routes add an audio surcharge (~$0.023–$0.0575/s depending on quality).

A worked example with the assumptions stated: a 5-second 720p clip on pixverse/v6-fl2v is 5 × $0.1035 = $0.5175; the same clip on vidu/viduq3-turbo-fl2v is 5 × $0.0506 = $0.2530. Both are real task costs you can reproduce from the tables above — no credit-package conversion required.

Figure 2: 720p per-second rates across the Modellix FL2V routes, read from live model pages on August 6, 2026.

Two honesty notes on pricing. First, billing units differ across providers — Wan direct is per-second credits, aggregator model cards sometimes show a flat “from $0.4” figure that hides the duration, and credit packages on vendor platforms convert at package-dependent rates. A “cheaper” number only means something when the duration, resolution, and billing unit match. Second, the “free” search intent around FL2V mostly points at consumer tools (domoai, vidy, similar) that run free tiers on the web app; on the API side there is no free FL2V generation — the free angles are trial credits on vendor platforms and aggregator onboarding credits, both of which you should verify on the live console before relying on them.

Choosing an FL2V route: quality, speed, and integration

The right route depends on what your output has to be:

• Fastest and cheapest: Vidu Q3 Turbo FL2V. Its model page positions it for quick morphs and rapid storyboard filling — good for preview loops where you regenerate often.
• Cinematic quality: Vidu Q3 Pro FL2V or PixVerse v6 at 1080p. Pro is described as the premium tier for commercial transitions; PixVerse adds optional audio and up to 15s of output, which matters when a scene needs more than 8 seconds.
• Camera control and end-frame-only input: Hailuo 02 FL2V accepts 15 camera-control instructions in [Pan left]-style prompt syntax, and — uniquely among these routes — treats the first frame as optional, auto-generating it when you only supply a last frame (a live user need, per the Google forum thread that ranks for this query).
• Vendor-direct vs aggregator: Alibaba and Google document their FL2V APIs directly but with vendor-specific constraints (Wan’s region-locked endpoints and 24h URL validity, Veo’s platform requirements). Through an aggregator you trade vendor SDKs for one REST pattern, USD per-second billing, and — for Modellix specifically — access to the Chinese model families without needing a Chinese account. That last point is a real workflow difference, not a claim that any route is universally cheapest.

Modellix exposes all five dedicated FL2V routes above plus the Wan 2.7 first_frame + last_frame mode through one API key and one billing model. If you are evaluating routes for a product integration, the honest way to choose is: price your exact duration and resolution on the routes you qualify for, then weigh the operational cost of the integration path — which is precisely what the model pages and the providers directory let you do side by side.

FL2V vs the adjacent video APIs

FL2V sits in a family of video-generation APIs that get confused with each other. The decision rule is which inputs you actually have:

You have	API to use	What it returns
One image + prompt	Image-to-video (I2V)	Video animating from that image; the ending is the model’s choice
Two images (start + end) + prompt	FL2V (this guide)	Video interpolating a transition between the two frames
A video + prompt	Video extend	Continuation of the existing clip
Character/subject reference images + prompt	Reference-to-video (R2V)	New video preserving the reference subject(s)

The frequent real-world mistake is calling FL2V with a single image, or expecting FL2V to continue an existing clip — it does neither. For single-image animation, our image-to-video API guide covers the one-image pattern end to end; for continuation, the PixVerse video extend API guide walks through extending a clip rather than transitioning between frames.

Frequently Asked Questions

What is a first last frame video API?

A first-last-frame video API (FL2V, also FLF2V or start/end frames) takes two images — the start frame and the end frame — plus a text prompt, and generates a video that transitions from the first image to the last. The prompt controls the motion in between; the API is asynchronous (submit, poll, download).

Is FL2V the same as image-to-video?

No. Image-to-video animates a single starting image and lets the model decide the ending. FL2V constrains both the first and last frames, which makes it the right tool when the ending is part of the brief (before/after transitions, morphs, storyboard completion). Most FL2V routes require exactly two images.

Which AI video APIs support first and last frames?

As of August 2026: Alibaba Wan 2.1/2.2 (kf2v family) and Wan 2.7 (first-frame + last-frame mode), Google Veo 2 / Veo 3.1, Kling’s start & end frames mode, MiniMax Hailuo 02 FL2V, PixVerse v6/c1 FL2V, and Vidu Q3 Pro/Turbo FL2V. Aggregators (fal.ai, Segmind, Modellix) resell most of these behind one API.

Can I generate a video from only a last frame?

On most routes, no — both frames are required. MiniMax’s Hailuo 02 FL2V is the exception: its Modellix route treats the first frame as optional and auto-generates one when only a last frame is supplied. Last-frame-only conditioning is also a requested feature on Google’s side, where it is not yet supported.

How much does first-last-frame video cost?

FL2V is billed per second of output, tiered by resolution. On Modellix’s routes (2026-08-06), 720p ranges from $0.0506/s (Vidu Q3 Turbo) to $0.1150/s (PixVerse c1); 1080p ranges from $0.0598/s to $0.2185/s. A 5-second 720p clip costs roughly $0.25–$0.58 depending on the route.

Do the first and last frames need to be similar?

They need to be visually consistent — same subject, comparable composition and lighting, matching dimensions. Kling’s guide warns that large differences cause a visible “lens switch” instead of a smooth transition. The model interpolates; it does not rewrite the scene.

Is there a free FL2V API tier?

No mainstream FL2V API offers free generation. Consumer tools run free tiers on their web apps; API access is paid, with trial credits on some vendor platforms and aggregator onboarding credits — verify the current policy on the live console before building a workflow on it.

---

Provider details and pricing reflect public information as of August 2026 and change frequently. Validate against each provider’s live pricing before committing. Access image and video models from multiple providers, including Wan, Hailuo, PixVerse, and Vidu, through a single API key at modellix.ai.

Cover image: illustrative Modellix artwork; it is not a product screenshot or source evidence.