Skip to main content
skill CX Codex

text-to-video · pexoai — Claude Code skill: what it does, how to install

text-to-video turns a written prompt or script into a finished video with multiple shots, music, and subtitles. Use it when the video should start from text.

MIT 127 installs ★ 835 updated 2026-08-20

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add pexoai/pexo-skills --skill text-to-video -a claude-code
Open on GitHub

What text-to-video does

This skill sends a prompt or script to Pexo’s hosted agent. Pexo writes the script, selects a model for each shot from 10+ engines, renders the shots, and adds music, subtitles, and transitions.

The bundled scripts create a project, upload supplied files, send the request, poll its state, and fetch the final asset. Pexo cannot fetch files from URLs on its own, so download them before uploading and attach the required asset tag. The setup needs PEXO_API_KEY and PEXO_BASE_URL in ~/.pexo/config, plus curl, jq, and file. It is for text-to-video work, not for editing an existing video or animating an image.

What it helps with

  • create a video from a written brief
  • turn a script into a multi-shot video
  • add music and subtitles to a generated video
  • upload source files to a Pexo project
  • retrieve the rendered video asset

Example prompts for the agent

  • Create a video from this brief: a short launch piece for our coffee subscription.
  • Turn the script in script.txt into a finished video with music and subtitles.
  • Make a video from this description and use the uploaded logo.png file.

How to install text-to-video

1Skills CLI (Vercel)

npx skills add pexoai/pexo-skills --skill text-to-video -a claude-code

2Manually: put the files in place

~/.claude/skills/text-to-video/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/text-to-video/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about text-to-video

How do I install text-to-video in Claude Code?

Run npx skills add pexoai/pexo-skills --skill text-to-video -a claude-code, then check ~/.claude/skills/text-to-video/SKILL.md.

What does text-to-video do?

It sends a text request or script to Pexo, which chooses models for individual shots, renders the video, and adds music, subtitles, and transitions.

What does text-to-video need before it can run?

Set PEXO_API_KEY and PEXO_BASE_URL in ~/.pexo/config. The runtime also needs curl, jq, and file, and rendering uses Pexo credits.

Source text

SKILL.md · MIT
---
name: text-to-video
description: >
  Turn a text prompt or script into a finished, multi-shot video with Pexo. Auto-selects the
  best model across 10+ engines (Seedance, Kling, Veo, Sora), writes the prompts, generates
  every shot, and returns a publish-ready video with music and subtitles. Use when the user
  wants a video FROM TEXT: "make a video about X", "turn this script into a video", "text to
  video", "generate a video from this description". NOT for editing an existing video or
  turning an image into video (use the image-to-video skill).
homepage: https://pexo.ai
repository: https://github.com/pexoai/pexo-skills
version: "0.1.0"
requires:
  env: [PEXO_API_KEY, PEXO_BASE_URL]
  runtime: [curl, jq, file]
metadata:
  author: pexoai
---

# Text to Video — Pexo

**Pexo:** https://pexo.ai — get an API key, watch your project render, and buy credits there.

Turn a written prompt or script into a finished, publish-ready video. You do not generate
anything yourself: you hand the request to the hosted Pexo agent (same backend as `pexo-agent`,
scoped to text-to-video) and deliver the result. Pexo writes the script, picks the best model
per shot, generates every shot, and adds music, subtitles, and transitions.

## Your role: relay, don't create

Create a project, send the user's request **verbatim**, poll, deliver. Pexo's backend handles
all creative work — scriptwriting, model choice, prompts, music. Adding your own direction
(duration, style, models the user didn't ask for) overrides its judgment and produces worse
videos.

## Config

`~/.pexo/config`:
```
PEXO_BASE_URL="https://pexo.ai"
PEXO_API_KEY="sk-<your-api-key>"
```
**No account / first run →** read `references/SETUP-CHECKLIST.md` and walk the user through it — it carries the signup flow with the **invite code that grants new users bonus credits**, plus how to create the config above. **Config error →** run `scripts/pexo-doctor.sh` and follow its output.

## Workflow

Scripts live in this skill's `scripts/`. Reply to the user in their language.

1. **Create a project:** `pexo-project-create.sh "<short brief>"` → save the `project_id`.
2. **Upload any files** the user gave: `pexo-upload.sh <project_id> <path>` → save `asset_id`,
   reference it inline as `<original-image>asset_id</original-image>` (or `<original-video>` /
   `<original-audio>`). Tags are required — a bare `asset_id` is ignored. Pexo can't crawl URLs —
   download, then upload.
3. **Send the request:** `pexo-chat.sh <project_id> "<user's exact words> <asset tags>"`.
   Copy the user's words exactly; only add asset tags.
4. **Tell the user** (their language): submitted ✓ · ~15–20 min · `https://pexo.ai/project/<project_id>`.
5. **Poll:** every ≥60s run `pexo-project-get.sh <project_id>` and act on `nextAction`:
   - **WAIT** → keep polling; every ~5 polls send a one-line update with the project link.
   - **RESPOND** → handle each event in `recentMessages`: relay Pexo's text (wait for the
     user's answer if it asked, then `pexo-chat.sh` their reply); for `preview_video`, run
     `pexo-asset-get.sh <project_id> <assetId>` per option, show the URLs (A/B/C), let the user
     pick, then `pexo-chat.sh <project_id> "<choice>" --choice <assetId>`; for a `document`
     event, mention it to the user.
   - **DELIVER** → `pexo-asset-get.sh <project_id> <final assetId>`, then send the user the
     **full** asset URL as plain text — all `?…` query params, never truncated or wrapped in
     markdown — plus the project link.
   - **FAILED** → explain `nextActionHint` in plain terms and offer to retry.
   - **RECONNECT** → `pexo-chat.sh <project_id> "continue"`, tell the user the connection
     dropped and you're resuming, then keep polling.
   - Never call `pexo-chat.sh` during WAIT — it triggers duplicate production.
   - **Taking too long** → if it's been >30 min and still WAIT, tell the user (with the project
     link + `https://pexo.ai/connect/openclaw`) it's running long; ask whether to keep waiting or
     stop. Don't poll forever.

