Name: GPU Video Generation — LTX-2 API
Brand: mastera-ai
SKU: api-mastera-ai-gpu-video-ltx2
Availability: InStock
Author: API Market

# GPU Video Generation — LTX-2 on NVIDIA RTX 5090

**MasterA AI GPU Video Generation (LTX-2)** turns a text prompt into a short cinematic video clip using **LTX-2 19B (distilled)**, the latest generation of Lightricks' LTX video model. A default job produces a **~5-second clip in about 30–60 seconds** of wall-clock time.

It runs on a dedicated, self-hosted **NVIDIA RTX 5090** powered by solar energy. No shared queue, no third-party cloud, no model-provider account — you send JSON, you get an MP4 back.

Generation is **asynchronous**. Typical flow:
1. **POST** your prompt and parameters to `/v1/video/generate` — returns immediately with a **`task_id`**.
2. **GET** `/v1/video/tasks/{task_id}` every 3–5 seconds until the task reports completed.
3. Download the finished clip from **`output_url`**.

---

## Features

- **LTX-2 19B distilled** — high-quality text-to-video on a single RTX 5090.
- **~30–60 seconds per clip** — fast enough to iterate in a working session.
- **Clip lengths 3, 5 or 10 seconds** — `length` parameter.
- **Quality presets** — `fast` (8 steps), `balanced` (12), `best` (16) via the `quality` param.
- **Resolution** — `sd` (768x512) or `hd` (1280x704) via the `resolution` param.
- **Reproducible** — pass a fixed `seed` to repeat a generation exactly.
- **Solar-powered, self-hosted** — inference runs on MasterA AI's own renewable-powered GPU.
- **Async with polling** — POST returns instantly; your threads are never blocked.

---

## Pricing

Billed **per API call** (per generated clip). Flat **$0.25/clip** regardless of quality or resolution.

| Plan | Price | Included | Overage | Rate limit |
|:-----|:------|:---------|:--------|:-----------|
| **Pay As You Go** | No monthly fee | — | **$0.25** per API call | 10 req/sec |
| **Pro** | **$38 / month** | **200** API calls | **$0.25** per additional call | 10 req/sec |

Both plans are soft-limited — traffic above the quota is billed rather than blocked.

> Every request through the proxy counts as a billed API call — including `GET /v1/video/tasks/{task_id}` polls. Poll every 3–5 seconds, never in a tight loop.

---

## API Documentation

### Base URL
```
https://prod.api.market/api/v1/mastera-ai/gpu-video-ltx2
```

