PixVerse CLI: Generate AI Videos and Images in Terminal

Introduction

Every creative workflow has a bottleneck — the moment you have to leave your code editor, open a browser, and manually click through a web interface to generate a piece of media. For developers, AI agents, and anyone building automated content pipelines, that context switch is friction that adds up fast.

PixVerse CLI eliminates that bottleneck. It is the official command-line interface for PixVerse, giving you access to PixVerse generation and workspace workflows directly from your terminal. Text-to-video, image-to-video, text-to-image, image-to-image, transitions, voice generation, music generation, reference video, motion control, templates, upscaling, and asset management are all scriptable, pipeable, and available without touching a browser.

What makes PixVerse CLI particularly useful is its design philosophy: it was built with AI agents in mind. Commands can return structured JSON with --json or -p, exit codes are deterministic, and every pipeline step is composable. This means you can teach Claude Code, Cursor, Codex, or any other agent to generate images, videos, voice, and music on your behalf with fewer fragile handoffs.

This guide is aligned with the current PixVerseAI/cli GitHub README and its public capabilities manifest, checked on June 29, 2026. Model availability, default models, and command flags can change faster than evergreen tutorials, so production scripts should still verify pixverse --version, pixverse create <mode> --help, and pixverse update before a large batch run.

Prerequisites

Before starting, you need:

• Node.js 20 or higher — check with node --version
• A PixVerse account — sign up at pixverse.ai
• An active PixVerse subscription — the CLI uses the same credit system as the website; only subscribed users can generate content

PixVerse CLI does not require any API keys to be manually copied. Authentication is handled through a browser-based OAuth flow that stores your token locally.

Step 1: Install the CLI

Install globally with npm:

Verify the installation:

If you prefer not to install globally, you can also run commands via npx:

Step 2: Authenticate

Run the login command:

The CLI opens a browser for OAuth device authorization. You can also copy the URL and finish authorization from any browser on any device, which is useful for SSH and headless environments. Your token is stored automatically in ~/.pixverse/ and is valid for 30 days.

To verify you are logged in and check your available credits:

The account info command shows your subscription tier, workspace credits, and usage context. pixverse account usage helps you review credit consumption, while pixverse account slots shows the current concurrent generation slots for image and video jobs. CLI sessions are independent from PixVerse web/app sessions, and you can remove the stored CLI token with pixverse auth logout. Always check your balance and available slots before running batch jobs.

Quick Start Commands

If you only need the shortest path from installation to a generated asset, start with this sequence:

npm install -g pixverse
pixverse auth login
pixverse create image --prompt "A photorealistic forest path at golden hour" --json
pixverse create video --prompt "A sunset over ocean waves" --model v6 --quality 720p --duration 5 --json

For agent and CI workflows, keep --json or -p enabled so stdout stays machine-readable while progress and errors stay on stderr. For production retries, add --idempotency-key <key> to creation commands so repeated submissions do not accidentally create duplicate charged jobs.

Step 3: Generate Your First Image

Text-to-image generation is the fastest way to test your setup. Run:

The current GitHub README lists GPT Image 2 as the default image model. For reproducible automations, still set --model explicitly and check the live CLI help or capabilities.json before batch work. The --json flag returns structured output:

For higher resolution output, specify a model that supports it:

PixVerse supports several image models, each with different resolution ceilings and aspect-ratio support:

You can also transform an existing image with image-to-image:

To download the generated image:

Step 4: Generate Your First Video

Text-to-video works the same way. Generate a 5-second clip:

For a fully customized generation:

The --audio flag enables AI-generated ambient sound that matches your video content. The --json flag returns a video_url on completion that you can pass directly to a download command or the next step in a pipeline.

PixVerse provides multiple video models with different quality, duration, and mode support:

Animate a Static Image

To turn a photo or generated image into a video, provide the --image flag:

You can pass a local file path or a URL. Local files are uploaded automatically — no manual upload step required. Local image inputs larger than 1920x1920 or 5MB are automatically resized or compressed before upload; remote image URLs are validated by the backend as-is.

For Grok Imagine 1.5, an image is required and the output aspect ratio follows that image:

Use Reference, Transition, Motion Control, and Templates

The current CLI supports more than simple text-to-video and image-to-video. These creation modes are useful when you need more control over characters, keyframes, edits, or effects:

