Pika API Guide: Setup, Pricing & Your First Request

What is the Pika API?

“Generate video, image, audio, music and speech with 100+ leading models from every major lab, through one API key at member pricing.”

Pika sells it as the Pika API Club: “a membership program that provides access to top gen media models at previously impossible prices, all through one API.” It’s separate from the Pika app you use at pika.art, with its own account, dashboard and billing at dev.pika.art.

Sources: Pika API homepage and Pika API llms.txt.

Pika API pricing

Pricing has two parts: a membership fee and pay-as-you-go usage. From Pika’s FAQ:

• “Membership is $10/month and unlocks member (wholesale) pricing.”
• “New members get a $10 credit toward their first month of usage.”
• “Beyond the flat membership fee, model usage is pay-as-you-go.”
• “You can cancel anytime.”

Usage is prepaid: Pika’s docs say “There is no free generation tier and no separate test environment,” and a request fails with insufficient_balance until your account has funds.

Pika 2.5 prices are from its catalog entry; MiniMax H3 is from the homepage comparison, which notes “Prices recorded as of 9.18.26. Includes 5% platform fee.” The 5-second column is our arithmetic. The Pika 2.5 spec adds: “Only successful generations are charged.” Prices change, so check the API pricing page before building a budget.

Pika also claims the API Club is “up to 88% cheaper than other API aggregators’ model prices,” while noting it “can’t guarantee we’re going to be the cheapest on every single model vs. every competitor.” Team and enterprise plans are available through Pika’s enterprise page.

API pricing is separate from Pika app subscriptions; for those, see Pika pricing.

Which models can you call?

Pika’s llms.txt lists “155 callable operations,” and notes that “a model can appear more than once when it supports multiple functions.” Highlights by category:

Browse the live list on Pika’s models page, which also has a playground for each model. Model guides on this site: video models, image models and audio models.

Setup in four steps

Pika says: “Onboarding is self-serve end to end. No sales contact, no waitlist, no manual provisioning.”

1. Create an account at dev.pika.art/login. Signing in creates your organization.
2. Generate an API key at dev.pika.art/keys, where keys are also rotated and revoked.
3. Add funds at dev.pika.art/billing.
4. Test the connection with the free catalog: GET https://api.dev.pika.art/catalog/apis.

Store the key as an environment variable. Pika recommends the name PIKA_API_KEY:

export PIKA_API_KEY="your-key-here"

How requests work

The base URL is https://api.dev.pika.art. Authenticate with X-API-Key: $PIKA_API_KEY or Authorization: Bearer $PIKA_API_KEY. Media jobs are asynchronous: the submit call returns a job with an id and status, and you poll “until status is completed or failed.”

Pika’s docs stress that the live catalog is the source of truth: “Do not infer endpoint paths, request fields, enum values, pricing, or model support from a model name or from prior knowledge.” Check the catalog entry before writing code for any model.

Your first request: Pika 2.5 text-to-video

Pika 2.5 text-to-video takes a required prompt, plus optional resolution (720p or 1080p, default 1080p), seed and negative_prompt. Duration is fixed: “5s only for text-to-video.”

1. Check the price (free)

curl https://api.dev.pika.art/catalog/apis/pika/pika-2.5/text-to-video?expand=inputs

2. Check your balance (free)

curl https://api.dev.pika.art/billing/balance \
  -H "X-API-Key: $PIKA_API_KEY"

Amounts are in micro-USD: divide balance_micro_usd by 1,000,000 to get dollars.

3. Submit the job

curl -X POST https://api.dev.pika.art/v1/media/pika/pika-2.5/text-to-video \
  -H "X-API-Key: $PIKA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A paper boat drifts down a rain-filled gutter, low angle close to the water, soft grey daylight",
    "resolution": "720p",
    "duration_s": 5
  }'

At the listed $0.04 per second, this 720p, 5-second test should cost about $0.20.

4. Poll until it finishes

curl https://api.dev.pika.art/v1/media/jobs/REQUEST_ID \
  -H "X-API-Key: $PIKA_API_KEY"

5. Download the video

A completed job looks like this in Pika’s spec (shortened):

{
  "id": "media_8f3a2c91-...",
  "status": "completed",
  "output": {
    "media_type": "video",
    "video": {
      "url": "https://api.dev.pika.art/v1/files/video_8f3a2c91.mp4",
      "content_type": "video/mp4"
    }
  },
  "billing": { "state": "settled", "charge_micro_usd": ... }
}

Download output.video.url and save it to your own storage. Record spend from billing.charge_micro_usd only when billing.state is settled.

The same request in Python

A minimal script of our own, based on Pika’s spec. Run it on a server or your computer, never in a browser.

import os, time, requests

BASE = "https://api.dev.pika.art"
HEADERS = {"X-API-Key": os.environ["PIKA_API_KEY"]}

job = requests.post(
    f"{BASE}/v1/media/pika/pika-2.5/text-to-video",
    headers=HEADERS,
    json={
        "prompt": "A paper boat drifts down a rain-filled gutter, soft grey daylight",
        "resolution": "720p",
        "duration_s": 5,
    },
    timeout=60,
).json()

job_id = job["id"]
while job["status"] not in ("completed", "failed"):
    time.sleep(10)
    job = requests.get(f"{BASE}/v1/media/jobs/{job_id}",
                       headers=HEADERS, timeout=60).json()

if job["status"] == "completed":
    url = job["output"]["video"]["url"]
    with open("pika-test.mp4", "wb") as f:
        f.write(requests.get(url, timeout=300).content)
    print("Saved pika-test.mp4")
else:
    print("Job failed:", job)

For production, add error handling, and send an Idempotency-Key header so retries don’t create duplicate paid jobs. Pika warns: “Never reuse an idempotency key with a different body.”

Using your own images, video or audio

For image-to-video and other operations that take a file:

1. Request an upload with POST /v1/media/uploads, sending the file’s content_type and size_bytes.
2. PUT the raw file to the returned upload_url with the returned headers, exactly as given. The link is valid for 5 minutes.
3. Pass the hosted url into the model’s input field.

Size limits are 20 MB for images and audio and 50 MB for video. If your file is already at a public URL, you can pass that URL directly.

Webhooks instead of polling

For long jobs, add a top-level "webhook_url" to the submit body, or register an endpoint for every job on the Webhooks page. Pika says deliveries are signed per Standard Webhooks and “retried over about 55 hours.” Verify every signature and deduplicate on webhook-id.

Using the API with AI coding agents

Pika calls the API “agent-native”: you can “copy one onboarding prompt directly into your agent or vibe-coding platform,” and it lists Claude Code, Codex, Cursor, Lovable, Replit and ChatGPT as supported at launch. Get the prompt from dev.pika.art/agent.

Keep the API key out of the chat. Store it as an environment variable, and review what your agent will spend before approving paid generations.

Common errors

Security and good practice

• Keep keys server-side. Pika: “Never place an API key in browser code, a URL, source control, generated output, screenshots, or chat.”
• Call Pika from your own server if you’re building a web app.
• Quote before you spend, and set budgets per key.
• Save outputs to your own storage; you can delete a job’s stored media with DELETE /v1/media/jobs/{request_id}.
• Follow the rules: Pika’s Terms of Service and Acceptable Use Policy. Every operation also runs the provider’s own safety policy.

Pika API FAQs