### Authentication
Add your API.market key to every request:
```
x-api-market-key: YOUR_API_KEY
```
Get your key at [api.market](https://api.market/account/apiKeys). This is the only credential you need — authentication to MasterA AI's GPU backend is handled by the API.market proxy.

### Endpoints

| Method | Path | Description |
|:-------|:-----|:------------|
| `POST` | `/v1/video/generate` | Submit a text-to-video generation job |
| `GET` | `/v1/video/tasks/{task_id}` | Poll job status; `output_url` when completed |
| `GET` | `/v1/video/files/{filename}` | Download the finished MP4 |
| `GET` | `/v1/health` | Health check |

---

### POST `/v1/video/generate`

Generate a video from a text prompt. Returns immediately with a `task_id`.

**Request body**

| Field | Type | Required | Default | Description |
|:------|:-----|:---------|:--------|:------------|
| `prompt` | string | **Yes** | — | Text description of the video to generate. |
| `model` | string | No | `ltx2` | `ltx2` (LTX-2 19B) or `wan5b` (Wan 2.2 5B). |
| `quality` | string | No | `fast` | `fast` (8 steps), `balanced` (12), or `best` (16). |
| `resolution` | string | No | `sd` | `sd` (768x512) or `hd` (1280x704). |
| `length` | string | No | `5s` | Clip duration: `3s`, `5s`, or `10s`. |
| `seed` | integer | No | `0` | Seed for reproducible generation. |

**Example**
```bash
curl -X POST "https://prod.api.market/api/v1/mastera-ai/gpu-video-ltx2/v1/video/generate" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt":"A red fox running through fresh snow, slow motion, cinematic","model":"ltx2","quality":"balanced","resolution":"hd"}'
```

The response carries the **`task_id`** you poll with.

---

### GET `/v1/video/tasks/{task_id}`

Poll generation progress. A default clip takes ~30–60 seconds, so poll every **3–5 seconds** — each poll is a billed call.

```bash
curl "https://prod.api.market/api/v1/mastera-ai/gpu-video-ltx2/v1/video/tasks/TASK_ID" \
  -H "x-api-market-key: YOUR_API_KEY"
```

When the task is `completed`, the response includes **`output_url`** — download the MP4 from it (or use `/v1/video/files/{filename}`).

---

### GET `/v1/video/files/{filename}`

Download the finished MP4 for a completed task.

---

### GET `/v1/health`

Check that the GPU and gateway are up and see which models are loaded.

---

## Implementation Guide

### Python — generate and poll

```python
import time
import requests

BASE = "https://prod.api.market/api/v1/mastera-ai/gpu-video-ltx2"
HEADERS = {"x-api-market-key": "YOUR_API_KEY", "Content-Type": "application/json"}

def generate_video(prompt, quality="balanced", resolution="hd", length="5s", seed=0):
    payload = {"prompt": prompt, "model": "ltx2", "quality": quality,
               "resolution": resolution, "length": length, "seed": seed}
    task = requests.post(f"{BASE}/v1/video/generate", json=payload, headers=HEADERS, timeout=60)
    task.raise_for_status()
    task_id = task.json()["task_id"]
    deadline = time.time() + 300
    while time.time() < deadline:
        time.sleep(5)  # each poll is a billed call
        result = requests.get(f"{BASE}/v1/video/tasks/{task_id}", headers=HEADERS, timeout=30).json()
        status = str(result.get("status", "")).lower()
        if status == "completed":
            return result
        if status in ("error", "failed"):
            raise RuntimeError(result)
    raise TimeoutError(f"task {task_id} did not finish in 300s")

print(generate_video("A red fox running through fresh snow, slow motion, cinematic"))
```

### Node.js — generate and poll

```javascript
const BASE = "https://prod.api.market/api/v1/mastera-ai/gpu-video-ltx2";
const HEADERS = { "x-api-market-key": process.env.API_MARKET_KEY, "Content-Type": "application/json" };
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));

async function generateVideo(prompt, opts = {}) {
  const res = await fetch(`${BASE}/v1/video/generate`, {
    method: "POST", headers: HEADERS,
    body: JSON.stringify({ prompt, model: "ltx2", quality: "balanced", resolution: "hd", length: "5s", ...opts }),
  });
  if (!res.ok) throw new Error(`generate failed: ${res.status}`);
  const { task_id: taskId } = await res.json();
  const deadline = Date.now() + 300_000;
  while (Date.now() < deadline) {
    await sleep(5000);
    const result = await fetch(`${BASE}/v1/video/tasks/${taskId}`, { headers: HEADERS }).then((r) => r.json());
    if (result.status === "completed") return result;
    if (result.status === "error") throw new Error(JSON.stringify(result));
  }
  throw new Error(`task ${taskId} did not finish in 300s`);
}
```

---

## Performance Optimization

- **Draft the concept on a still model first.** A prompt that fails as an image will fail as a video for the same reasons, at a fraction of the cost. Sketch composition and style on [SDXL-Turbo](https://api.market/store/mastera-ai/gpu-sdxl) at $0.0025, then bring the working prompt here.
- **Keep clips short while iterating.** `length: "3s"` uses less GPU time per attempt. Raise it only once the prompt is settled.
- **Prompt for motion, not just subject.** LTX-2 responds to camera and movement language — "slow tracking shot", "handheld", "static camera", "orbiting" — far more than to added scene detail.
- **Use `best` quality only for finals.** `fast` is roughly half the time at a small quality cost; `balanced` is a good default.
- **Lock the `seed` while iterating.** Changing one phrase against a fixed seed isolates its effect instead of resampling the whole clip.
- **Poll at 3–5 seconds, not faster.** Polls cost the same as generation, and tighter polling will not make the GPU finish sooner.
- **Cache aggressively.** Identical inputs produce an identical clip, and at $0.25 a call a cache hit is the cheapest optimization available.

---

## FAQ

**Q: What model does this use?**  
A: LTX-2 19B (distilled), text-to-video only.

**Q: How long is the video?**  
A: `length` can be `3`, `5`, or `10` seconds.

**Q: How long does generation take?**  
A: ~30–60 seconds for a default clip. Longer clips and `best` quality take proportionally more time.

**Q: Does a longer clip cost more?**  
A: No. Billing is per API call, not per second.

**Q: What is the difference between the `quality` presets?**  
A:
- `fast` — 8 steps
- `balanced` — 12 steps
- `best` — 16 steps

Higher step counts add more detail but require more GPU time.

**Q: Is generation synchronous or asynchronous?**  
A: Asynchronous. `POST /v1/video/generate` returns a `task_id` immediately. Poll `GET /v1/video/tasks/{task_id}` for the result.

**Q: Do I need a MasterA AI account or a second API key?**  
A: No. `x-api-market-key` is the only credential required. API.market's proxy handles authentication to the GPU backend.

**Q: Can I generate a video from an image?**  
A: No. This endpoint supports text-to-video only.

**Q: Can I reproduce the same clip twice?**  
A: Yes. Pass the same `prompt`, `seed`, `quality`, `resolution`, and `length`.

**Q: Do status polls and health checks count against my quota?**  
A: Yes. They count at the same $0.25 rate as a generation. Poll every 3–5 seconds.

**Q: What happens if I exceed my Pro plan's 200 calls?**  
A: Nothing breaks. The plan is soft-limited, so additional calls are billed at $0.25 each rather than rejected.

**Q: What is the rate limit?**  
A: 10 requests per second. In practice, GPU processing time not request rate is the primary throughput limit.

**Q: Why is this described as solar-powered?**  
A: The GPU is self-hosted by MasterA AI on hardware powered by renewable solar energy, rather than running on rented third-party cloud infrastructure.

**Q: Have more questions?**  
A: Email info@mastera-ai.com.

Fast text-to-video with LTX-2 19B on a dedicated RTX 5090. Cinematic ~5s clips in 30-60 seconds. Async job API, poll for results.