Not every model supports every creation mode. In the current README matrix, create video supports v6, pixverse-c1, Seedance 2.0 Standard/Fast/Mini, Happy Horse 1.0, Kling O3, Kling 3.0, Grok Imagine, Veo 3.1, Sora 2, and v5.6. grok-imagine-1.5 is image-to-video only and requires --image; create extend supports v6 and grok-imagine; create reference supports v6, pixverse-c1, Seedance 2.0 Standard/Fast/Mini, Kling O3, grok-imagine, and v5.6; 2-frame transitions support the newer video families; 3+ frame transitions use v5; create modify uses v5.5; and create motion-control uses v5.6.

Step 5: Generate Voice and Music

The current GitHub README documents standalone audio through dedicated creation commands. Use create voice for text-to-speech and create music for prompt-to-music generation. Voice and music outputs are saved as audio assets, so you can track them with task, list them with asset list --type audio, and download them with asset download --type audio. For native video ambience, use --audio or --no-audio on supported video creation commands.

Generate voice audio:

Browse voice models and preset voices:

Generate music:

For instrumental tracks, use --instrumental. For lyrics-capable models, pass lyrics as literal text, a local file path, or stdin:

Current voice model families include MiniMax Speech 2.8 and ElevenLabs models. Current music model families include MiniMax Music, ElevenLabs Music, and Google Lyria 3 Pro. Use pixverse voice models and pixverse music models for the live catalog before scripting a production workflow.

Step 6: Run the Interactive Wizard

If you are exploring for the first time and are not yet familiar with all the available flags, run any creation command without arguments to enter the guided wizard:

The wizard walks you through prompt, model selection, quality, aspect ratio, duration, and other options step by step — useful for discovering what parameters are available before scripting them.

Beyond Generation: Manage Your Assets and Workspace

The current PixVerse CLI also includes management commands that help you build end-to-end terminal workflows:

• pixverse task status <id> and pixverse task wait <id> for task polling
• pixverse task status --ids 123,456,789 --type video --json for batch status checks
• pixverse asset list, asset upload, asset info, asset download, and asset delete for video, image, and audio asset lifecycle operations
• pixverse saved list, saved items, saved new, saved rename, saved add, saved remove, and saved delete for saved folders
• pixverse template categories, template list, template search, and template info for discovering effects and templates
• pixverse voice models, voice presets, and music models for live audio model discovery
• pixverse workspace list, workspace status, workspace switch, and workspace manage for multi-workspace operations
• pixverse account info, account usage, and account slots for credit, usage, and concurrency checks
• pixverse config set, config list, config path, and config defaults for repeatable local defaults

This makes it straightforward to automate not only creation, but also organization, template discovery, audio discovery, download, workspace routing, and delivery in one script. If you need to run one command against a different workspace, use the global --workspace-id <id> flag; 0 targets your personal workspace.

Script-Friendly Flags

Most automation depends on predictable output and predictable runtime behavior. These flags are especially useful in scripts and AI-agent workflows:

Text input flags are now easier to automate. --prompt, --text, and --lyrics can accept a literal string, a local file path, or - for stdin:

Teaching Your AI Agent to Generate Media

This is where PixVerse CLI becomes genuinely transformative. Because commands can return structured JSON and use deterministic exit codes, any AI agent that can run shell commands can be taught to generate images and videos on demand.

Installing PixVerse Skills

PixVerse Skills is a structured skill library that teaches agents how to use the CLI correctly: command flags, model constraints, multi-step pipelines, and robust error handling.

For Claude Code and other agents that support the skills format, add the PixVerse skills directly:

For Cursor, Claude Code, Codex, and other agent frameworks, this skill improves reliability by giving the agent explicit constraints instead of forcing it to infer them from scratch.

PixVerse CLI also ships a compact machine-readable command manifest at dist/capabilities.json, with the public source available as capabilities.json in the GitHub repository. This manifest describes commands, flags, exit codes, JSON output expectations, and effect categories, so agents can inspect the CLI contract without scraping help text.

Once your agent has the PixVerse skills loaded, you can give it natural-language instructions like:

• “Generate a 10-second product demo video from this screenshot”
• “Create four variations of this blog cover image in 16:9 format”
• “Animate this diagram into a 5-second explainer clip with ambient sound”
• “Generate three 8-second 16:9 promo clips with different camera motions”

The agent will translate those instructions into the correct CLI commands, parse the JSON output, and handle polling and downloads — no manual intervention required.

Claude Code

In Claude Code, PixVerse CLI becomes a native tool the agent uses autonomously. After loading the PixVerse skills, you can include media generation directly in any task:

Claude Code will invoke the correct CLI commands, parse the image URL from the JSON response, and download the file to your specified path — all within the same session where it is also writing your code.

A typical Claude Code workflow:

Cursor

