How to Generate AI Video with PixVerse V6 via the PixVerse API
6 min read • June 8, 2024 (June 15, 2026)
Table of contents
- Introduction
- Generate a video in two API calls
- Supported models
- Audio, multi-shot & effects
- Pricing
- Batch-generate with a script
- Examples
- Frequently asked questions
- Conclusion
Introduction
Yes — you can generate PixVerse V6 video through a REST API. useapi.net provides a PixVerse API for PixVerse.ai that drives your own PixVerse account: you send a text or image prompt to one POST endpoint, poll a GET endpoint for the result, and get back an MP4.
The default model is the native PixVerse V6 — up to 15-second 1080p clips with integrated audio and multi-shot storytelling — and the same videos/create endpoint also exposes the rest of the native family (v5.6, v5.5, v5, v5-fast, pixverse-c1) plus third-party models such as Seedance 2.0, Kling O3/V3, Veo 3.1, Sora 2, Grok Imagine, and HappyHorse — all selectable with a single model field. This guide shows the two-call video workflow with copy-paste curl, then a runnable Node.js script that batch-generates from a list of prompts.
Generate a video in two API calls
You need a useapi.net API token and a connected PixVerse account. Generation is asynchronous: the create call returns a video_id immediately, then you poll until the video is ready.
1. Submit the job — POST https://api.useapi.net/v2/pixverse/videos/create:
curl -X POST "https://api.useapi.net/v2/pixverse/videos/create" \
-H "Authorization: Bearer $USEAPI_TOKEN" \
-H "Content-Type: application/json" \
-d '{
"model": "v6",
"prompt": "A red panda eating bamboo in a misty forest, camera slowly pushing in",
"quality": "720p",
"duration": 5,
"aspect_ratio": "16:9"
}'
The response returns immediately with a video_id:
{
"video_id": "user:1234-pixverse:jo***@gmail.com-video:112233445566"
}
2. Poll for the result — GET https://api.useapi.net/v2/pixverse/videos/{video_id}:
curl "https://api.useapi.net/v2/pixverse/videos/VIDEO_ID" \
-H "Authorization: Bearer $USEAPI_TOKEN"
While the video is still processing this endpoint returns 404. Once it is done it returns 200 with video_status_name: "COMPLETED" and video_status_final: true. The finished MP4 is in the url field:
{
"video_id": "user:1234-pixverse:jo***@gmail.com-video:112233445566",
"model": "v6",
"prompt": "A red panda eating bamboo in a misty forest, camera slowly pushing in",
"quality": "720p",
"duration": 5,
"url": "https://media.pixverse.ai/....mp4",
"video_status_name": "COMPLETED",
"video_status_final": true
}
Prefer not to poll? Pass a replyUrl in the create body to receive a webhook callback (same JSON shape) when the video completes or fails.
Supported models
Pick a model per request with the model field (default v6). Native PixVerse models support integrated audio, the off-peak discount, preview mode, and seed; see Model Capabilities for the full per-model quality / duration / aspect-ratio matrix.
| Model id | Highlights | Qualities | Durations |
|---|---|---|---|
v6 (default) | Multi-shot, integrated audio, longest clips | 360p, 540p, 720p, 1080p | 1–15s |
v5.6 | Integrated audio | 360p, 540p, 720p, 1080p | 1–10s (1080p ≤ 8s) |
v5.5 | Integrated audio | 360p, 540p, 720p, 1080p | 1–10s (1080p ≤ 8s) |
v5 | Lip-sync TTS + sound-effect prompts | 360p, 540p, 720p, 1080p | 1–10s (1080p ≤ 8s) |
v5-fast | Fastest native model | 360p, 540p, 720p, 1080p | 1–10s (1080p ≤ 8s) |
pixverse-c1 | Wide aspect-ratio support, 15s | 360p, 540p, 720p, 1080p | 1–15s |
Beyond the native family, the same videos/create endpoint accepts third-party models via the model field: seedance-2.0 / seedance-2.0-fast (ByteDance), kling-o3 / kling-v3 (Kuaishou), veo-3.1-lite / veo-3.1-standard / veo-3.1-fast (Google), sora-2 / sora-2-pro (OpenAI), grok-imagine (xAI), and happyhorse-1.0 (Alibaba). Each has its own quality, duration, and feature constraints — see Model Capabilities.
Audio, multi-shot & effects
Integrated audio. Set audio: true to generate voice, dialogue, and background sound in a single step. It is a toggle on v6, v5.6, v5.5, pixverse-c1, the Seedance models, and the Kling models; on veo-3.1-standard, veo-3.1-fast, and happyhorse-1.0 audio is always on. (Legacy v5 instead uses lip_sync_tts_prompt and sound_effect_prompt.)
Multi-shot storytelling. On v6 only, set multi_shot: true to have the model generate multiple camera angles and scene cuts within one clip instead of a single continuous shot.
900+ effect templates. List the catalog with GET videos/effects, then pass the chosen template_id to videos/create along with the required input image(s). When template_id is set, the template controls model, duration, and quality — you only supply the frame path(s).
For more workflows on native PixVerse models, the API also offers image-to-video (upload a frame via POST files, pass it as first_frame_path), extend, upscale, lip-sync, modify, and motion-control.
Pricing
You keep your own PixVerse subscription (Pro, Premium, or Ultra) and add a single flat $15/month to useapi.net that covers API access to every supported service — there are no per-call API surcharges.
Each generation spends credits from your PixVerse plan. For native PixVerse models you can cut that cost with off_peak_mode: true (results usually delivered within 24 hours): Pro 30% off, Premium 50% off, Ultra unlimited free. preview_mode: true is another native-only option — a fast, lower-quality preview at 20% off that you can later upscale. Third-party models don’t support off-peak or preview mode; Ultra subscribers get a 40% discount on them instead. Pro+ plans additionally include unlimited image generation in Relax Mode for select models (Ultra covers all of them).
For an interactive per-model, per-plan cost calculator, see the PixVerse API overview.
Batch-generate with a script
Finding the right shot takes many attempts, and running them by hand is tedious. The Node.js script below reads a list of prompts from prompts.json, uploads any input frame images, submits each videos/create job, then polls and downloads every finished MP4 — so you can queue a batch and come back to the winners.
You need Node.js v21 or newer. Put prompts.json and pixverse.mjs in the same folder and run node ./pixverse.mjs API_TOKEN EMAIL, where API_TOKEN is your useapi.net API token and EMAIL is your connected PixVerse account email. The script looks the account up by email automatically.
Expand prompts.json
[
{
"prompt": "By default the v6 model with a 5-second 720p 16:9 clip will be used."
},
{
"model": "v6",
"duration": 15,
"quality": "1080p",
"aspect_ratio": "16:9",
"audio": true,
"multi_shot": true,
"prompt": "PixVerse V6 with integrated audio and multi-shot storytelling. A dramatic courtroom scene with multiple camera angles. For all parameters see https://useapi.net/docs/api-pixverse-v2/post-pixverse-videos-create-v4"
},
{
"model": "v5.6",
"duration": 8,
"quality": "1080p",
"first_frame_path": "./first_frame.webp",
"audio": true,
"prompt": "Image-to-video: the local image is uploaded via POST files and passed as first_frame_path. Note: aspect_ratio is derived from the image and must NOT be set for i2v."
},
{
"model": "seedance-2.0",
"duration": 5,
"quality": "720p",
"aspect_ratio": "16:9",
"prompt": "Third-party models (seedance-2.0, kling-o3, veo-3.1-fast, sora-2, grok-imagine, happyhorse-1.0, …) are selectable via the model field. They reject native-only flags such as off_peak_mode, preview_mode, multi_shot and seed."
}
]
Expand pixverse.mjs script
/*
Script version 1.0, June 15, 2026
Script to batch-generate videos using prompts with the PixVerse API v2 by useapi.net 🚀
Uses the POST /videos/create endpoint (default model: v6) and polls GET /videos/{video_id}.
For more details visit https://useapi.net/docs/api-pixverse-v2/post-pixverse-videos-create-v4
Installation Instructions:
==========================
You need Node.js v21 or newer installed to run this script. Download and install Node.js from:
- Windows, macOS, Linux: https://nodejs.org/
After installation, verify by running the following command in a terminal:
node -v
Running the Script:
===================
Usage: node pixverse.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]
Replace API_TOKEN with your actual useapi.net API token, see https://useapi.net/docs/start-here/setup-useapi
Replace EMAIL with configured PixVerse email account, see https://useapi.net/docs/start-here/setup-pixverse
If optional PROMPTS_FILE not provided prompts.json will be used.
Example:
--------
node pixverse.mjs user:1234-abcdefhijklmnopqrstuv [email protected]
This command executes the script using API token user:1234-abcdefhijklmnopqrstuv with [email protected] PixVerse account email.
Changelog:
==========
- June 15, 2026: Initial release.
*/
import readline from 'node:readline';
import fs from 'fs/promises';
import { writeFile } from 'node:fs/promises';
import { Readable } from 'node:stream';
// Constants
const RESULTS_FILE = 'pixverse_results.txt';
const ERRORS_FILE = 'pixverse_errors.txt';
const DEFAULT_PROMPTS_FILE = 'prompts.json';
const DEFAULT_MODEL = 'v6';
const SLEEP_429 = 30 * 1000; // in milliseconds
const SLEEP_POLL = 15 * 1000; // in milliseconds
const urlAccounts = 'https://api.useapi.net/v2/pixverse/accounts';
const urlCreate = 'https://api.useapi.net/v2/pixverse/videos/create';
const urlVideo = 'https://api.useapi.net/v2/pixverse/videos/'; // + video_id (poll)
const urlFiles = 'https://api.useapi.net/v2/pixverse/files/'; // + ?email= (upload)
// PixVerse accepts these image extensions for uploaded frames.
const supportedFileExtensions = ['png', 'jpeg', 'jpg', 'gif', 'webp'];
// { filename: path }
const uploadedFiles = {};
// Utility to sleep for given milliseconds
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
// Function to fetch configured PixVerse API accounts
async function fetchAccounts(apiToken) {
const response = await fetch(urlAccounts, {
headers: {
'Accept': 'application/json',
'Authorization': `Bearer ${apiToken}`
}
});
if (!response.ok) {
console.error(`⛔ Error fetching accounts (HTTP ${response.status}): ${response.statusText}`);
process.exit(1);
}
return response.json();
}
const elapsedTimeSec = (start) => (Date.now() - start) / 1000;
// Map a file extension to the Content-Type required by POST /files
const contentTypeForExt = (ext) =>
ext === 'png' ? 'image/png' :
ext === 'gif' ? 'image/gif' :
ext === 'webp' ? 'image/webp' : 'image/jpeg';
// Upload a local image and return its PixVerse `path` (used as first_frame_path etc.)
async function uploadFile(apiToken, email, filename) {
// Check if already uploaded
if (uploadedFiles.hasOwnProperty(filename))
return uploadedFiles[filename];
const startTime = Date.now();
console.log(`⬆️ Account ${email} uploading file…`, filename);
const body = new Blob([await fs.readFile(filename)]);
const fileExt = filename.split('.').pop().toLowerCase();
const response = await fetch(`${urlFiles}?email=${encodeURIComponent(email)}`, {
method: 'POST',
headers: {
'Accept': 'application/json',
'Authorization': `Bearer ${apiToken}`,
'Content-Type': contentTypeForExt(fileExt)
},
body
});
if (response.ok) {
const json = await response.json();
// Image uploads return result[0].path; use that as the frame path.
const path = json?.result?.[0]?.path ?? json?.path;
console.log(`🆗 path (${elapsedTimeSec(startTime)} sec)`, path);
uploadedFiles[filename] = path;
}
else {
console.error(`❗ Unable to upload file HTTP ${response.status} (${elapsedTimeSec(startTime)} sec)`, await response.text());
// Do not attempt to upload failed file again
uploadedFiles[filename] = undefined;
}
return uploadedFiles[filename];
}
async function submit(apiToken, url, body, index, prompt) {
const createResponse = await fetch(url, {
method: 'POST',
headers: {
'Accept': 'application/json',
'Content-Type': 'application/json',
'Authorization': `Bearer ${apiToken}`
},
body
});
const createBody = await createResponse.text();
// POST /videos/create returns 200 with a video_id to poll.
if (createResponse.status == 200) {
const json = JSON.parse(createBody);
const videoId = json.video_id ?? json.image_id;
if (videoId) {
await fs.appendFile(RESULTS_FILE, `${videoId},#${index}:${prompt}\n`);
console.log(`✅ video_id`, videoId);
return 200;
} else {
const error = `No video_id found in HTTP 200 response`;
console.log(`❓ ${error}`, createBody);
await fs.appendFile(ERRORS_FILE, `${error},#${index}:${prompt}\n`);
return 500;
}
} else {
switch (createResponse.status) {
case 429:
console.log(`🔄️ Account busy / concurrent limit, retry on HTTP ${createResponse.status}`, createBody);
break;
case 400:
console.log(`🛑 Rejected request (validation)`, createBody);
await fs.appendFile(ERRORS_FILE, `${createResponse.status},#${index}:${prompt}\n`);
break;
case 412:
console.log(`🛑 Insufficient credits`, createBody);
break;
case 422:
console.log(`🛑 Moderated prompt`, createBody);
await fs.appendFile(ERRORS_FILE, `${createResponse.status},#${index}:${prompt}\n`);
break;
default:
console.log(`❗ FAILED with HTTP ${createResponse.status}`, createBody);
await fs.appendFile(ERRORS_FILE, `${createResponse.status},#${index}:${prompt}\n`);
}
return createResponse.status;
}
}
// Submit a single prompt to POST /videos/create.
// first_frame_path (uploaded image) switches to image-to-video; aspect_ratio is then derived from the image.
async function submitVideo(apiToken, email, prompt, index) {
const {
model, prompt: text, first_frame_path, duration, quality, aspect_ratio,
audio, multi_shot, preview_mode, off_peak_mode, seed, template_id
} = prompt;
const useModel = model ?? DEFAULT_MODEL;
console.log(`🚀 ${useModel} » Prompt #${index} • account ${email} …`);
const framePath = first_frame_path ? await uploadFile(apiToken, email, first_frame_path) : undefined;
const body = JSON.stringify({
model: useModel,
email,
prompt: text,
first_frame_path: framePath,
duration,
quality,
// aspect_ratio applies only to text-to-video and is optional (the server defaults to 16:9 when omitted); for image-to-video it is derived from the image
aspect_ratio: framePath ? undefined : aspect_ratio,
audio,
multi_shot,
preview_mode,
off_peak_mode,
seed,
template_id
});
return await submit(apiToken, urlCreate, body, index, text);
}
// Function to poll and download videos
async function download(apiToken) {
if (! await fileExists(RESULTS_FILE)) return;
try {
const resultsContent = await fs.readFile(RESULTS_FILE, 'utf8');
const lines = resultsContent.trim().split('\n');
for (const line of lines) {
const [videoId, prompt] = line.split(',');
console.log(`👉 ${videoId}`);
while (true) {
const response = await fetch(`${urlVideo}${videoId}`, {
headers: {
'Accept': 'application/json',
'Authorization': `Bearer ${apiToken}`
}
});
// 404 means the video is still processing — keep waiting.
if (response.status == 404) {
console.log(`⌛ ${videoId} still processing, waiting…`);
await sleep(SLEEP_POLL);
continue;
}
if (!response.ok) {
console.log(`🛑 Poll failed ${videoId} (HTTP ${response.status}):\n${prompt}\n`, await response.text());
break;
}
const job = await response.json();
const { url, video_status_name, video_status_final, error } = job;
if (error) {
console.error(`🛑 FAILED ${videoId} (${error}):\n${prompt}\n`);
break;
}
// Poll until the status is final (COMPLETED, MODERATED, etc.).
if (!video_status_final) {
console.log(`⌛ ${videoId} status (${video_status_name}) and is still in progress, waiting…`);
await sleep(SLEEP_POLL);
continue;
}
if (video_status_name !== 'COMPLETED' || !url) {
console.error(`🛑 ${videoId} finished as ${video_status_name} with no url:\n${prompt}\n`);
break;
}
const videoFilename = `${videoId.replace(/[:*]/g, '_')}.mp4`;
try {
await fs.access(videoFilename);
console.log(`⚠️ ${videoFilename} already exists. Skipping download.`);
break;
} catch {
// File does not exist, proceed with downloading
}
console.log(`✅ Downloading ${url} to ${videoFilename}`);
try {
const videoResponse = await fetch(url);
if (!videoResponse.ok) {
console.error(`⛔ Unable to download ${videoId} (HTTP ${videoResponse.status}):\n${prompt}\n`, url);
break;
}
const stream = Readable.fromWeb(videoResponse.body);
await writeFile(videoFilename, stream);
} catch (err) {
console.error(`⛔ Error during download: ${err}`);
}
break;
}
}
} catch (error) {
console.log(`⛔ Error during download:`, error.stack || error);
}
}
// Main function
async function main() {
const apiToken = process.argv[2];
const email = process.argv[3];
const promptFile = process.argv[4] || DEFAULT_PROMPTS_FILE;
if (!apiToken || !email) {
console.error('Usage: node pixverse.mjs <API_TOKEN> <EMAIL> [PROMPTS_FILE]');
process.exit(1);
}
console.info('Script v1.0');
console.info('Node version is: ' + process.version);
try {
if (await fileExists(RESULTS_FILE)) {
let user_input;
while (!['y', 'n'].includes(user_input)) {
user_input = (await promptUser(`❔ ${RESULTS_FILE} file detected. Do you want to download the results now? (y/n): `))?.toLowerCase();
if (user_input == 'y') {
await download(apiToken);
await fs.unlink(RESULTS_FILE);
}
}
}
const start = new Date();
try {
console.info('START EXECUTION', start);
await execute(apiToken, email, promptFile); // Pass the promptFile to execute function
}
finally {
console.info('COMPLETED', new Date());
console.info('EXECUTION ELAPSED', diffInMinutesAndSeconds(start, new Date()));
}
try {
console.info('START DOWNLOAD', start);
await download(apiToken);
}
finally {
console.info('TOTAL ELAPSED', diffInMinutesAndSeconds(start, new Date()));
}
} catch (error) {
console.error('⛔ Error during execution:', error.stack || error);
}
}
// Modify the execute function to accept promptFile as a parameter
async function execute(apiToken, email, promptFile) {
const accounts = await fetchAccounts(apiToken);
console.info(`Configured PixVerse API accounts (${Object.keys(accounts).length}):`, Object.keys(accounts).join(', '));
if (Object.keys(accounts).length <= 0) {
console.error(`⛔ No configured PixVerse accounts found. Please refer to https://useapi.net/docs/start-here/setup-pixverse`);
process.exit(1);
}
if (!accounts[email]) {
console.error(`⛔ Account ${email} not found. Please refer to https://useapi.net/docs/start-here/setup-pixverse`);
process.exit(1);
}
const promptData = await fs.readFile(promptFile, 'utf8');
const prompts = JSON.parse(promptData);
console.log(`Total number of prompts to process`, prompts.length);
let warnings = [];
// Parameters accepted by this script for the POST /videos/create endpoint.
// See https://useapi.net/docs/api-pixverse-v2/post-pixverse-videos-create-v4 for the full parameter set.
const supportedParams = ['model', 'prompt', 'first_frame_path', 'duration', 'quality', 'aspect_ratio',
'audio', 'multi_shot', 'preview_mode', 'off_peak_mode', 'seed', 'template_id'];
const invalidKeys = (prompt) => Object.keys(prompt).filter(key => !key.startsWith('__') && !supportedParams.includes(key))
for (let i = 1; i <= prompts.length; i++) {
const prompt = prompts[i - 1];
const { prompt: text, first_frame_path, template_id } = prompt;
if (first_frame_path) {
try {
await fs.access(first_frame_path);
} catch {
warnings.push(`⚠️ Image '${first_frame_path}' does not exist. Prompt ${i}`);
}
const ext = first_frame_path.split('.').pop().toLowerCase();
if (!supportedFileExtensions.includes(ext))
warnings.push(`⚠️ Image ${first_frame_path} extension ${ext} not supported. Prompt ${i}`);
}
const notSupported = invalidKeys(prompt);
if (notSupported.length)
warnings.push(`⚠️ Following params not supported: ${notSupported.join(',')}. Prompt ${i}`);
// prompt is optional only when a template_id supplies the generation.
if (!text && !template_id)
warnings.push(`⚠️ prompt is required (unless template_id is set). Prompt ${i}`);
}
if (warnings.length > 0) {
warnings.forEach(warning => console.warn(warning));
console.error(`⛔ Execution stopped due to warnings.`);
process.exit(1);
}
for (let i = 0; i < prompts.length; i++) {
const prompt = prompts[i];
while (true) {
const responseCode = await submitVideo(apiToken, email, prompt, i + 1);
if (responseCode == 429)
await sleep(SLEEP_429);
else
if (responseCode == 412) {
process.exit(1);
} else
break;
}
}
}
// Utility function to check if a file exists
async function fileExists(path) {
try {
await fs.access(path);
return true;
} catch {
return false;
}
}
// Function to prompt user input
async function promptUser(query) {
const rl = readline.createInterface({
input: process.stdin,
output: process.stdout
});
return new Promise((resolve) => rl.question(query, answer => {
rl.close();
resolve(answer);
}));
}
function diffInMinutesAndSeconds(date1, date2) {
const diffInSeconds = Math.floor((date2 - date1) / 1000);
return `${Math.floor(diffInSeconds / 60)} minutes ${diffInSeconds % 60} seconds`;
};
main();
Examples
Real PixVerse clips generated through this PixVerse API, taken straight from our release notes.
v6 » Dramatic courtroom scene (text-to-video, 15s 1080p, multi-shot + audio)
From PixVerse v6: Multi-Shot Storytelling and Audio. Generated with multi_shot: true and audio: true — multiple camera angles and synchronized dialogue in a single 15-second clip.
v5.6 » Playing guitar and singing (image-to-video, integrated audio)
From PixVerse v5.6: Integrated Audio Generation. Animated from a still passed as first_frame_path with audio: true.
v5.6 » Motion Control (retarget motion onto a character image)
From PixVerse: Motion Control. A still character image (frame_1_path) is driven by motion extracted from a reference video (video_1_path) via POST videos/motion-control.
Frequently asked questions
Is there a PixVerse API? Yes — two ways. PixVerse.ai offers an official platform API billed against a separate API subscription. Or use useapi.net’s PixVerse API, which drives your own consumer PixVerse account through a standard REST endpoint. The differentiators: you spend your existing web subscription credits (with the Off-Peak discount, which the official API does not support), you get the full 900+ effect catalog instead of the official API’s 1/3/5 options, and the same single endpoint also exposes third-party models (Seedance, Kling, Veo 3.1, Sora 2, Grok, HappyHorse) that you would otherwise call through separate providers.
What models can I use? The default is native PixVerse V6. The same videos/create endpoint also accepts v5.6, v5.5, v5, v5-fast, and pixverse-c1, plus third-party seedance-2.0 / seedance-2.0-fast, kling-o3 / kling-v3, veo-3.1-lite / veo-3.1-standard / veo-3.1-fast, sora-2 / sora-2-pro, grok-imagine, and happyhorse-1.0. See Supported models and Model Capabilities.
Can I generate audio and multi-shot video? Yes. Set audio: true for integrated voice, dialogue, and background sound (a toggle on v6, v5.6, v5.5, pixverse-c1, Seedance, and Kling; always on for veo-3.1-standard / veo-3.1-fast / happyhorse-1.0). Multi-shot storytelling is v6-only via multi_shot: true. See Audio, multi-shot & effects.
Can I do image-to-video? Yes. Upload your starting frame with POST files, then pass the returned path as first_frame_path on videos/create. For image-to-video, aspect_ratio is derived from the image and must not be set.
How much does it cost? You keep your own PixVerse subscription and add a flat $15/month to useapi.net for API access to all services. Each generation then spends PixVerse credits from your plan — and native models can run far cheaper with off_peak_mode (Pro 30% off, Premium 50% off, Ultra free) or preview_mode (20% off). See Pricing and the interactive calculator.
Do I need PixVerse credits, or are they included? Credits come from your own PixVerse plan — useapi.net does not resell them. The $15/month is purely for API access. A 412 response from videos/create means your PixVerse credits are exhausted.
Conclusion
Visit our 
Discord Server or 
Telegram Channel for any support questions and concerns.
We regularly post guides and tutorials on the 
YouTube Channel.
Check our GitHub repo with code examples.