All posts
Video Generation API

Pika API: Your First Pika 2.2 Video in Minutes

Send your first Pika 2.2 request on each::labs: copy-ready curl and Python for text-to-video and image-to-video, the five settings that matter, polling and webhooks, prompts, and three builds for creators and app studios.

By Eftal Yurtseven · Nov 16, 2026 · 10 min read

Pika API: Your First Pika 2.2 Video in Minutes

One Pika clip is easy. You type a prompt in a browser tab and a few minutes later you have something worth posting. Forty clips by Friday, in three aspect ratios, each with a different hook, generated from inside your own app? That's a different job, and it's the job the Pika API is for.

On each::labs, Pika 2.2 runs as two endpoints behind the same prediction API as every other model in the catalog. This guide gets you from nothing to a downloaded MP4: a first text-to-video request you can paste into a terminal, then image-to-video, the five settings that change your output, how to poll for the result, prompts that suit Pika, and three builds that creators and mobile app studios actually ship.

What the Pika API Looks Like on each::labs

The Pika 2.2 family page holds two models, and you pick by what you start from. Pika 2.2 Text to Video (slug pika-v2-2-text-to-video) builds a clip from words alone. Pika 2.2 Image to Video (slug pika-v2-2-image-to-video) starts from a still you already own and moves it.

When Pika released 2.2 in early 2025, the headline upgrades were ten-second clips and 1080p output. Both show up in the API as plain fields, so there's no special mode to unlock. You'll need an each::labs key from the API keys page, and that's the only key involved: the same one runs Pika, Kling, Veo and everything else, so swapping models later is a change to one string.

Before you write any code, read the schema. The model detail endpoint is public, so this works without a key:

curl https://api.eachlabs.ai/v1/models/pika-v2-2-text-to-video

The response carries the full request_schema with every field, default and allowed value, plus the version string you'll send with each request. Treat it as the source of truth. Blog posts age; the schema doesn't lie.

One request is one sentence. Write it clearly once.
One request is one sentence. Write it clearly once.

Send Your First Pika Text-to-Video Request

Every each::labs model follows one pattern. You POST a prediction with a model slug, a version and an input object, get back an ID, then fetch the result when it's done. Your key goes in a Bearer header. Paste this, swap in your key, and run it:

curl -X POST https://api.eachlabs.ai/v1/prediction \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "pika-v2-2-text-to-video",
    "version": "0.0.1",
    "input": {
      "prompt": "Handheld phone footage of a young woman in an oversized grey sweatshirt on a sofa, she glances up from her phone and laughs in surprise, warm lamp light, natural colors",
      "aspect_ratio": "9:16",
      "duration": 5,
      "resolution": "720p"
    },
    "end_user_id": "usr_4f9a2c"
  }'

Three of those top-level fields need a word. The version is whatever the model detail endpoint returns, and both Pika endpoints report 0.0.1 today. The input object is the model's own schema; only prompt is required for text-to-video. And end_user_id is required on every prediction: a stable, pseudonymous ID for the real person the video is for, the same ID every time for the same person. Use your internal user ID or a hash of it, never an email or a name. For a batch job with nobody behind it, the each::labs end-user ID rules describe a job ID built from the owning employee's ID and the job name.

The API answers straight away:

{
  "status": "success",
  "message": "Prediction created successfully",
  "predictionID": "abc123-def456-ghi789"
}

Don't celebrate yet. That "success" means the job was accepted. The video comes next.

The answer comes back later. Plan the wait into the code.
The answer comes back later. Plan the wait into the code.

Poll for the Video, or Let a Webhook Call You

Fetch the prediction by its ID:

curl https://api.eachlabs.ai/v1/prediction/abc123-def456-ghi789 \
  -H "Authorization: Bearer YOUR_API_KEY"

The status moves through created, starting and processing until it lands on success, or on a failure state (error or failed) or cancelled. On success, output holds the video URL, metrics.predict_time tells you how long the render took, and on a failure logs tells you why. A video takes longer than an image, so polling every five seconds is plenty.

Here's the whole loop in Python, written so you can drop it into a script and call it for either Pika model:

import os, time, requests

