Dark amber cover: MODELLIX wordmark, two-line title PixVerse First-Last Frame API / Integration Guide & Code, 2 FRAMES · ONE VIDEO capsule

The short answer: PixVerse FL2V is a two-frame transition API

The PixVerse first-last frame API — officially the “Transition (First-last frame)” feature — generates a video between two images you provide: a start frame and an end frame, plus a prompt describing the transition. It is a single asynchronous endpoint, POST /openapi/v2/video/transition/generate, and it follows the same submit–poll–retrieve loop as PixVerse’s text-to-video and image-to-video APIs, with one extra prerequisite: both frames must be uploaded first so you can pass their img_id values.

Before the code, one terminology note, because the SERP mixes names for the same capability. PixVerse’s official Transition (First-last frame) guide calls it “Transition” or “First-last frame Feature”; the API reference names the endpoint “Transition(First-last frame) generation”; and the developer community — plus aggregator model cards — shortens it to FL2V (first-last-to-video), “Start-End-to-Video”, or “keyframe-to-video”. They are the same feature. Everything in this guide was read from the official pages on August 6, 2026; PixVerse iterates on parameters and prices quickly, so treat anything model- or price-specific as current as of that date.

What you need before you call it

The prerequisites match the rest of the PixVerse Platform API:

  • A valid API key, sent in the API-KEY header.
  • A unique Ai-Trace-Id per request — a UUID. The official docs flag reused trace ids as the most common cause of tasks stuck in “Generating”.
  • An active subscription with API credits. The API bills against your Platform credit balance; the web app’s free trial does not apply.
  • Two images — a first frame and a last frame — uploaded through the platform’s media API so you get an img_id for each. The official upload documentation requires png / webp / jpeg / jpg, files under 20MB, and dimensions up to 10000 pixels.
  • A model choice. The current family is V6 and C1 (both support first-last-frame with 1–15 second durations); the older ladder — V3.5/V4/V4.5, V5, V5.5/V5.6 — also supports it with shorter fixed durations. Details in the next section.

If you are new to the submit–poll–retrieve loop itself — keys, trace ids, and polling — our PixVerse API integration guide walks through authentication and the general pattern end to end.

Uploading your first and last frame images

FL2V needs both frames to exist on PixVerse’s side before generation. Upload each image with POST /openapi/v2/image/upload, sending the file as multipart/form-data:

1
2
3
4
curl --location --request POST 'https://app-api.pixverse.ai/openapi/v2/image/upload' \
  --header 'API-KEY: YOUR_PIXVERSE_API_KEY' \
  --header 'Ai-Trace-Id: '"$(uuidgen)" \
  --form 'image=@/path/to/first-frame.jpg'

The response returns the img_id you will pass to the generation endpoint:

1
2
3
4
5
6
7
8
{
  "ErrCode": 0,
  "ErrMsg": "",
  "Resp": {
    "img_id": 123456789,
    "img_url": "https://..."
  }
}

Two caveats from the official docs. First, the feature guide warns that URL-based image uploads are currently not supported — use the file path form even though the upload API reference still documents an image_url field. Second, uploads go through moderation: a rejected image returns an error such as 500052 (“image failed moderation”), and you must re-upload a compliant file before generating. Upload both frames, keep both img_id values, and move to the generation call.

Calling the PixVerse first-last frame API: parameters and code

The request goes to https://app-api.pixverse.ai/openapi/v2/video/transition/generate with API-KEY, Ai-Trace-Id, and Content-Type: application/json headers. The official parameter set, from the generation API reference:

Parameter Required Notes
prompt Yes ≤ 5000 characters; describes the transition process
model Yes v3.5, v4, v4.5, v5, v5.5, v5.6, v6, or c1
duration Yes V6/C1: 1–15; V5: 5/8; V5.5/V5.6: 5/8/10; V3.5/V4/V4.5: 5/8 (1080p caps at 5)
quality Yes 360p, 540p, 720p, 1080p
first_frame_img Yes img_id from the image upload response
last_frame_img Yes img_id from the image upload response
seed No int, 0–2147483647
generate_audio_switch No true/false, default false; supported on V5.5/V5.6/V6/C1

The two official pages disagree on one detail worth knowing: the feature guide’s parameter list still shows motion_mode and only models v3.5/v4/v4.5, while the generation API reference and the V6 model overview list the full model ladder and no motion_mode. When in doubt, follow the API reference for accepted values — it is the endpoint’s own schema, and it is the page that documents V6/C1 support with 1–15 second durations.

Note also what the official endpoint does not take: there is no aspect_ratio, camera_movement, or style parameter in the transition schema. Those controls exist on the V6-native and aggregator routes (which accept frame URLs directly) — the route comparison later in this guide covers that difference.