Cursor users can load PixVerse Skills as a project context file. Place the relevant skill files in your .cursor/ directory or add them to your workspace rules. Once loaded, Cursor has full awareness of every PixVerse CLI command and can generate media as part of any coding task.

A common Cursor workflow: ask the agent to generate a mockup image based on a design you are building, then use it as a reference directly in your IDE session — without ever leaving the editor.

Codex and Other Agents

PixVerse CLI is compatible with any agent that can execute shell commands and parse JSON. The structured output format — consistent field names, predictable error codes, and stderr-separated error messages — ensures that even simple scripting agents can integrate generation reliably.

The exit code contract makes error handling straightforward:

Automation Pipelines

Once you understand the individual commands, PixVerse CLI unlocks powerful multi-step workflows that run entirely without user interaction.

Text to Image to Video

One of the most useful pipelines: generate a high-resolution image from a text prompt, then animate it into a video.

Full Video Production Pipeline

For polished output, chain creation with post-processing steps. Use --audio or --no-audio when you want native sound on supported video creation commands, then use create voice for text-to-speech audio and create music for standalone music assets that you will combine downstream:

Batch Generation

For content pipelines that require multiple variations, run jobs in parallel:

The --no-wait flag submits the job and returns immediately with a task ID, allowing you to submit multiple jobs before polling. With --no-wait --json, record the returned task IDs and resolved creation parameters for logging and reproducibility. Use --count <n> when you want multiple variations from one prompt, and use batch task status --ids when you want one status response for several running jobs. The pixverse task wait command handles adaptive polling for you.

Configuring Defaults

If you consistently use the same model, quality, or aspect ratio, set them as defaults so you do not have to repeat flags every time:

Command-line flags always override your configured defaults, so you retain full flexibility while reducing repetition. For workspace-specific automation, add --workspace-id <id> to a command when you want to override the active workspace for that single run.

What You Can Build

With PixVerse CLI integrated into your agent workflow, the range of automatable tasks expands considerably:

• Documentation — auto-generate product demo videos and screenshots as part of your doc build process
• Marketing — run nightly batch jobs that produce social media content variations from a single prompt library
• App development — let your coding agent generate placeholder visuals, mockup animations, or loading screen videos while you build the UI
• Audio workflows — generate voiceover drafts, prompt-to-music tracks, or audio assets for later editing
• Content pipelines — chain CLI calls with other tools (ffmpeg, ImageMagick, cloud storage) to build fully automated media production workflows
• Prototyping — generate quick motion concepts in seconds to validate ideas before committing to full production

The CLI is designed to fit naturally into any shell-based workflow. If your existing automation runs in bash, Python, Node, or a CI/CD pipeline, PixVerse CLI slots in without any additional integration overhead.

Getting Started Checklist

• Install Node.js 20 or higher
• Run npm install -g pixverse
• Run pixverse auth login and authorize in browser
• Run pixverse account info to verify credits
• Run pixverse account slots before concurrent batch work
• Generate your first image: pixverse create image --prompt "..." --json
• Generate your first video: pixverse create video --prompt "..." --json
• Generate your first voice asset: pixverse create voice --text "..." --json
• Generate your first music asset: pixverse create music --prompt "..." --json
• Explore templates with pixverse template list
• Install PixVerse Skills for your agent (Claude Code, Cursor, or Codex)
• Set up your preferred defaults with pixverse config defaults set
• Build your first automation pipeline

Keeping the CLI Up to Date

Use the built-in updater to keep your local CLI current:

You can also use npm directly:

For release-level changes and newly supported models, check the official CLI sources:

• PixVerse CLI GitHub repository
• PixVerse CLI capabilities manifest
• PixVerse CLI Changelog

The current docs highlight PixVerse V6 as the default video model, GPT Image 2 as the default image model, Seedance 2.0 Mini support, mode-specific PixVerse v5 and v5.5 workflows, dedicated create voice and create music commands, audio asset management, saved folders, workspace switching, config defaults, capabilities.json for agents, pixverse update, stdin support for text inputs, --trace-id, and --idempotency-key for safer retries.

Next Steps

The PixVerse CLI on GitHub and npm (npm install -g pixverse) give you immediate access to generation, task polling, asset management, templates, saved folders, account checks, audio model discovery, and workspace controls from a single interface. The PixVerse Skills repository adds agent-ready guidance so Claude Code, Cursor, Codex, and other tools can run these workflows with stronger reliability.

The combination of a reliable CLI and an agent-ready skill library means image, video, voice, and music generation can live in the same workflow as your code — managed by the same agent, in the same terminal, without switching tools.

Start with a single command. Build from there.