API = "https://api.eachlabs.ai/v1/prediction"
HEADERS = {
    "Authorization": f"Bearer {os.environ['EACHLABS_API_KEY']}",
    "Content-Type": "application/json",
}

def run_pika(model, inputs, end_user_id):
    r = requests.post(API, headers=HEADERS, json={
        "model": model,
        "version": "0.0.1",
        "input": inputs,
        "end_user_id": end_user_id,
    })
    r.raise_for_status()
    prediction_id = r.json()["predictionID"]

    while True:
        data = requests.get(f"{API}/{prediction_id}", headers=HEADERS).json()
        if data["status"] in ("success", "error", "failed", "cancelled"):
            break
        time.sleep(5)

    if data["status"] != "success":
        raise RuntimeError(data.get("logs") or data["status"])
    out = data["output"]
    return out if isinstance(out, str) else out[0]

url = run_pika(
    "pika-v2-2-text-to-video",
    {"prompt": "Aerial shot gliding over a foggy pine forest at sunrise, slow forward dolly",
     "aspect_ratio": "16:9", "duration": 5, "resolution": "720p"},
    end_user_id="usr_4f9a2c",
)
print(url)

To keep the file, download it like any other URL: curl -L "$URL" -o pika.mp4.

Polling is fine for a script. In production, add webhook_url to the create request and each::labs posts the finished prediction to your server. Add webhook_secret too, and every delivery carries an X-Webhook-Signature (an HMAC-SHA256 over the X-Webhook-Timestamp value, a dot and the raw body) that lets you reject anything that didn't come from us.

Animate a Still With Pika Image-to-Video

Image-to-video needs two things: image_url and prompt. The image has to be reachable by URL. If it lives on your laptop, upload it first. Ask for an upload slot:

curl -X POST https://api.eachlabs.ai/v1/upload/presign \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content_type": "image/png", "file_type": "image"}'

The response gives you a presigned_url, a public_url and a set of required_headers. PUT the raw file bytes to the presigned URL with those headers exactly as returned (the slot is open for 15 minutes), then pass the public_url to Pika:

{
  "model": "pika-v2-2-image-to-video",
  "version": "0.0.1",
  "input": {
    "image_url": "https://cdn-us.eachlabs.ai/uploads/your-still.png",
    "prompt": "Slow push in, steam curls up from the cup, morning light drifts across the table, background stays still",
    "duration": 5,
    "resolution": "1080p"
  },
  "end_user_id": "usr_4f9a2c"
}

Notice what's missing: image-to-video has no aspect_ratio field. The frame you send is the frame Pika starts from, so crop the still to the shape you need before you upload it. A 1080 by 1920 still for Reels, a square one for the feed. Doing the crop yourself beats hoping the model guesses which part of a landscape photo matters.

Five dials decide the clip. The rest is taste.
Five dials decide the clip. The rest is taste.

The Pika API Settings That Actually Matter

The schema is short, which is a gift. Five fields do all the work.

duration takes the integer 5 or 10, and defaults to 5. Short clips loop better and are quicker to judge, so draft at 5 and only ask for 10 when the action really needs the room.

resolution is 720p by default or 1080p. Draft at 720p, then rerender the keepers at 1080p. Most ideas die at the draft stage anyway, so don't give every one the full treatment.

aspect_ratio (text-to-video only) is a plain text field that defaults to 16:9, so a request that leaves it out comes back landscape. Set it explicitly every time, and render one test clip in the shape you need before you build a batch around it. A default you forgot about is how a whole batch comes back sideways.

negative_prompt lists what to keep out. On text-to-video it defaults to ugly, bad, terrible, and the moment you send your own, that default no longer applies, so fold general terms into yours. On image-to-video there's no default at all. Short and specific works best: text, watermark, extra fingers, flicker.

seed is the field people ignore and shouldn't. Leave it empty and every run rolls fresh. Fix it and you can change one word in the prompt and see exactly what that word did. When a 720p draft is the one, rerun it at 1080p with the same seed and prompt, so resolution is the only thing you changed.

One more thing to plan around: Pika 2.2 clips come back as silent MP4s at 24fps. For app previews and feed ads that autoplay muted anyway, that's the right default. Add music or a voiceover in the edit.

Write Prompts Pika Can Act On