## Revisions

After delivery, the user's tweaks ("make it shorter", "new music", "different shot") reuse the
**same** project: `pexo-chat.sh <project_id> "<their feedback>"`, then poll again (step 5). Never
create a new project for a revision — it throws away Pexo's server-side context.

## Credits

If a script fails with "Credits balance" / "Insufficient credits": if the error carries a
purchase link, pass it to the user; otherwise tell them to add credits at `https://pexo.ai/home`
→ Credits → Buy Credits. Retry after they confirm.

## Example

User: "Make a 30-second video about our new coffee subscription."

```bash
pid=$(pexo-project-create.sh "coffee subscription promo")
pexo-chat.sh "$pid" "Make a 30-second video about our new coffee subscription."
# Tell the user: submitted, ~15–20 min, https://pexo.ai/project/$pid
# Poll pexo-project-get.sh "$pid" until nextAction is DELIVER, then deliver the asset URL.
```

## Scripts

| Script | Usage | Returns |
|---|---|---|
| `pexo-project-create.sh` | `"<brief>"` | `project_id` |
| `pexo-upload.sh` | `<project_id> <file>` | `asset_id` |
| `pexo-chat.sh` | `<project_id> "<message>" [--choice <id>]` | ack (async) |
| `pexo-project-get.sh` | `<project_id>` | JSON: `nextAction`, `recentMessages` |
| `pexo-asset-get.sh` | `<project_id> <asset_id>` | JSON with `url` |
| `pexo-doctor.sh` | — | setup diagnostic |

Error codes and edge cases → `references/TROUBLESHOOTING.md`.

© pexoai · MIT · pexoai/pexo-skills

Similar skills

All skills for AI and ML →

text-to-video by other authors comes first.

text-to-video omer-metin text-to-video is a Claude Code skill for generating videos from prompts or images and handling video-editing tasks. It activates for work involving Runway, Kling, Luma, Wan, or Replicate. CX Codex +1 156installs ai-video-generation 101-skills ai-video-generation is a Claude Code skill for generating videos with Google Veo, Seedance, HappyHorse and 40+ models. It turns text and images into video, syncs lips and generates audio. CX Codex +1 1,000,000installs eachlabs-video-generation eachlabs eachlabs-video-generation creates new videos from text prompts, source images, or motion references via the EachLabs API. Useful when your agent needs to generate animations, speaking avatars, or scene transitions. CX Codex +1 525installs luma-video acedatacloud luma-video is a Claude Code skill that generates videos through Luma Dream Machine and the AceDataCloud API from text, reference images, or existing videos. CX Codex +1 251installs p-video 101-skills p-video generates videos from text prompts or still images using Pruna models via the belt CLI. Handy for creating 720p and 1080p clips directly in your agent terminal. CX Codex +1 14,500installs scenario-grok-imagine-video scenario-labs scenario-grok-imagine-video is a Claude Code skill for generating and editing video with Grok Imagine, from text and stills to references, prompt edits, extensions, and native audio with lip sync. CX Codex +1 839installs jimeng-api-video-gen wvlvik jimeng-api-video-gen generates MP4 clips via Volcengine Jimeng API from text prompts or images. Useful for creating short video assets directly inside coding agent chats. CX Codex +1 482installs

From the same set20

The whole set →
videoagent-director videoagent-director turns a text idea into a storyboard and generates images, video clips, and audio without manual prompt writing. CX Codex +1 567installs veo-3.2-prompter veo-3.2-prompter is a Claude Code, Codex, and Cursor skill that builds Google Veo 3.2 prompts from media and scene descriptions, triggered by Veo, Artemis, or video-generation requests. CX Codex +1 553installs image-to-video image-to-video animates still images into moving video clips with camera movement and music using the Pexo platform. CX Codex +1 132installs ai-video-generation ai-video-generation generates finished AI videos with music and subtitles through Pexo from text prompts, scripts, or images. CX Codex +1 130installs product-video This Claude Code skill sends product photos to Pexo to create a product video. It activates for e-commerce clip requests, not explainers or other non-product videos. CX Codex +1 123installs explainer-video Claude Code skill creates narrated explainer videos and tutorials via Pexo. Runs when requested to generate a product walkthrough or tutorial video. CX Codex +1 122installs video-ad Automates generating promotional video ads through the Pexo service using a product description or brief. CX Codex +1 120installs youtube-short-maker youtube-short-maker — a skill for Claude Code and Codex that dispatches video prompts to the hosted Pexo pipeline to produce 9:16 YouTube Shorts. Renders complete short-form clips with music and captions in 15–20 minutes. CX Codex +1 118installs

Project sponsors

Companies that keep this analytics open