Name: GPU Video Generation API — LTX-Video on RTX 5090 and 5080
Brand: mastera-ai
SKU: api-mastera-ai-gpu-video
Availability: InStock
Author: API Market

# GPU Video Generation — LTX-Video on NVIDIA RTX 5090 and 5080

**MasterA AI GPU Video Generation** turns a text prompt into a short video clip using **LTX-Video**, a DiT-based video model distilled for speed. A default job produces **97 frames at 25 fps — roughly 3.9 seconds of video — in about 30 seconds** of wall-clock time.

It runs on a dedicated, self-hosted **NVIDIA RTX 5090 and 5080** powered by solar energy. There is no shared queue, no third-party cloud in the path, and no model-provider account to create — you send JSON, you get a video back.

Generation is **asynchronous**. Typical flow:

1. **POST** your prompt and parameters to `/v1/ltx/generate` — the request returns immediately with a **`task_id`**.
2. **GET** `/v1/tasks/{task_id}` every few seconds until the task reports completion.
3. Read the generated video from the completed task payload.

At roughly **30 seconds per clip** and **$0.18 per call**, this sits between still-image generation and the large commercial video models: fast and cheap enough to iterate on, and short-form by design.

---

## Features

- **LTX-Video** — a distilled diffusion-transformer video model built for fast generation on a single GPU.
- **~30 seconds per clip** — short enough to iterate on a prompt in a working session rather than a batch run overnight.
- **~4-second clips by default** — 97 frames at 25 fps. Both `length` and `fps` are adjustable.
- **Negative prompting** — `negative_prompt` steers the model away from unwanted content, artefacts, and styles.
- **Frame-rate control** — `fps` sets playback rate; combined with `length` it determines clip duration.
- **Guidance control** — `cfg` sets classifier-free guidance strength; the distilled model defaults to `1`.
- **Dedicated RTX 5090 and 5080** — a single-tenant GPU, so your jobs are not queued behind other tenants' workloads.
- **Solar-powered, self-hosted** — inference runs on MasterA AI's own renewable-powered hardware, not on rented cloud GPUs.
- **Reproducible output** — pass a fixed `seed` to repeat a generation exactly.
- **Asynchronous with polling** — POST returns instantly, so your request threads are never blocked for 30 seconds of GPU time.
- **Health and status endpoints** — check GPU, gateway, and model state before dispatching work.
- **Single-header auth** — one `x-api-market-key` header. No seller account, no OAuth, no second credential.
- **Up to 10 requests/second** on both plans.

---

## Use Cases

- **Social-media short-form video** — 4-second clips are the right shape for TikTok, Reels, and Shorts openers, loops, and stingers.
- **Ad creative testing** — generate many motion variants of one concept cheaply, then test which performs before commissioning production work.
- **Animated backgrounds and loops** — ambient motion for websites, presentations, digital signage, and streaming overlays.
- **Storyboarding and previsualization** — see a shot move before committing a crew or a render farm to it.
- **Product and marketing motion** — turn a static concept into a short animated showcase for a landing page or email.
- **Concept exploration** — explore camera moves, pacing, and atmosphere for a scene in minutes rather than days.
- **Game and app motion assets** — looping textures, cutscene drafts, and animated placeholder art.
- **Music and audio visuals** — generate abstract or thematic clips to cut against a track.
- **Creative tooling** — embed text-to-video in your own editor, CMS, or agent with a few lines of HTTP.

---

## Pricing

| Plan | Price | Included | Overage | Effective rate | Rate limit |
|:-----|:------|:---------|:--------|:---------------|:-----------|
| **Pay As You Go** | No monthly fee | — | **$0.18** per API call | $0.18 | 10 req/sec |
| **Pro** | **$29.99 / month** | **300** API calls | **$0.18** per additional call | **$0.10** on included calls | 10 req/sec |

Pro is worth taking above roughly **167 calls a month** — below that, Pay As You Go is cheaper. Beyond the included 300, both plans bill at the same $0.18, so Pro's advantage is on the quota, not the overage.

Both plans are soft-limited: traffic above the quota is billed rather than blocked, so a spike degrades your bill, not your service.

> Every request through the proxy counts as a billed API call — including `GET /v1/tasks/{task_id}` polls, `/v1/health`, and `/v1/status`. At $0.18 a call, polling discipline matters here far more than it does on the image products: poll every **3–5 seconds**, never in a tight loop.

---

## API Documentation

### Base URL

```
https://prod.api.market/api/v1/mastera-ai/gpu-video
```

