Pika Labs built its reputation on short, stylised clips that hold up on a phone screen, and the API is the part most people miss. There is no first-party endpoint on pika.art. Instead, the Pika model family is served through fal.ai, which means you get a plain REST interface, per-call billing, and the same job pattern you would use for any other hosted generator. If you already produce stills with FLUX and want them to move, this is one of the shorter paths from a rendered frame to a finished clip, and it sits right next to the image-to-video routes we have covered before.

This guide covers what the Pika Labs API actually exposes, what each call costs, how the request and polling cycle works, and where Pika is the right pick versus the other video models you can reach the same way. Everything below is written from the current fal model cards for Pika 2.2, Pika Scenes, and Pika Effects, and it follows the same evaluation angle as our comparison of hosted generation APIs.

What the Pika Labs API actually exposes

Pika is not one endpoint. It is a small family of models, each with its own model ID, and you pick the one that matches the shape of your input. Text-to-video takes a prompt and nothing else. Image-to-video takes a starting frame, which is the variant most useful if your pipeline already ends in a FLUX render or a Seedance handoff from a still.

The models you can call today:

• Pika 2.2 text-to-video (fal-ai/pika/v2.2/text-to-video) : up to 1080p, 5 to 10 seconds, seven aspect ratios including 16:9, 9:16, 1:1 and 4:5. This is the current quality flagship and the one to reach for on general text-to-video work.
• Pika 2.1 text-to-video: 720p only, cheaper, faster. Useful for draft passes.
• Pika Scenes 2.2: image-to-video, built around animating an asset you supply rather than inventing the whole frame.
• Pika Effects 1.5: image-to-video with preset stylisation controls, priced low enough to run in bulk.

The split matters more than it looks. Scenes and Effects preserve your input frame far more faithfully than a text prompt ever will, so if brand accuracy is the point, generate the frame first with something like FLUX 1.1 Pro and let Pika handle only the motion.

What each call costs

Pricing is per clip, not per subscription seat, and it is low enough that iteration is not the expensive part of the job. The structure will look familiar if you have costed out FLUX Pro API calls, just with video-shaped numbers.

Model	Resolution	Duration	Price per 5s clip
Pika 2.2 text-to-video	1080p	5-10s	$0.45
Pika 2.2 text-to-video	720p	5-10s	$0.20
Pika 2.1 text-to-video	720p	5s	$0.20
Pika Effects 1.5	image-to-video	short	$0.039

Billing runs monthly on a pay-as-you-go basis, so an idle month costs nothing. Rate limiting sits at roughly 20 generations per minute across the account, which is generous for a single app but tight if you are fanning out a batch job, and it is the same ceiling you have to plan around when running generation in bulk over an API.

Compared against the other hosted video models, Pika lands in the cheap-and-stylised bracket rather than the photoreal-and-expensive one. A 1080p Pika clip at $0.45 undercuts most of the tiers listed in the current Veo pricing and example breakdown by a wide margin, and the tradeoff is exactly what you would expect: less physical realism, more character.

Making the call

The request pattern is the standard fal queue: you submit, you get a request ID, and you poll until the job reports completed. Nothing about Pika needs a special client, which is why it drops into an existing pipeline cleanly. If you have already wired up any other hosted model, the shape here will be familiar from building pipelines over plain REST.

Submit the job:

curl -X POST https://queue.fal.run/fal-ai/pika/v2.2/text-to-video \
  -H "Authorization: Key $FAL_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a lone lighthouse in heavy fog, slow push in, moody cinematic light",
    "negative_prompt": "text, watermark, distorted hands",
    "aspect_ratio": "16:9",
    "resolution": "1080p",
    "duration": 5
  }'

That returns a request_id. Poll the status endpoint until it flips to COMPLETED, then fetch the result to get an MP4 URL. Do not sleep-loop tightly on it; a 5 second interval is plenty, and a 10 second clip will not come back faster than the model renders it. The same polite polling discipline applies to every queued generator, including the Kling endpoints.

curl https://queue.fal.run/fal-ai/pika/requests/$REQUEST_ID/status \
  -H "Authorization: Key $FAL_KEY"

