The Pika API exposes every tool - Pika 2.5, Pikaformance, Pikaframes, AI Powers, PikaStream - as RESTful endpoints under one developer key. SDKs for Node, Python, and Go. Async webhooks. Generous rate limits. Per-token pricing.
The web app is the front door - but most production workflows can't live there. Marketing teams running thousands of ad variations. Game studios generating cinematics on demand. Newsletter platforms personalizing video for each subscriber. Content moderation pipelines validating thousands of clips a day. Each of these needs Pika's models exposed as primitives, not buttons in a UI.
The Pika API hands you exactly that. Every Pika tool - text-to-video, image-to-video, Pikaformance lip-sync, Pikaframes long-form, AI Powers styling and effects, PikaStream live video — is callable from your code under a single developer key. One authentication flow, one rate-limit ceiling, one billing wallet. The same models that power the consumer app and Pika AI Selves, exposed as RESTful endpoints with proper SDKs, async webhooks, and observability built in.
It's also explicitly agent-friendly. The API was built with autonomous AI workflows in mind - Claude through MCP, Openclaw agents, custom-built runtime, doesn't matter. Skip onboarding, get a key, ship. Selected skills are also published in the open-source Pika-Skills GitHub repository for self-hosting and customization. The whole surface is designed for products that need to call Pika at scale, not for one-off creative experiments.
Three lines of setup, one POST, and a finished MP4. Switch the language tab on the right to see the same flow in Node, Python, Go, or cURL.
Sign in at the developer portal. Generate a secret key starting with sk-pika-. Store it in your environment as PIKA_API_KEY.
Pick your language. Node, Python, and Go are first-class. Or hit the REST endpoints directly — same surface either way.
compose()The compose endpoint is the simplest entry point — it chains generation, styling, and effects into a single request and returns a finished clip URL.
Poll the job status, or register a webhook URL and Pika will POST when the render is done. Most clips finish in 60–90 seconds.
Each endpoint handles one capability — generation, styling, effects, lip-sync, live video. The compose endpoint chains them together when you want a single-request finished clip.
Core Pika 2.5 generation. Accepts a text prompt, an optional reference image, duration, aspect ratio, and resolution. Returns a job_id and status URL.
Single-request pipeline. Generate + style + effect + sticker overlays in one call. Returns a finished MP4 URL — the simplest entry point for new integrations.
Keyframe-based extended clips up to 25 seconds at 1080p. Supports iterative extension — pass a previous job_id to extend an existing clip.
Audio-driven talking-face generation. Accepts a still image plus an audio file. Returns a synced HD performance video — typical render in around six seconds.
Apply a curated style preset to an existing clip. Supports stacking multiple presets for blended looks. Non-destructive — the source is preserved.
Apply a Pikaffect transformation — cake-ify, melt, levitate, crystalize, and 23 more. Returns a re-rendered clip with the effect applied throughout.
Replace an object or character in an existing clip while preserving lighting and motion. Provide source video plus the new subject as a prompt or image.
Open a live PikaStream 1.0 session. Returns a meeting URL and session token. Bills per active minute. Pro plan and above.
Poll status of any async render. Returns queued, processing, complete, or failed — plus the output URL once ready and any error details if not.
Returns current credit balance, plan tier, billing cycle reset date, and API usage for the current period. Useful for in-product credit displays.
Register and manage webhook endpoints for async events — job completion, failure, billing thresholds. Each event is signed with HMAC for verification.
Remove a generated clip from Pika storage. Idempotent. Useful for compliance workflows where assets must be deleted after a fixed retention window.
Type-safe, well-tested, and kept in sync with the API surface. All three SDKs handle authentication, async polling, webhook signature verification, and retries with exponential backoff.
First-class TypeScript types for every endpoint. Promise-based async, optional streaming, edge runtime support. Drop into Vercel, Cloudflare Workers, or any Node 18+.
Python 3.9+ with full type hints, sync and async clients, and Pydantic models for response shapes. Plays clean with Django, FastAPI, Flask, and notebook environments.
Go 1.21+ with idiomatic error handling, context support for cancellation, and zero external dependencies beyond the standard library.
Standard Bearer token auth with optional key scoping. Rotate keys without downtime, scope them to specific endpoints, and revoke them instantly from the developer portal.
Pass your key as Authorization: Bearer sk-pika-... on every request. HTTPS only — keys sent over plain HTTP are rejected.
Generate keys scoped to specific endpoints (read-only, generate-only, no PikaStream, etc.) — useful for sharing keys across teams without exposing your full account.
Every webhook payload is signed with HMAC-SHA256 using your webhook secret. Verify the X-Pika-Signature header in your handler before trusting any payload.
For renders that take more than a few seconds, register a webhook URL and Pika will POST when the job is done. Skip polling, save bandwidth, get notified the moment a clip lands.
When you register a webhook URL on a generation request, Pika delivers a signed POST when the render completes (or fails). The payload includes the job ID, status, the rendered MP4 URL, the credit cost, and any error details if the render failed.
Every webhook is signed with HMAC-SHA256 using your webhook secret. Verify the X-Pika-Signature header against the raw request body before processing — example code is in every SDK and the docs.
Webhooks retry up to five times with exponential backoff if your endpoint returns non-2xx or times out. After five failed attempts, the event is dropped and a delivery-failed alert lands in your developer portal.
Limits scale with your plan tier. Need higher? Reach out — Fancy plan customers and enterprise users get custom rate ceilings as part of onboarding.
Renders running in parallel per API key. Pro plan ceiling. Fancy doubles to 20.
Standard rate. Burst up to 600/min for short windows. Sliding-window throttle.
Max time before a stuck render is force-cancelled. Refunds credits if timeout fires.
Exponential backoff between attempts. Failed deliveries surface in the portal.
Three sample videos demonstrating the kinds of output your API integration can produce — the official launch reel, hands-on workflow, and creative VFX patterns from the broader Pika community.
Same endpoint structure across every output tier. The resolution and quality scale with your plan and the parameters you pass on each request.
Production patterns where the API adds real lift. The common thread: workflows where a UI doesn't scale and human-in-the-loop generation is too slow.
Newsletter platforms generating a custom video clip per subscriber — name, location, behavior context — all baked into the rendered output before send.
Marketing teams running thousands of creative variants for A/B testing — different prompts, aspect ratios, and styling across the same product brief.
Generate a product hero clip from each catalog SKU automatically. Image-to-video plus a brand-consistent style preset, queued nightly.
Indie game studios generating cinematics, intros, and trailer footage at runtime — without the full mocap and rendering pipeline.
Drop the API into your Openclaw agent or Claude through MCP. Your existing assistant suddenly has access to generation, lip-sync, and live video.
SaaS products built around video creation — meme generators, lip-sync apps, viral content tools. Skip the generation infrastructure entirely.
Automated personalized response videos. PikaStream sessions for premium support tiers. Custom mascots delivering policy explanations.
Course platforms generating lesson videos, language practice clips, and animated explainers programmatically — at scale across thousands of learners.
Animate your 2D mascot with new dialogue, new contexts, new product mentions. A single image asset becomes a content engine.
sk-pika-. Store the key in a secure environment variable — Pika treats keys as bearer credentials, so anyone with the key can call the API on your account. Rotate or revoke instantly from the same portal if a key is exposed. Free-tier credits are included so you can start integrating before committing to a paid plan.
@pika/agent-api), Python (pika-api), and Go (github.com/pika-labs/pika-go). All three are MIT-licensed and kept in sync with the API surface. For other languages, the REST endpoints work directly — community SDKs for Ruby, PHP, Rust, and Elixir exist on GitHub but aren't officially maintained.
Retry-After header indicating when to retry. The official SDKs handle this automatically with exponential backoff. Concurrent job limits are separate from request limits — if you hit the concurrency ceiling (10 on Pro, 20 on Fancy), new generation requests are queued rather than rejected. For burst capacity beyond the standard ceiling, contact the team to discuss enterprise rate limits.
status.pika.me shows real-time platform health.
Free tier credits to test the integration. Three SDK languages first-class. Twelve endpoints covering every Pika tool. Webhook-first async. Drop in, ship.