### 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/ltx/generate` | Submit a text-to-video generation job |
| `GET`  | `/v1/tasks/{task_id}` | Poll job status and retrieve the result |
| `GET`  | `/v1/health` | GPU, gateway, and loaded-model health |
| `GET`  | `/v1/status` | Model load and idle state on the GPU host |

---

### POST `/v1/ltx/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. |
| `negative_prompt` | string | No | `""` | Things to keep out of the video — artefacts, styles, objects. |
| `width` | integer | No | `768` | Output width in pixels. |
| `height` | integer | No | `512` | Output height in pixels. |
| `length` | integer | No | `97` | Number of frames. At the default `fps` of 25 this is ~3.9 seconds. |
| `fps` | integer | No | `25` | Frames per second. With `length`, determines clip duration. |
| `steps` | integer | No | `8` | Inference steps. Higher means more detail and more GPU time. |
| `cfg` | number | No | `1` | Classifier-free guidance scale. |
| `seed` | integer | No | `0` | Seed for reproducible generation. Pass the same non-zero seed with the same prompt and settings to repeat a result. |

> Clip duration is `length / fps`. To get a 6-second clip at 25 fps, set `length: 150`. Longer clips cost more GPU time but the same **$0.18 per call** — the price is per request, not per second.

**Example**

```bash
curl -X POST "https://prod.api.market/api/v1/mastera-ai/gpu-video/v1/ltx/generate" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cat walking through a sunlit field, slow tracking shot, shallow depth of field",
    "negative_prompt": "blurry, distorted, flickering, watermark, text",
    "width": 768,
    "height": 512,
    "length": 97,
    "fps": 25,
    "steps": 8,
    "cfg": 1,
    "seed": 42
  }'
```

The response confirms the task was created and carries the **`task_id`** you poll with.

---

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

Poll generation progress. A default clip takes around 30 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/v1/tasks/TASK_ID" \
  -H "x-api-market-key: YOUR_API_KEY"
```

---

### GET `/v1/health`

Confirm the GPU and gateway are up and see which models are loaded. Useful as a pre-flight check before dispatching work.

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

**Example response**

```json
{
  "status": "ok",
  "comfyui": true,
  "gateway": true,
  "gpu": "RTX 5080",
  "models": ["sdxl-turbo", "ltx-0.9.8-distilled", "flux.1-schnell"]
}
```

---

### GET `/v1/status`

Reports model load and idle state on the GPU host.

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

For day-to-day monitoring prefer `/v1/health`, which reports the GPU, the gateway, and the loaded model list directly.

---

## Status Codes

| Code | Meaning | What to do |
|:-----|:--------|:-----------|
| `200` | Success | Read the response body. |
| `400` | Bad request | A parameter is missing or invalid — `prompt` is required. |
| `401` | Invalid or missing API key | Send a valid `x-api-market-key` header. |
| `403` | Not subscribed / quota blocked | Subscribe to a plan on the product page. |
| `404` | Unknown `task_id` | Verify the id returned by the generate call; completed tasks are not retained indefinitely. |
| `429` | Rate limited | You exceeded 10 requests/second — back off and retry. |
| `5xx` | GPU or gateway error | Retry with backoff; check `/v1/health` if failures persist. |

---

## Rate Limits

Both plans allow up to **10 requests per second**. Requests above that return `429`.

The request-rate ceiling is not the real constraint here. Video generation is asynchronous and a single GPU works through the queue behind your `task_id`s, so at roughly 30 seconds per clip, steady throughput is on the order of **two clips per minute** regardless of how fast you submit. Treat 10 req/sec as a burst allowance for submissions and polls, and size your job queue against GPU time rather than request rate.

---

## Error Handling

- **Retry `429` and `5xx` with exponential backoff**, starting at 1 second and capping around 30 seconds.
- **Never retry `400` or `401`** — they will fail identically until the request or the key is fixed.
- **Never blind-retry a failed generation.** At $0.18 a call, an automatic retry loop on a bad prompt is an expensive way to fail. Log it and surface it.
- **Cap your polling loop.** Abort after ~300 seconds if a task never completes and surface a timeout to your caller.
- **Poll at 3–5 seconds.** Polls are billed calls at the same $0.18 rate as generation — tight polling can cost more than the clip itself.
- **Persist the `task_id`** so a crashed worker resumes polling instead of paying to regenerate.
- **Check `/v1/health` on repeated failures** to distinguish a GPU or gateway outage from a problem with your request.

---

## Implementation Guide

### Python — generate and poll

```python
import time
import requests

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

