# varg.ai — full context for AI assistants and coding agents

> varg.ai is an AI video platform for teams and AI agents: an agent turns a brief into finished ads, product videos and talking heads, and the same 120+ generative models (Seedance, Kling, Veo 3.1, Wan, MiniMax, Nano Banana, GPT Image, Flux, ElevenLabs and more) are available as a video and image generation API, an MCP server and a TypeScript SDK on one credit balance.

Facts checked 2026-10-08 against varg.ai, docs.varg.ai and the live model catalog (version 2026-10-07). Models and prices change often. Before quoting a model ID or a price, read the live catalog (https://api.varg.ai/v2/models) and price list (https://api.varg.ai/v2/pricing). Short index: https://varg.ai/llms.txt. All docs as Markdown: https://docs.varg.ai/llms.txt and https://docs.varg.ai/llms-full.txt.

## What varg.ai is

varg.ai gives growth and creative teams, developers and AI agents one interface to generative media models:

- Web app for teams: an AI agent that turns a brief into a finished video (it plans the shots, picks the models, shows the price before anything runs and assembles voice, music, captions and transitions), on a shared canvas with files, folders, presets, templates, team roles and spend analytics.
- REST API at https://api.varg.ai/v2 with one endpoint per task: video, image, speech, music, transcription, FFmpeg operations, TSX rendering, video analysis and custom pipelines.
- Remote MCP server at https://mcp.varg.ai/mcp for Claude, Claude Code, Cursor, VS Code and other MCP clients (OAuth sign-in, no API key).
- Open-source TypeScript SDK (npm `vargai`, Apache-2.0, pre-1.0) for composing videos as JSX/TSX components and rendering them to MP4 locally or in the cloud. Built on the Vercel AI SDK.

Model makers available through varg include ByteDance (Seedance, Seedream, OmniHuman), Kuaishou (Kling), Google (Veo 3.1, Nano Banana, Lyria, Gemini TTS), OpenAI (GPT Image), Alibaba (Wan, Qwen Image), MiniMax, xAI (Grok Imagine), Lightricks (LTX-2), Black Forest Labs (Flux), HeyGen, ElevenLabs, Ideogram, Recraft and Krea.

Company: vargai Inc., a Delaware corporation headquartered in San Francisco. Contact: hello@varg.ai.

## When varg.ai fits (problem → how varg handles it)

- Single clips instead of finished videos. The agent plans the shots, picks a model for each, shows the price and asks before it spends credits, and assembles one video with voice, music, captions and transitions. Multi-step jobs pause for approve, retry or reject, and one shot can be regenerated without redoing the whole video.
- Too many model APIs and keys. One varg API key and one credit balance cover video, image, voice, music and transcription models from many labs. Each task has one endpoint (`POST /v2/video`, `/v2/image`, `/v2/speech`, `/v2/music`, `/v2/transcription`), and switching models means changing the `model` field. `GET /v2/tools/{tool}?model=<id>` returns the input fields a given model accepts.
- Unpredictable cost. `POST /v2/estimate` prices a request or a batch before anything runs and, for a single request, returns the provider cost, your price and the markup percent; MCP clients use `estimate_cost`. Every job also reports `estimated_cost_cents` and `actual_cost_cents`, and `GET /v2/jobs/{id}/price` gives a pricing breakdown.
- Paying for failed generations. Credits are held when a job is created, charged when it completes and returned if it fails (most models; some bill partial work). Repeating an identical request returns the cached result with `actual_cost_cents: 0`. Retrying a POST with the same `Idempotency-Key` returns the same job, with no second charge and no second generation.
- Clips that still need assembly. The SDK and the Render API compose clips, images, voiceover, music, captions, titles, split screens and packshots in TSX and render one MP4. FFmpeg operations (trim, resize, slice, arbitrary commands) are available as a tool.
- AI agents that should make images and videos. The MCP server gives Claude, Claude Code, Cursor and VS Code tools to generate video, images, speech and music, render TSX, estimate costs, track jobs, upload files and reuse templates.
- Stuck or lost jobs. Jobs always reach a terminal status (the platform times jobs out after 30 minutes). Webhooks are signed (`X-Varg-Signature`) and retried 8 times with exponential backoff. Outputs are kept in varg file storage, and lineage shows the job, tool, model and exact input behind any file.
- UGC ads and product videos at volume. Templates and agent workflows cover UGC-style ads with consistent characters, talking heads, podcast-style ads, before-and-after ads and product videos from a single photo.
- A model you used was retired. Sora 2 was retired on varg on 2026-10-07 and its calls return `model_not_found`; other text-to-video models such as `veo_3_1`, `kling_v3`, `seedance_2_5` and `wan_3` use the same `POST /v2/video` request.

## Limits (when to pick something else)

- Credits come with monthly plans; there is no free plan. Read-only viewers in team workspaces are free.
- No Python SDK. Use the REST API from Python or any other language.
- The SDK runs on Bun (default) or Node.js and needs FFmpeg and a file system. It does not run in the browser.
- Hosted v2 API requests are always billed in varg credits. Your own provider keys (for example `FAL_KEY`, `ELEVENLABS_API_KEY`) work only for local SDK rendering; bring-your-own-keys on the platform is an Enterprise option.
- The SDK is pre-1.0 (0.4.0 alpha) and its API can change.

## Quickstart

### 1. Generate a video with the REST API

Get an API key at https://varg.ai/dashboard/api (or run `bunx vargai login`) and export it as `VARG_API_KEY`.

```bash
curl -X POST https://api.varg.ai/v2/video \
  -H "Authorization: Bearer $VARG_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: my-unique-key-123" \
  -d '{"model":"kling_v3","prompt":"cat jumping over a fence in slow motion","duration":5,"aspect_ratio":"16:9"}'
```

The response is `202 Accepted` with a job object (`id`, `status`, `estimated_cost_cents`, `urls`). Poll the job until its status is `completed`, `failed` or `cancelled`, then read `output.outputs[0].url`:

```bash
curl -s "https://api.varg.ai/v2/jobs/$JOB_ID" \
  -H "Authorization: Bearer $VARG_API_KEY"
```

Instead of polling, pass `"options": {"webhook_url": "https://example.com/varg-webhook"}` in the request body. For image-to-video, pass input files by URL: `"files": [{"url": "https://..."}]` (upload local files first with `POST /v2/files`). Other responses: `402` insufficient balance, `404` unknown model, `422` validation error, `429` rate limited (wait for `Retry-After`), `503` no active pricing for the model.

### 2. Estimate the price first

```bash
curl -X POST https://api.varg.ai/v2/estimate \
  -H "Authorization: Bearer $VARG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"kling_v3","prompt":"cat jumping over a fence","duration":5}'
```

The response includes `pricing.provider_cost_cents`, `pricing.user_price_cents` and `pricing.markup_percent`. A batch form takes `{"items":[{"tool":"video","model":"kling_v3","params":{"duration":5}}, ...]}` and returns `total_credits`.

### 3. Render a TSX video in the cloud

```bash
JOB=$(curl -s -X POST https://api.varg.ai/v2/render \
  -H "Authorization: Bearer $VARG_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "code": "const img = Image({ model: fal.imageModel(\"nano_banana_pro\"), prompt: \"a cabin in mountains at sunset\", aspectRatio: \"16:9\" });\nexport default (<Render width={1920} height={1080}><Clip duration={3}>{img}</Clip></Render>);"
  }')

JOB_ID=$(echo $JOB | jq -r '.id')
```

Poll `GET /v2/jobs/$JOB_ID` as above; the MP4 URL is in `output.outputs[0].url`.

### 4. Compose and render locally with the SDK

```bash
bun install vargai ai     # or: npm install vargai ai
```

```tsx
/** @jsxImportSource vargai */
import { Render, Clip, Image, Video } from "vargai/react"
import { createVarg } from "vargai/ai"

const varg = createVarg({ apiKey: process.env.VARG_API_KEY! })

const character = Image({
  model: varg.imageModel("nano-banana-pro"),
  prompt: "cute kawaii fluffy orange cat character, round body, big eyes, Pixar style",
  aspectRatio: "9:16",
})

export default (
  <Render width={1080} height={1920}>
    <Clip duration={5}>
      <Video
        prompt={{
          text: "character waves hello enthusiastically, bounces up and down",
          images: [character],
        }}
        model={varg.videoModel("kling-v3")}
      />
    </Clip>
  </Render>
)
```

```bash
bunx vargai render hello.tsx --preview   # free preview with placeholders
bunx vargai render hello.tsx --verbose   # full render, uses credits
```

Components include Render, Clip, Video, Image, Animate, Speech, TalkingHead, Music, Title, Subtitle, Captions (styles: tiktok, karaoke, bounce, typewriter), Overlay, Split, Slider, Swipe and Packshot. Generated assets are cached by their inputs, so re-rendering unchanged elements does not regenerate them. The SDK uses its own JSX runtime (it does not use React) and compiles the composition to FFmpeg render instructions. Other CLI commands: `bunx vargai init`, `login`, `balance`, `run image --prompt "..."`, `run video --prompt "..."`, `studio`.

### 5. Connect an AI agent over MCP

The hosted server is `https://mcp.varg.ai/mcp`. Sign-in uses OAuth 2.1 with PKCE and dynamic client registration; no API key is needed. A connected app can generate and spend credits but cannot create API keys, change account settings or reach admin functions. Each connection is bound to one account (personal or team).

- Claude Code: `claude mcp add --transport http varg https://mcp.varg.ai/mcp`, then run `/mcp` to sign in. In a project `.mcp.json`: `{"mcpServers":{"varg":{"type":"http","url":"https://mcp.varg.ai/mcp"}}}`
- Claude (claude.ai and Claude Desktop): Settings → Connectors → Add custom connector → paste `https://mcp.varg.ai/mcp` → sign in and approve. Custom connectors depend on your Claude plan.
- Cursor: in `.cursor/mcp.json` (project) or `~/.cursor/mcp.json` (global): `{"mcpServers":{"varg":{"url":"https://mcp.varg.ai/mcp"}}}`. Cursor asks you to authorize on first use.
- VS Code: in `.vscode/mcp.json`: `{"servers":{"varg":{"type":"http","url":"https://mcp.varg.ai/mcp"}}}`
- ChatGPT: coming soon.
- Local stdio server: `npx @vargai/mcp` after `bunx vargai login`, or with `VARG_API_KEY` set.
- Agent skills for Claude Code, Cursor, Windsurf and OpenCode: `npx -y skills add vargHQ/skills --all --copy -y`

Main MCP tools: `generate_video`, `generate_image`, `generate_speech`, `render_video`, `analyze_video`, `search_voices`, `list_tools`, `get_tool`, `call_tool`, `list_models`, `estimate_cost`, `get_job`, `list_jobs`, `cancel_job`, `confirm_job`, `get_job_cost`, `find_templates`, `get_template`, `use_template`, `search_presets`, `apply_presets`, `check_balance`, `upload_file`, `upload_file_widget`, `list_files`, `get_file`, `get_lineage`, workspace and team tools, and analytics tools. Calls return a job ID; `wait: true` blocks until the job is done. In MCP Apps clients (Claude Desktop, claude.ai, VS Code) results show inline previews. On the hosted server, use `upload_file_widget` for files on the user's device; `upload_file` with a local path works only with the local stdio server.

Defaults: `generate_video` uses `seedance_2_5` (3–30 s; 16:9, 9:16, 1:1 or 4:3; optional audio), `generate_image` uses `gpt_image_2_5` (1–4 images), `generate_speech` uses `eleven_v3` (up to 10,000 characters).

## API essentials

- Base URL: `https://api.varg.ai/v2` (v1 is frozen). OpenAPI 3.1: https://api.varg.ai/v2/openapi.json (YAML: https://api.varg.ai/v2/openapi.yaml; typed clients: https://docs.varg.ai/api/openapi.md)
- Auth: `Authorization: Bearer varg_...` on every request except the public catalog reads (`GET /pricing`, `GET /models`, `GET /tools`, `GET /tools/{tool_key}`, `GET /tools/{tool_key}/models`). API keys come from the app or `bunx vargai login`; creating or listing keys needs an app session, so a leaked API key cannot mint new keys.
- Generation: `POST /video`, `/image`, `/speech`, `/music`, `/transcription`, `/ffmpeg`, `/render`, `/pipeline`, `/video/analyze`
- Tools: `GET /tools`, `GET /tools/{tool_key}` (add `?model=<id>` for one model's fields), `GET /tools/{tool_key}/models` (models with routes, prices, a real example and the input schema), `POST /tools/{tool_key}/call`
- Model specs as Markdown: `https://varg.ai/models/<model>.md` for one model (inputs, limits, provider options, routes, prices, the exact REST and MCP call), `https://varg.ai/models/llms.txt` for the index, `https://varg.ai/models/llms-full.txt` for all of them
- Jobs: `GET /jobs`, `GET /jobs/{id}`, `GET /jobs/{id}/status`, `GET /jobs/{id}/price`, `POST /jobs/{id}/refresh`, `/cancel`, `/retry`. Lifecycle: queued → submitting → running → completed | failed | cancelled.
- Files: `POST /files` (upload), `POST /files/import` (by URL), `POST /files/probe`, `GET /files/check` (by hash), `GET /files`, `GET /files/{id}`, `DELETE /files/{id}`
- Lineage: `POST /lineage` resolves a file to the job that created it.
- Pricing and billing: `POST /estimate`, `GET /pricing` (public), `GET /billing/balance`, `GET /billing/usage`, `GET /billing/transactions`
- Public model catalog: `GET https://api.varg.ai/v2/models`
- Request fields for `POST /video`: `model` (required), `prompt` (up to 2,000 characters), `aspect_ratio`, `duration` (seconds), `files` (up to 10 URLs), `provider_options` (provider-native overrides), `options.webhook_url`.
- Rate limits: sliding window per API key; on `429`, wait `Retry-After` seconds and retry with the same `Idempotency-Key`.
- Errors: `{"error": {"code", "message", "details"}}`

## Models (catalog version 2026-10-07)

The live catalog lists 120+ generative models. Model IDs below are API IDs; the live list is at https://api.varg.ai/v2/models.

### Video
- Seedance (ByteDance): `seedance_2_5` (default), `seedance_2`, `seedance_2_preview`, `seedance_2_fast_preview`, `seedance_2_mini`
- Kling (Kuaishou): `kling_v3`, `kling_v3_standard`, `kling_v3_4k_image_to_video`, `kling_v3_4k_reference_to_video`, `kling_v3_pro_reference_to_video`, `kling_v3_pro_motion_control`, `kling_v3_standard_motion_control`, `kling_v3_standard_v2v_reference`, `kling_v2_6`, `kling_v2_6_motion`, `kling_v2_5`, `kling_v2`
- Veo (Google): `veo_3_1`, `veo_3_1_fast`, `veo_3_1_lite`; Gemini Omni Flash 1.1 (`omni_flash_1_1`)
- Wan (Alibaba): `wan_3` (up to 30 s at 1080p with native audio), `wan_2_5`, `wan_2_5_preview`; Happy Horse (`happy_horse`)
- MiniMax: `minimax_h3`, `minimax_h3_max`, `minimax_h3_max_turbo`
- Grok Imagine (xAI): `grok_imagine_1_5`, `grok_imagine_1_5_lite`, `grok_imagine`, `grok_imagine_edit`
- LTX-2 (Lightricks): `ltx_2_19b_distilled`, `ltx_2_a2v` (audio-to-video)
- Flux 3 video (Black Forest Labs): `flux_3`, `flux_3_draft`
- HeyGen: `heygen_video_1`, `heygen_avatar_iv`, `heygen_avatar_v`, `heygen_avatar`
- Lipsync and talking heads: `sync_v3`, `sync_v2_pro`, `sync_v2`, `veed_fabric_1_0` (image + audio to talking video), `omnihuman_v1_5` (full-body animation from image + audio)
- Video upscaling: `topaz_video`, `seedvr_video`, `sima_video_upscaler`, `bytedance_upscaler`

### Image
- GPT Image (OpenAI): `gpt_image_2_5` (default), `gpt_image_2_5_flare`, `gpt_image_2_5_sunburst`, `gpt_image_2`, `gpt_image_1_5`, `gpt_image_1_mini`, `chatgpt_image_latest`
- Nano Banana (Google): `nano_banana_2_1`, `nano_banana_pro`, `nano_banana_2`, `nano_banana_2_lite`, plus `nano_banana_pro/edit` and `nano_banana_2/edit`
- Flux (Black Forest Labs): `flux_3_image`, `flux_pro`, `flux_dev`, `flux_schnell`
- Seedream (ByteDance): `seedream_5_pro`, `seedream_5_lite`, `seedream_v4_5/edit`
- Others: Ideogram 4.5 (`ideogram_v4_5`, text in images), Qwen Image 3 (`qwen_image_3`), Qwen Angles (`qwen_angles`), Recraft v3 (`recraft_v3`), Krea 2 (`krea_2`, `krea_2_medium`, `krea_2_medium_turbo`), Grok Imagine Image 2.0 (`grok_imagine_image_2`), Meta Muse Image (`muse_image`), Higgsfield Soul (`soul`), Phota (`phota`, `phota/edit`, `phota/enhance`)
- Image upscaling: `topaz`, `seedvr`, `clarity_upscaler`, `recraft_clarity`, `aura_sr`, `ccsr`

### Speech
- ElevenLabs: `eleven_v3` (default), `eleven_v4`, `eleven_v4_turbo`, `eleven_multilingual_v2`, `eleven_flash_v2_5`, `eleven_turbo_v2_5`
- Google: `gemini_3_8_flash_tts`, `gemini_3_8_flash_lite_tts`
- Voices and styles are found with `search_presets` / `search_voices`.

### Music
- ElevenLabs Music v2.5 (`eleven_music_v2_5`): songs with vocals or instrumentals
- Google Lyria 3.5 (`lyria_3_5`): full songs with vocals and lyrics, or instrumentals

### Transcription
- Whisper: `groq_whisper_large_v3_turbo`, `groq_whisper_large_v3`, `whisper`, `whisper_large_v3`; word-level timestamps

### Other tools
- `ffmpeg`: trim, resize, slice and arbitrary FFmpeg commands on video and audio files
- `render`: TSX to MP4
- `video_analyze`: a video URL in, a JSON report out (summary, visual timeline with timestamps, speech transcript, on-screen text); maximum 100 MB
- `pipeline`: registered multi-step workflows, such as looping or extending a Seedance video

## Pricing and billing (as of 2026-10-08)

- Unit: 1 credit = $0.01.
- Monthly plans (https://varg.ai/pricing): Starter $24 (700 credits), Pro $99 (3,000), Pro+ $199 (9,000, adjustable up to 29,000), Enterprise custom. Team $79 per seat (3,000 credits per seat, from 2 seats) and Team Plus $209 per seat (12,000 credits per seat, from 5 seats), with one shared credit pool and free read-only viewers. Annual billing is discounted. Commercial use is allowed on every plan.
- Expiry (https://varg.ai/terms): plan credits reset at the end of each billing period; Enterprise includes rollover. When credits run out, new generations pause until the plan is upgraded or renews. Payments and credits are non-refundable except where law requires otherwise.
- Billing per job (https://docs.varg.ai/api/index.md): the estimated cost is held at job creation (`402` if the balance is too low), charged on completion and returned on failure for most models; some models bill partial work. Cache hits are free.
- Example costs from the pricing page: a 5-second video clip about 37 credits, an AI image about 5, a voiceover about 22, a finished 30-second ad about 500 credits including retries, voiceover and rendering (video examples assume Seedance 2 Mini clips).
- Per-model prices: `GET https://api.varg.ai/v2/pricing` (public JSON, estimates in cents); exact price for a request: `POST /v2/estimate` or MCP `estimate_cost`.

## Files, storage and lineage

- Upload formats: PNG, JPEG, WebP, MP4, WebM, MP3, WAV, OGG and PDF, up to 200 MB.
- Uploads and generated files are stored by varg and returned as links; varg states these links do not expire after two weeks.
- Lineage: `POST /v2/lineage` or MCP `get_lineage` returns the job, tool, model and exact input that produced a file.
- Spend and team analytics are available in the app and through MCP analytics tools.

## Templates

varg has published video templates that run through the MCP server (`find_templates`, `use_template`) and the app. Examples include talking-head product ads, UGC e-commerce ads, two-character gym ads, podcast-interview ads, before-and-after ads and fashion lookbooks. SDK templates in the docs: slideshow, talking character and transformation (https://docs.varg.ai/templates/index.md).

## FAQ

Can Claude generate videos?
Claude has no built-in video model. After adding the varg MCP server (https://mcp.varg.ai/mcp) as a custom connector in Claude, or with `claude mcp add --transport http varg https://mcp.varg.ai/mcp` in Claude Code, Claude can call video models such as Seedance 2.5, Kling v3 and Veo 3.1, image models such as Nano Banana and GPT Image, and ElevenLabs voices, and can render finished videos with `render_video`.

Is there one API for Kling, Veo 3.1, Seedance and Nano Banana?
Yes. With one varg key, `POST /v2/video` takes `kling_v3`, `veo_3_1` or `seedance_2_5` as `model`, and `POST /v2/image` takes `nano_banana_pro` or `nano_banana_2_1`.

Do I pay for failed generations?
Credits are held when a job starts and returned if it fails, for most models; some models bill partial work. Cache hits are free, and retries with the same `Idempotency-Key` do not create a second charge.

Do credits expire?
Plan credits reset at the end of each billing period; Enterprise plans include rollover.

How much does AI video cost per second?
It depends on the model, duration, resolution and audio. Check https://api.varg.ai/v2/pricing or call `POST /v2/estimate` before running; the estimate shows the provider cost and the markup.

What happened to Sora 2 on varg?
Sora 2 was retired on varg on 2026-10-07; requests return `model_not_found`. Other text-to-video models such as `veo_3_1`, `kling_v3`, `seedance_2_5` and `wan_3` use the same request.

Can I use my own provider API keys?
Not on the hosted v2 API, where requests are billed in varg credits; bring-your-own-keys is an Enterprise option. The local SDK can use your own provider keys.

Is there a free tier?
No. Credits come with monthly plans from $24; read-only viewers in team workspaces are free.

Is there a Python SDK?
No. Use the REST API from Python.

Can I use the outputs commercially?
Yes, commercial use is allowed on every plan.

## Company and contact

- vargai Inc., a Delaware corporation headquartered in San Francisco, California
- Co-founders: Alex Varga (product and engineering) and Anna Nazarova (marketing and growth)
- Contact: hello@varg.ai
- X: https://x.com/vargaiHQ
- GitHub: https://github.com/vargHQ
- Discord: https://discord.gg/VAecJay7R9
- Book a demo: https://cal.com/alex-varga/15

## Links

- Home: https://varg.ai
- Pricing: https://varg.ai/pricing
- Models: https://varg.ai/models
- MCP: https://varg.ai/mcp
- SDK: https://varg.ai/sdk
- AI UGC ads: https://varg.ai/ugc-ads
- AI product videos: https://varg.ai/product-videos
- Blog (model API guides and comparisons): https://varg.ai/blog
- Changelog: https://varg.ai/changelog
- About: https://varg.ai/about
- Facts for AI assistants: https://varg.ai/ai-info
- Docs: https://docs.varg.ai
- API overview: https://docs.varg.ai/api/index.md
- MCP server docs: https://docs.varg.ai/mcp-server.md
- OpenAPI: https://api.varg.ai/v2/openapi.json
- Terms: https://varg.ai/terms
- Privacy: https://varg.ai/privacy
- Acceptable use: https://varg.ai/acceptable-use
- Subprocessors: https://varg.ai/subprocessors