For the image-to-video variants, swap the model ID for fal-ai/pika/v2.2/pikascenes and pass an image_url alongside the prompt. The image has to be publicly reachable, so upload your FLUX render somewhere addressable first. Prompt phrasing still matters here even though the frame is fixed: motion verbs do the work, and a prompt generator is a reasonable place to start if your motion descriptions keep coming back flat.

Where Pika fits next to the alternatives

Pika is rarely the only model in a production pipeline. Most teams end up calling two or three, choosing by shot rather than standardising on one, because each model fails differently. Pika holds stylised motion and character work well and struggles with hard physical realism; Kling is stronger on human movement; Veo is the expensive photoreal option. That is also why routing tends to move up a layer, and tools like Wireflow now run Pika alongside other video models behind one queued API so a failed or capacity-limited call falls through to a second model rather than dropping the job.

The practical selection rules, in short:

• Short social cutdowns, stylised motion, character-led shots: Pika 2.2, 1080p.
• Draft and thumbnail passes before committing budget: Pika 2.1 at 720p, or Effects at four cents a clip.
• Realistic human motion and dialogue-adjacent shots: look at the Kling 2.5 developer walkthrough instead.
• Product and landscape work where physics has to read correctly: Veo, at Veo’s price.

A useful habit is to treat model choice as per-shot metadata in your own job records rather than a global config value. Once you store the model ID with each generated clip, swapping one out later is a data change, not a refactor, and you can compare hit rates across the field the way the 2026 model roundup does.

A FLUX-to-Pika workflow that holds up

The reason this pairing works is that each model does the thing it is actually good at. FLUX gives you exact control of composition, lighting and product accuracy in a still. Pika gives you motion. Trying to get both out of a single text-to-video call is how you end up with twelve rejected clips and a warped logo, a failure mode familiar to anyone who has run programmatic video generation at volume.

The sequence:

1. Generate the key frame in FLUX at the exact aspect ratio you need for the clip. Match it to Pika’s supported ratios up front so nothing gets cropped later.
2. Upload the frame to public storage and keep the URL.
3. Call Pika Scenes with that image_url and a motion-only prompt: what moves, in what direction, how fast. Leave the scene description out, since the frame already has it.
4. Poll, retrieve, and store the MP4 alongside the source frame and the request ID.
5. Regenerate only the motion prompt on failures. The frame does not need to change.

Keeping the frame fixed across retries is the single biggest cost saver, because a still costs a fraction of a clip and stays consistent across every attempt. It is the same discipline that makes node-based API platforms workable at volume: pin the deterministic steps, retry only the stochastic one.

FAQ

Is there an official Pika Labs API?

Not a first-party one on pika.art. Access is through fal.ai, which hosts the Pika model family behind standard REST endpoints, the same way it hosts FLUX models and other generators.

How much does the Pika API cost per video?

A 5 second 1080p clip from Pika 2.2 is $0.45, and the 720p version is $0.20. Pika Effects image-to-video is $0.039 per clip, which is cheap enough to use for exploratory passes.

What is the maximum clip length?

Pika 2.2 generates 5 to 10 seconds per call. Longer sequences come from generating multiple clips and joining them, which is also how most image-to-video pipelines handle anything past ten seconds.

Can I feed a FLUX image into Pika?

Yes, through the Scenes or Effects image-to-video variants. Pass a publicly reachable image_url and keep the prompt focused on movement rather than re-describing the scene.

What are the rate limits?

Around 20 generations per minute per account. That is fine for interactive use and tight for batch jobs, so queue your own work rather than firing everything at once, the same way you would throttle a drag-and-drop API pipeline.

Does the API allow commercial use?

Yes. The hosted Pika models carry commercial-use rights, though you should still check the current model card before shipping client work, since terms differ per model across the wider set of hosted video APIs.

Which Pika model should I default to?

Pika 2.2 at 720p for iteration, then a single 1080p regeneration of the take you are keeping. Paying the higher rate only on finals is usually a two-thirds saving over a session, and the same draft-then-finalise pattern works for AI marketing video work.

Wrapping up

The Pika Labs API is a small surface with a clear job: cheap, stylised motion, delivered through a plain queued REST call. It is not the model to reach for when a shot has to survive close inspection, and it is a very good one when the clip has to look distinctive and ship today. Pair it with a FLUX still for anything where composition and brand accuracy matter, keep the frame fixed across retries, and store the model ID with every clip so you can move to a different generator later without rebuilding anything.