A minimal curl call, following the official example structure:

1
2
3
4
5
6
7
8
9
10
11
12
13
curl --location 'https://app-api.pixverse.ai/openapi/v2/video/transition/generate' \
  --header 'Ai-Trace-Id: '"$(uuidgen)" \
  --header 'API-KEY: YOUR_PIXVERSE_API_KEY' \
  --header 'Content-Type: application/json' \
  --data '{
    "prompt": "The car transforms into a spaceship, metallic panels sliding apart as it lifts off",
    "model": "v6",
    "duration": 5,
    "quality": "720p",
    "first_frame_img": 123456789,
    "last_frame_img": 987654321,
    "seed": 937433858
  }'

The equivalent in Python with the standard library:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import json
import uuid
import urllib.request

def generate_fl2v(first_frame_img, last_frame_img, prompt, api_key,
                  model="v6", duration=5, quality="720p", seed=None):
    body = {"prompt": prompt, "model": model, "duration": duration,
            "quality": quality, "first_frame_img": first_frame_img,
            "last_frame_img": last_frame_img}
    if seed is not None:
        body["seed"] = seed
    req = urllib.request.Request(
        "https://app-api.pixverse.ai/openapi/v2/video/transition/generate",
        data=json.dumps(body).encode(),
        headers={
            "API-KEY": api_key,
            "Ai-Trace-Id": str(uuid.uuid4()),
            "Content-Type": "application/json",
        },
    )
    with urllib.request.urlopen(req) as resp:
        return json.load(resp)  # {"ErrCode": 0, "Resp": {"video_id": ...}}

The response contains the new task’s video_id — generation is asynchronous, so no video exists yet at this point.

PixVerse FL2V workflow: first and last frame images, upload via /openapi/v2/image/upload, transition/generate, poll status, MP4 download

Figure 1: The PixVerse first-last frame flow — upload both frames, call transition/generate, poll status until it reaches 1, then download. Diagram generated from the official Transition documentation on August 6, 2026.

Polling for the result and handling failures

Query the video status endpoint with the returned video_id until it leaves processing:

Status Meaning
5 Waiting for generation — poll at 3–5 second intervals
1 Generation successful — the response contains the url of the finished video
7 Failed content moderation — adjust parameters and retry; credits are refunded automatically
8 Generation failed — check the official error-code list for the specific cause 
1
2
3
curl --location 'https://app-api.pixverse.ai/openapi/v2/video/result/YOUR_VIDEO_ID' \
  --header 'API-KEY: YOUR_PIXVERSE_API_KEY' \
  --header 'Ai-Trace-Id: '"$(uuidgen)"

The failure cases that cost integrators the most time:

  • Task stuck in “Generating”. The official FAQ names a duplicate Ai-Trace-Id as the first thing to check — it explicitly warns that reusing one means you won’t get a new video. Generate a fresh trace id per request, including per poll.
  • “Couldn’t find a matching img_id”. The frame was never uploaded, the upload was rejected, or the id belongs to a different media type. Re-upload and confirm both img_id values before generating.
  • Image moderation rejection (500052). The upload endpoint returns this when a frame fails review; the fix is a compliant re-upload, not a retry of the same file.
  • Weak or jittery morphs. FL2V interpolates between your two frames; if they are visually dissimilar or composed differently, the transition degrades. Matched composition, lighting, and framing between the two frames is the single biggest lever for a smooth transition between first frame and last frame.

The polling loop is identical to the one PixVerse uses for its other video endpoints — if you have already integrated the PixVerse video extend API guide, the status handling here is copy-paste compatible.

One billing surprise: credits are consumed at submission, so a moderation failure (7) can look like a charge for nothing. The FAQ confirms credits are refunded automatically for failed generations — verify it in your balance history before contacting support.

What the PixVerse first-last frame API costs

PixVerse bills FL2V in Platform credits, and the pricing page splits the family into two billing models — this is where most cost estimates go wrong. V6 and C1 are billed per second; the older versions (V5.5, V5, V4.5/V4/V3.5) are billed per clip at fixed durations.

Per-second rates for V6 and C1 (read from the official pricing page on August 6, 2026):

Model Quality No audio With audio
V6 360p 5/s 7/s
V6 540p 7/s 9/s
V6 720p 9/s 12/s
V6 1080p 18/s 23/s
C1 360p 6/s 8/s
C1 540p 8/s 10/s
C1 720p 10/s 13/s
C1 1080p 19/s 24/s

