A first-class developer API that lets you bring Pika Skills, Powers, and the entire 14+ model creative stack into your own products. One key, one endpoint, one wallet - all the same underlying infrastructure that powers Pika me Agents.
import { Pika } from '@pika-labs/sdk'; const pika = new Pika({ apiKey: process.env.PIKA_API_KEY }); // Generate a 6-second cinematic clip in your agent's style const video = await pika.video.generate({ prompt: "Golden hour timelapse, urban rooftop, soft ambient music", model: "sora", duration: 6, agentId: "agt_abc123" }); console.log(video.url); // → https://cdn.Pika me/...
The programmatic surface to Pika Labs' entire creative AI platform - exposed as a developer-friendly REST API with SDKs.
The Pika me Dev API is the programmatic interface that lets developers integrate Pika's creative AI stack directly into their own applications, agents, and pipelines. Where the consumer Pika me app gives you a chat surface and a custom agent, the Dev API gives you raw access to the same underlying machinery - video generation, image generation, voice synthesis, music composition, transcription, and persona orchestration - all addressable through standard HTTPS endpoints.
Under the hood, the API exposes the same fourteen-plus generation models, the same Pika Skills, and the same Pika Powers that the consumer product uses. The difference is the surface: instead of asking your Pika Agent in plain language to make something, you call a specific endpoint with structured parameters and receive a structured response. The underlying compute, billing, and routing all run on the same infrastructure.
This matters for builders because it collapses what would otherwise be a sprawling integration project. Without Pika, integrating Sora, Veo 3, Kling, ElevenLabs, MiniMax Music, and Whisper into a single product means signing up for six separate API keys, learning six different request formats, managing six billing relationships, and writing custom routing logic to pick between them. With the Pika me Dev API, that becomes one key, one base URL, one billing dashboard, and a single SDK surface that handles routing automatically.
Pika me/dev/login, verify your developer account, and your API key is provisioned immediately. The same Pika Wallet you use for the consumer app funds your API calls.
The Pika me Dev API is REST-based with JSON request and response bodies. Authentication uses bearer tokens passed in the standard Authorization header. Long-running generations (video, music, real-time streaming) return job IDs immediately and notify completion via webhooks or polling - so your code never blocks on a long model execution. Short generations (images, transcripts) return inline. There's also a streaming response mode for use cases where you want to display tokens as they're generated.
What you get without writing custom integration code for each underlying model provider.
Video, image, voice, music, and transcription all behind one consistent request format. No more learning six different APIs.
Specify the outcome, and the API picks the best model automatically. Or override with the model parameter when you need to.
Reference a Pika Agent by ID, and every generation inherits that agent's identity, soul, and style files. Persona built in.
Call /skills/podcast, /skills/explainer, or /skills/ugc-ads directly. Multi-step workflows as one HTTP call.
Long generations return job IDs instantly. Configure a webhook URL and the API calls back when your asset is ready.
Server-sent events stream tokens as they're generated. Build real-time creative UIs without polling overhead.
Same Pika Wallet, same per-token billing model as the consumer app. View detailed usage in the Dev dashboard.
Official SDKs for JavaScript/TypeScript and Python. Community libraries for Go, Ruby, PHP, and Rust on the way.
OAuth 2.0 for end-user auth, scoped API keys for server-to-server, IP allowlisting, and audit logs on every call.
About five minutes from creating your developer account to getting your first generation back from the API.
Sign up at Pika me/dev/login. Verify your email and accept the developer terms.
Open the Dev dashboard, click Create Key, name your environment (production, staging, dev), and copy the key.
pk_live_...
Pick your language - JavaScript, Python, or use cURL directly. SDKs handle auth, retries, and error parsing for you.
npm install @pika-labs/sdk
Generate a video, image, or voiceover with one method call. The SDK returns a typed response with the asset URL.
All endpoints are rooted at https://api.Pika me/v1. JSON requests, JSON responses, bearer auth.
Copy-paste examples for the most common Pika me Dev API operations. JavaScript, Python, and cURL.
Async job - the response includes a job ID you poll or receive via webhook.
import { Pika } from '@pika-labs/sdk'; const pika = new Pika({ apiKey: process.env.PIKA_API_KEY }); const job = await pika.video.generate({ prompt: "A drone shot over an alpine lake at sunset, cinematic", model: "sora", duration: 6, aspectRatio: "16:9", agentId: "agt_abc123" }); // Poll until ready let result = await pika.jobs.wait(job.id); console.log(result.url); // → https://cdn.Pika me/v/...
from pika import Pika import os pika = Pika(api_key=os.environ["PIKA_API_KEY"]) job = pika.video.generate( prompt="A drone shot over an alpine lake at sunset, cinematic", model="sora", duration=6, aspect_ratio="16:9", agent_id="agt_abc123", ) # Poll until ready result = pika.jobs.wait(job.id) print(result.url) # → https://cdn.Pika me/v/...
curl -X POST https://api.Pika me/v1/video/generate \ -H "Authorization: Bearer $PIKA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "prompt": "A drone shot over an alpine lake at sunset, cinematic", "model": "sora", "duration": 6, "aspect_ratio": "16:9", "agent_id": "agt_abc123" }' # Returns: { "job_id": "job_xyz789", "status": "queued" } # Poll: GET https://api.Pika me/v1/jobs/job_xyz789
Fast model, immediate response - no polling needed for image generations.
const image = await pika.image.generate({ prompt: "Minimalist product shot of a coffee cup, soft lighting", model: "gemini-image", size: "1024x1024", agentId: "agt_abc123" }); console.log(image.url); console.log(`Tokens spent: ${image.tokensUsed}`);
image = pika.image.generate(
prompt="Minimalist product shot of a coffee cup, soft lighting",
model="gemini-image",
size="1024x1024",
agent_id="agt_abc123",
)
print(image.url)
print(f"Tokens spent: {image.tokens_used}")
curl -X POST https://api.Pika me/v1/image/generate \ -H "Authorization: Bearer $PIKA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "prompt": "Minimalist product shot of a coffee cup, soft lighting", "model": "gemini-image", "size": "1024x1024", "agent_id": "agt_abc123" }'
Skills bundle multiple model calls into one workflow. One request → multi-asset deliverable.
const podcast = await pika.skills.podcast({ brief: "Discuss the impact of MCP on the AI agent ecosystem", speakers: [ { voice: "alice_v2", role: "host" }, { voice: "darius_v1", role: "guest" } ], duration: 300, // 5 minutes bRoll: true, chapters: true, webhook: "https://your-app.com/pika/webhook" }); // Webhook fires when ready; result.url has the finished MP4
podcast = pika.skills.podcast(
brief="Discuss the impact of MCP on the AI agent ecosystem",
speakers=[
{"voice": "alice_v2", "role": "host"},
{"voice": "darius_v1", "role": "guest"},
],
duration=300,
b_roll=True,
chapters=True,
webhook="https://your-app.com/pika/webhook",
)
curl -X POST https://api.Pika me/v1/skills/podcast \ -H "Authorization: Bearer $PIKA_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "brief": "Discuss the impact of MCP on the AI agent ecosystem", "speakers": [ { "voice": "alice_v2", "role": "host" }, { "voice": "darius_v1", "role": "guest" } ], "duration": 300, "b_roll": true, "chapters": true, "webhook": "https://your-app.com/pika/webhook" }'
Pull identity, soul, and style files for use in custom prompting pipelines.
const persona = await pika.agents.getPersona('agt_abc123'); console.log(persona.identity); // → "Monica, 28, creative director..." console.log(persona.soul); // → Tone, taste, humor preferences console.log(persona.style); // → Visual signature, color palette
persona = pika.agents.get_persona("agt_abc123") print(persona.identity) # → "Monica, 28, creative director..." print(persona.soul) # → Tone, taste, humor preferences print(persona.style) # → Visual signature, color palette
curl https://api.Pika me/v1/agents/agt_abc123/persona \ -H "Authorization: Bearer $PIKA_API_KEY" # Returns: { "identity": "...", "soul": "...", "style": "..." }
Receive async job notifications without polling. Verify signatures to ensure authenticity.
import express from 'express'; import { Pika } from '@pika-labs/sdk'; const app = express(); app.post('/pika/webhook', express.raw({ type: 'application/json' }), (req, res) => { const signature = req.headers['pika-signature']; try { const event = Pika.verifyWebhook(req.body, signature, process.env.PIKA_WEBHOOK_SECRET); if (event.type === 'job.completed') { console.log('Asset ready:', event.data.url); } res.status(200).send('ok'); } catch (err) { res.status(400).send('Invalid signature'); } });
from flask import Flask, request from pika import Pika import os app = Flask(__name__) @app.route("/pika/webhook", methods=["POST"]) def handle_webhook(): signature = request.headers.get("pika-signature") try: event = Pika.verify_webhook( request.data, signature, os.environ["PIKA_WEBHOOK_SECRET"] ) if event.type == "job.completed": print("Asset ready:", event.data.url) return "ok", 200 except Exception: return "Invalid signature", 400
The full list of models you can target with the model parameter, plus the underlying provider and typical use case.
| Model ID | Category | Underlying Provider | Best For |
|---|---|---|---|
pika-video | Video | Pika Labs | Fast iteration, 6-second clips |
sora | Video | OpenAI | Cinematic, high-fidelity |
veo-3 | Video | Google DeepMind | Sound-aware longer clips |
kling | Video | Kuaishou | Character motion realism |
minimax-video | Video | MiniMax | Budget-friendly clips |
seedance-2 | Video | Seedance | Dance & kinetic motion |
remotion | Video | Remotion | Programmatic templating |
video-frames | Video | Pika Labs | Keyframe-driven sequences |
gemini-image | Image | Fast single image, "nano banana" | |
gpt-image-2 | Image | OpenAI | Detailed prompt-following |
seeddream | Image | Seedream | Stylized illustration |
elevenlabs | Voice | ElevenLabs | Premium voiceover |
minimax-voice | Voice | MiniMax | Standard TTS |
minimax-music | Music | MiniMax | Instrumental composition |
whisper | Transcription | OpenAI | Multilingual audio → text |
model parameter, the API picks the best-fit model based on your prompt and any agent context. Useful when you want Pika to handle model selection like the consumer app does.
How to authenticate, what scopes mean, and best practices for production-grade integration.
Every request to the Pika me Dev API must include an Authorization header with a bearer token. Two key types exist: live keys (prefix pk_live_) which spend real Pika Wallet tokens, and test keys (prefix pk_test_) which return mocked responses for development without billing your wallet.
When you create an API key in the Dev dashboard, you assign it scopes that control what it can do. Granular scopes mean a stolen key from one part of your infrastructure doesn't expose your entire account. Available scopes include:
video:generate - create video generationsimage:generate - create image generationsvoice:synthesize - synthesize voiceovermusic:compose - compose music tracksaudio:transcribe - transcribe audioskills:run - invoke skill workflowsagents:read - read agent personasagents:write - update agent personaswallet:read - view balance and usagewebhooks:manage - register/remove webhooksFor production keys, you can lock them to specific IP addresses or CIDR ranges in the Dev dashboard. Requests from any other origin are rejected with a 403, even if the bearer token is valid. This is a strong defense against accidentally-leaked credentials being abused - the attacker would also need to spoof your IP, which is much harder.
Every webhook payload includes a pika-signature header containing an HMAC-SHA256 signature of the request body using your webhook secret. Always verify this signature before processing - both SDKs provide a verifyWebhook helper that handles the comparison constant-time to prevent timing attacks. Without verification, anyone who learns your webhook URL could send forged completion events.
What to expect on heavy usage, and how to handle the codes the API returns.
Pika me Dev API rate limits are designed to keep the platform responsive for everyone without throttling legitimate workloads. Default limits on a fresh developer account are 60 requests per minute for synchronous endpoints (image, voice, transcription) and 30 requests per minute for asynchronous job-based endpoints (video, music, skills). Limits scale up automatically as your account demonstrates consistent, well-behaved usage.
Every response includes three rate-limit headers: X-RateLimit-Limit (your current ceiling), X-RateLimit-Remaining (calls left in this window), and X-RateLimit-Reset (Unix timestamp when the limit resets). If you hit the ceiling, you'll receive a 429 Too Many Requests response with a Retry-After header telling you how long to wait. The official SDKs handle 429s automatically with exponential backoff, so you rarely have to write retry logic yourself.
All error responses return a structured JSON body with error.code, error.message, and error.request_id. Always log the request_id - it's how Pika support traces an issue when you open a ticket. The error code uses a consistent vocabulary across the API (invalid_parameter, insufficient_tokens, model_unavailable, etc.) so you can switch on it programmatically.
The open framework underneath every Pika Agent - now available to bring into your own products.
OpenClaw is Pika Labs' open agent framework - the same orchestration layer that makes Pika me agents work. It handles tool-use, persistent memory storage, identity-file management, cross-platform deployment, and skill composition. Pika released it as a developer-facing layer so the same primitives that power consumer agents can power your custom agents too.
The framework integrates tightly with the Pika me Dev API: agents built in OpenClaw can call any Pika me endpoint as a native tool, use any of the fourteen-plus generation models, and bill through the same Pika Wallet. You're not stitching OpenClaw and Pika together with custom adapters - they're designed as one stack with two surfaces.
OpenClaw's design also accommodates agent-to-agent composition. You can build a "supervisor" agent in OpenClaw that delegates subtasks to specialized Pika me agents (one for video, one for voiceover, one for research), each operating with its own persona files and shared memory. This is the pattern Pika themselves use for complex skills like /pika:podcast, where a planning agent coordinates a writing agent, a casting agent, and an editing agent.
Some Pika Skills are also open-source under Apache 2.0 in the Pika-Labs/Pika-Skills repository on GitHub. The launch skill is pikastream-video-meeting, which enables real-time animated video calls with your agent on Google Meet. Forking the repo and contributing new skills is welcomed - Pika Labs is treating the skills marketplace as a community-built layer rather than a closed product feature.
github.com/Pika-Labs. The framework is in active development with frequent releases.
Eight patterns that separate a hobby project from a production-ready Pika me integration.
Every Pika me Dev account ships with both live and test keys. Use the test key in your dev and staging environments - responses are mocked, no tokens are burned, no real provider calls happen. Switch to the live key only for production deployments and integration tests where you actually need real output. This habit alone can save hundreds of dollars during early development.
Polling job status with GET /v1/jobs/{id} works but burns through your rate limit and adds latency. Webhooks are free, push-based, and arrive within seconds of job completion. Set up a single webhook endpoint per environment that routes events to the right downstream handlers based on event.type.
If your application reads an agent's identity, soul, or style file before every generation, you're making unnecessary requests. Persona files change infrequently - cache them in your application memory (or Redis if you're running multiple instances) with a TTL of around an hour. Refresh on demand if your code knows the persona was just updated via PUT /v1/agents/{id}/persona.
Sending obviously invalid parameters (negative durations, unsupported model IDs, malformed UUIDs) still costs you a round-trip even though the API returns 400. Use the TypeScript types shipped with the JS SDK or the Pydantic models in the Python SDK to catch these locally before the request fires. The SDKs do this for you when you use the typed methods rather than raw HTTP calls.
A 402 means your Pika Wallet is empty. In production, this needs a graceful degradation strategy: notify the user, queue the request for retry after top-up, or fall back to a cheaper model. Don't just crash - and definitely don't retry the same call in a tight loop, since the 402 will keep firing until the wallet is topped up.
Every API response includes a unique request_id in headers (and in error bodies). Log this with your own application logs so when something goes wrong, you can tell Pika support exactly which request to investigate. Without it, debugging multi-day-old issues becomes painful.
For text-heavy responses where the user is waiting (an explainer script, a podcast transcript), use the streaming response mode. The perceived latency drop is significant - users see content appearing in real-time instead of waiting for the full response. For binary assets (video, image, audio), streaming doesn't help; just poll or use webhooks.
Synchronous endpoints (image, voice) typically respond in 2–10 seconds. Async job-creation endpoints (video, music) respond in <1 second since they just queue work. Set your HTTP client timeout to 30 seconds for safety, and configure your async job timeout based on the model - Sora videos can take 60–90 seconds total, while Pika Video clips are usually 20–30 seconds.
The most-searched questions about building with the Pika me Dev API.
Sign up at Pika me/dev/login. After verifying your developer account, head to the Dev dashboard and click Create Key. You'll get a key prefixed with pk_live_ for production or pk_test_ for development.
The developer account, API key creation, and dashboard access are all free. You're only billed for actual generations from your Pika Wallet - there's no monthly platform fee. New developer accounts also receive a starter batch of tokens to test the API before any real spend.
JavaScript/TypeScript (@pika-labs/sdk on npm) and Python (pika on PyPI) are the two officially supported SDKs at launch. Community libraries for Go, Ruby, PHP, and Rust are in active development. Until then, all functionality is available via the raw REST API using any HTTP client.
Yes - Server-Sent Events streaming is available for text-heavy endpoints like scripts, transcripts, and explainer narration. Pass "stream": true in the request body and the API returns a stream of events instead of a single response. Both SDKs provide async-iterator interfaces for consuming streams.
Video generation is always async. The POST /v1/video/generate endpoint returns a job ID immediately (status 202). Either poll GET /v1/jobs/{id} until status is "completed," or register a webhook and have Pika notify you when the asset is ready. Webhooks are strongly preferred for production use.
You need a Pika me account because the wallet is account-scoped - but you don't need to use the consumer app for anything. Many developers create an account purely for API access and never touch the web or iOS interface. The agent ID parameter is also optional; if you don't pass one, your generations run with default persona settings.
If an upstream model (Sora, Veo 3, etc.) is temporarily unavailable, the API returns 503 with error.code: "model_unavailable". You can either retry later, or pass a fallback by sending the request again with a different model parameter. The auto-routing mode handles this automatically - it tries alternative models when the primary choice is down.
One wallet, one balance. Whether tokens are spent through the consumer Pika me app, the Pika MCP connected to Claude, or your custom API integration, they all draw from the same Pika Wallet. The Dev dashboard breaks down usage by source so you can see which integration is consuming most of your tokens.
Yes. The /v1/agents endpoints let you create new agents, read and update persona files, and list all agents in your account. This is how you build white-label products that provision custom agents on behalf of your users - for example, an agency tool that creates one Pika Agent per client.
Every webhook payload includes a pika-signature header with an HMAC-SHA256 signature of the body using your webhook secret. Always verify the signature using the verifyWebhook helper in either SDK before processing the event. Without verification, malicious actors who learn your webhook URL could send forged events.
Pika me Dev API is currently in general availability without a formal SLA. Enterprise SLA agreements are available on request via support@Pika me - including dedicated rate limits, priority queueing, and white-glove integration support for larger contracts.
The Pika MCP is a Model Context Protocol server that connects your Pika Agent to AI clients like Claude. The Pika me Dev API is a traditional REST API that connects Pika's creative stack to your own code. Both share the same wallet and underlying infrastructure - they're just different surfaces for different use cases. Use the MCP when integrating with conversational AI clients; use the Dev API when integrating with your own application code.
Free developer account. Test keys for sandboxing. Same wallet, same models, more control.