def generate_video(prompt, negative_prompt="", width=768, height=512,
                   length=97, fps=25, steps=8, cfg=1, seed=0):
    payload = {
        "prompt": prompt,
        "negative_prompt": negative_prompt,
        "width": width,
        "height": height,
        "length": length,
        "fps": fps,
        "steps": steps,
        "cfg": cfg,
        "seed": seed,
    }

    task = requests.post(f"{BASE}/v1/ltx/generate", json=payload, headers=HEADERS, timeout=60)
    task.raise_for_status()
    task_id = task.json()["task_id"]
    print(f"submitted {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/tasks/{task_id}", headers=HEADERS, timeout=30).json()
        status = str(result.get("status", "")).lower()
        if status in ("completed", "success", "done"):
            return result
        if status in ("failed", "error"):
            raise RuntimeError(result)

    raise TimeoutError(f"task {task_id} did not finish in 300s")

print(generate_video(
    "A cat walking through a sunlit field, slow tracking shot",
    negative_prompt="blurry, flickering, watermark",
    seed=42,
))
```

### Node.js — generate and poll

```javascript
const BASE = "https://prod.api.market/api/v1/mastera-ai/gpu-video";
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/ltx/generate`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({
      prompt,
      width: 768,
      height: 512,
      length: 97,
      fps: 25,
      steps: 8,
      cfg: 1,
      ...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); // each poll is a billed call
    const result = await fetch(`${BASE}/v1/tasks/${taskId}`, { headers: HEADERS }).then((r) => r.json());
    const status = String(result.status ?? "").toLowerCase();
    if (["completed", "success", "done"].includes(status)) return result;
    if (["failed", "error"].includes(status)) 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 50x 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.** Fewer frames means less GPU time per attempt. Raise `length` only once the prompt is settled.
- **Prompt for motion, not just subject.** LTX-Video responds to camera and movement language — "slow tracking shot", "handheld", "static camera", "orbiting" — far more than to added scene detail.
- **Use `negative_prompt` against temporal artefacts.** "flickering", "distorted", "morphing", "jittery" target the failure modes specific to video.
- **Lock the `seed` while iterating.** Changing one phrase against a fixed seed isolates its effect instead of resampling the whole clip.
- **Leave `cfg` near the default.** The distilled model is tuned for low guidance; pushing it up tends to produce artefacts rather than fidelity.
- **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.18 a call a cache hit is the cheapest optimization available.

---

## FAQ

**What model does this API use?**

LTX-Video, a distilled diffusion-transformer video model designed for fast single-GPU generation. It runs on a dedicated NVIDIA RTX 5090 and 5080.

**How long is the generated video?**

`length / fps` seconds. The defaults — 97 frames at 25 fps — give roughly 3.9 seconds. Raise `length` for longer clips.

**How long does generation take?**

About 30 seconds for a default clip. Longer clips and higher `steps` take proportionally more GPU time.

**Does a longer clip cost more?**

No. Billing is **per API call** at $0.18, not per second of output. A 6-second clip and a 4-second clip cost the same, though the longer one occupies the GPU longer.

**Is generation synchronous or asynchronous?**

Asynchronous. `POST /v1/ltx/generate` returns a `task_id` immediately, and you poll `GET /v1/tasks/{task_id}` for the result.

**Do I need a MasterA AI account or a second API key?**

No. `x-api-market-key` is the only credential. API.market's proxy handles authentication to the GPU backend.

**Can I generate video from an image?**

Not on this endpoint — LTX-Video here is text-to-video only. Set the opening look with prompt language instead.

**Can I reproduce the same clip twice?**

Yes. Pass the same `prompt`, `negative_prompt`, `seed`, and generation settings.

**What should I set `cfg` to?**

Leave it at the default of `1` unless you have a reason. The distilled model is tuned for low guidance, and raising it usually adds artefacts rather than detail.

**Do status polls and health checks count against my quota?**

Yes, and at the same $0.18 rate as a generation. Poll every 3–5 seconds, and never in a tight loop.

**What happens if I exceed my Pro plan's 300 calls?**

Nothing breaks. The plan is soft-limited, so additional calls are billed at $0.18 each rather than rejected.

**Which plan should I pick?**

Below about 167 calls a month, Pay As You Go. Above that, Pro's $29.99 for 300 calls works out cheaper per clip.

**What is the rate limit?**

10 requests per second on both plans. In practice GPU time, not request rate, is your throughput limit — expect around two clips per minute sustained.

**Why is this described as solar-powered?**

The GPU is self-hosted by MasterA AI on hardware running on renewable solar energy, rather than on rented third-party cloud infrastructure.

---

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


Fast text-to-video with LTX-Video on NVIDIA RTX 5090 and 5080. ~30 seconds per clip. Self-hosted GPU inference.