Per-clip rates for the older ladder (no audio): V5.5 runs 45 credits (5s), 90 (8s), 99 (10s) at 360p/540p, 60/120/132 at 720p, and 120/240 at 1080p (no 10s at 1080p). V5 and V4.5/V4/V3.5 run 45 (5s) and 90 (8s) at 360p/540p, 60/120 at 720p, and 120/240 at 1080p. The V4.5-family fast motion mode doubles the 5-second rate.

Worked example: a 5-second 720p FL2V on V6 with no audio is 9 credits/s × 5s = 45 credits. The pricing page’s own reference line is “$1 = 5 videos (v6, 720p, 5s, no audio, with Starter pack)” — that implies roughly 225 credits per dollar at the Starter-pack rate, which would put 45 credits around $0.20. That conversion is package- and promotion-dependent; do not treat it as a universal exchange rate. The correct calculation for your budget is: divide the price of the credit package you actually buy by its credit count, then multiply by the per-second (or per-clip) figure above. For a full walkthrough of the credit system and subscription plans, our PixVerse pricing breakdown covers the official tables side by side.

Direct API vs an aggregator route

The PixVerse first-last frame API is available directly, and it is also resold by aggregators — atlascloud, eachlabs, Magnific (Freepik), and others rank for this query with FL2V/transition model cards. Modellix is an API aggregator and has a commercial interest in this comparison; the route comparison below is the one we would want before choosing either path.

Before comparing any two numbers, line up the billing units: direct PixVerse bills in credits (per second on V6/C1, per clip on older models), while aggregators bill in USD per second with their own model routing. A credit price and a dollar price are not the same unit, and “the cheapest” changes with the credit package you would have bought anyway.

The more structural difference is the input model. Direct PixVerse requires the upload step: form-data upload → img_id integers in the payload. Aggregator routes — including the pixverse/v6-fl2v route — accept image URLs directly in the request body. If your frames already live behind URLs (a content bucket, a previous generation step), that removes the upload-and-store step entirely. The v6-fl2v model page showed the following per-second prices on August 6, 2026:

Quality No audio With audio
360p $0.0575/s $0.0805/s
540p $0.0805/s $0.1035/s
720p $0.1035/s $0.1380/s
1080p $0.2070/s $0.2645/s

So a 5-second 720p no-audio FL2V on the v6-fl2v route is 5 × $0.1035 = $0.5175, versus ~$0.20 at the direct Starter-pack rate — direct credits can win on raw price when you commit to a package, while the aggregator wins on integration surface (no upload step, no credit math, predictable USD per second) and on being one key among the other models on the platform. The honest recommendation is the same as for any PixVerse endpoint: price a representative task in both units using your actual credit package, then add the operational cost of the integration path. The older C1 FL2V route is also available as pixverse/c1-fl2v for those standardizing on the C1 family.

Frequently Asked Questions

What is the first frame to last frame video generator? It is a video model mode that takes two images — a first frame and a last frame — plus a prompt, and generates the video connecting them. PixVerse exposes it as the “Transition (First-last frame)” feature at POST /openapi/v2/video/transition/generate. The sibling guide to this one, First Last Frame to Video API, covers the concept and the multi-provider landscape more generally.

How long can a PixVerse first-last frame video be? On V6 and C1, 1–15 seconds per task. Older models cap at 5/8 seconds (V3.5/V4/V4.5, V5) or 5/8/10 seconds (V5.5/V5.6), with 1080p restrictions on the longest durations. Each task bills separately; chaining calls to extend a story re-enters the queue each time.

Why is my PixVerse first-last frame video not working? The most common causes, in order: a reused Ai-Trace-Id (stuck in “Generating”), a first_frame_img/last_frame_img id that failed upload or moderation, two frames too dissimilar to interpolate cleanly, and a zero credit balance. The upload endpoint’s 500052 error means the image was rejected — re-upload a compliant file rather than retrying the same one.

Is there a free way to use the PixVerse FL2V API? Not on the API side — it requires an API key and an active subscription with credits. The web app’s free tier does not apply to the Platform API. The one automatic refund is for moderation failures (status 7), per the official docs.

Can I use image URLs instead of uploading frames? On the direct PixVerse API, the feature guide says URL uploads are currently not supported — you upload files and pass img_id values. Aggregator routes such as the pixverse/v6-fl2v route accept frame image URLs directly, which is the main integration-surface difference between the two routes.

All PixVerse facts, parameter tables, and credit prices above were read from the official Transition (First-last frame) guide, generation API reference, upload documentation, status documentation, pricing page, and V6 model overview on August 6, 2026; the v6-fl2v price table was read from the model page the same day. Pricing and parameters change frequently — validate against the live pages before committing budget. Access image and video models from 12 providers, including PixVerse, through a single API key at modellix.ai.

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