Pika's own guidance is refreshingly plain: say who is in the scene, what they're doing and how it should look, covering subject, action, setting, lighting and style, and name the camera move. Its example is "a slow push toward a raccoon at a tiny desk". Then change one thing at a time when you refine.

Two habits get you most of the way. Lead with a strong verb and a specific action, and name one simple camera move: Pika 2.2 reads moves like "zoom in" or "pan left" reliably, while a paragraph of scenery gives it nothing to move. And for image-to-video, describe the motion, not the picture. The still already shows what's there. Your prompt only has to say what changes. (We wrote a whole post on writing image-to-video prompts around the motion.)

Copy these as starting points. For a vertical UGC-style hook:

Handheld phone footage, a man in a baggy navy sweatshirt sits at a kitchen table, reads something on his phone, looks straight into the camera and raises his eyebrows, morning window light, slight camera shake

For a product still (image-to-video):

Slow push in on the bottle, condensation runs down the glass, soft light moves across the marble, everything else stays still

For an app mascot or key art (image-to-video):

The fox character waves, then hops once toward the camera, bouncy cartoon motion, static camera, bright flat colors

For a cinematic establishing shot:

Aerial shot gliding over a foggy pine forest at sunrise, golden light breaking through the mist, slow forward dolly, 35mm film look

For food content:

Close-up of a bowl of ramen, chopsticks lift a tangle of noodles, steam rises, shallow depth of field, slow pan left
One still, ten motions. Ship the one that sells.
One still, ten motions. Ship the one that sells.

Three Pika API Builds for Creators and App Studios

A working request is the start. These are the three jobs we'd point a Pika integration at first.

Store and ad openers from your key art

Mobile app studios already own the asset Pika needs: the app icon character, the hero illustration, the onboarding art. Crop it to 9:16, send it to image-to-video with a short, bouncy action prompt, and you have the two-second hook that plays before the screen recording in a promo video or a paid social ad. Because the clip is silent, it drops straight into an edit that already has your sound. Run five actions on the same art and let the ad test pick the opener.

UGC-style hook variations in one batch

Creators and growth teams live on hooks. Write ten opening lines as ten prompts, all 9:16 and 5 seconds at 720p, and loop the Python function above over them. Keep the seeds of the ones that land, rerender those at 1080p, and cut them onto your real footage. If you want the full production line around it (scripts, talking heads, captions), our guide to building a UGC video factory with AI shows how the pieces connect.

Product stills that move

Ecommerce and app-commerce teams have hundreds of product photos and almost no motion. Point image-to-video at each one with a restrained prompt (push in, light shifts, one small physical detail like steam or condensation) and keep the background still so the product stays the hero. When the chain works, move it out of your scripts folder and into each::labs AI Flows, where a text-to-image step can make the still, Pika can animate it, and the whole thing runs from one trigger.

And if Pika's look isn't right for a particular shot, nothing about your integration has to change. Browse the other text-to-video models and image-to-video models, swap the slug and the input fields, and run the same prompt side by side. For the background on what 2.2 changed, see our post on Pika v2.2, and for Pika's own app, visit pika.art.

Frequently Asked Questions

Does Pika have an API?

On each::labs, Pika 2.2 is a regular API model. You POST a prediction to https://api.eachlabs.ai/v1/prediction with pika-v2-2-text-to-video or pika-v2-2-image-to-video as the model, then fetch the result by its prediction ID or receive it on a webhook.

Do I need a separate Pika API key?

No. Your each::labs key, sent as Authorization: Bearer YOUR_API_KEY, runs Pika and every other model in the catalog. Changing models means changing the model slug and the input fields, nothing else.

What models and endpoints does the Pika API offer on each::labs?

Two today, both Pika 2.2. Text to Video takes a prompt plus optional aspect ratio, duration, resolution, negative prompt and seed. Image to Video takes an image_url and a prompt, with the same options minus aspect ratio. The Pika page always lists what's current.

How long and how sharp can a Pika 2.2 video be?

Clips run 5 or 10 seconds, at 720p or 1080p, and come back as silent MP4 files. For anything longer, generate several shots and cut them together in your editor, which also gives you control over pacing that a single long take never would.

Start with what you need.

Scale when you’re ready.