Name: GPU Image Generation API — SDXL-Turbo on RTX 5090 and 5080
Brand: mastera-ai
SKU: api-mastera-ai-gpu-sdxl
Availability: InStock
Author: API Market

# GPU Image Generation — SDXL-Turbo on NVIDIA RTX 5090 and 5080

**MasterA AI SDXL-Turbo** is the speed tier of MasterA AI's image lineup. It generates an image from a text prompt in roughly **2 seconds** using **SDXL-Turbo**, an adversarially distilled Stable Diffusion XL variant that produces a usable image in as few as **1–4 inference steps** instead of the 30–50 a standard SDXL pipeline needs.

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 an image back.

Generation is **asynchronous**. Typical flow:

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

Because a single job finishes in about two seconds, this is the model to reach for when **throughput or responsiveness matters more than maximum fidelity** — batch jobs, live previews, and anything a user is waiting on.

---

## Features

- **SDXL-Turbo** — adversarial diffusion distillation gives near-SDXL quality at a fraction of the step count.
- **~2 seconds per image** — the fastest model in the MasterA AI catalogue.
- **Few-step generation** — defaults to **4** steps; SDXL-Turbo is designed to work at 1–4.
- **Negative prompting** — `negative_prompt` steers the model away from unwanted content, artefacts, or styles. Not available on the Flux.1-Schnell product.
- **Dedicated RTX 5090 and 5080** — a single-tenant GPU, so your requests 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.
- **Configurable resolution** — `width` and `height` default to **512×512**, SDXL-Turbo's native training size.
- **Asynchronous with polling** — POST returns instantly, so your request threads are never blocked on GPU time.
- **Health and status endpoints** — check GPU, gateway, and model state before dispatching a batch.
- **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

- **Real-time and interactive generation** — a two-second round trip is short enough to put image generation directly in a UI, where a user types a prompt and watches the result appear.
- **High-volume batch jobs** — generate thousands of images per hour for catalogues, datasets, or content libraries at $0.0025 each.
- **Prompt exploration and drafting** — sweep dozens of prompt variations cheaply, then re-render the winner on a higher-fidelity model.
- **Social media content at scale** — post images, story backgrounds, and thumbnails generated per campaign or per post.
- **E-commerce and product imagery** — lifestyle scenes, category art, and packaging concepts without a photoshoot.
- **Blog and editorial illustration** — a unique header image for every article, generated from its title at publish time.
- **Synthetic training data** — produce large labelled image sets for computer-vision models where volume beats per-image polish.
- **Game and app assets** — icons, tiles, textures, and placeholder art generated programmatically at build time.
- **Personalization** — a unique image per user, per record, or per email from templated prompts.
- **Chatbot and agent tooling** — give an LLM agent an image-generation tool whose latency does not stall the conversation.

---

## Pricing

| Plan | Price | Included | Overage | Effective rate | Rate limit |
|:-----|:------|:---------|:--------|:---------------|:-----------|
| **Pay As You Go** | No monthly fee | — | **$0.0025** per API call | $0.0025 | 10 req/sec |
| **Pro** | **$9.99 / month** | **5,000** API calls | **$0.0025** per additional call | **$0.002** on included calls | 10 req/sec |

Pro is worth taking above roughly **4,000 calls a month** — below that, Pay As You Go is cheaper. Beyond the included 5,000, both plans bill at the same $0.0025, 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`. Poll on a 1–2 second interval rather than in a tight loop.

---

## API Documentation

### Base URL

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

### 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/sdxl/generate` | Submit a text-to-image 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/sdxl/generate`

Generate an image from a text prompt. Returns immediately with a `task_id`.

**Request body**

| Field | Type | Required | Default | Description |
|:------|:-----|:---------|:--------|:------------|
| `prompt` | string | **Yes** | — | Text description of the image to generate. |
| `negative_prompt` | string | No | `""` | Things to keep out of the image — artefacts, styles, objects. |
| `width` | integer | No | `512` | Output width in pixels. |
| `height` | integer | No | `512` | Output height in pixels. |
| `seed` | integer | No | `0` | Seed for reproducible generation. Pass the same non-zero seed with the same prompt and settings to repeat a result. |
| `steps` | integer | No | `4` | Inference steps. SDXL-Turbo is distilled for 1–4. |

**Example**

```bash
curl -X POST "https://prod.api.market/api/v1/mastera-ai/gpu-sdxl/v1/sdxl/generate" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A cat wearing a hat, studio portrait, soft lighting",
    "negative_prompt": "blurry, low quality, extra limbs, watermark",
    "width": 512,
    "height": 512,
    "steps": 4,
    "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. Call this every 1–2 seconds until the task reports that it is finished; the completed payload carries the generated image.

```bash
curl "https://prod.api.market/api/v1/mastera-ai/gpu-sdxl/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 a batch.

```bash
curl "https://prod.api.market/api/v1/mastera-ai/gpu-sdxl/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-sdxl/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`.

Because generation is asynchronous, a single GPU works through the queue behind your `task_id`s — sustained throughput is bounded by GPU time, not by the request rate. At roughly two seconds per image, plan for on the order of **30 images per minute** of steady throughput and treat the 10 req/sec ceiling as a burst allowance for submissions and polls.

---

## 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.
- **Cap your polling loop.** Abort after ~120 seconds if a task never completes and surface a timeout to your caller. A two-second job that has not finished in two minutes is not going to.
- **Treat polls as billed calls.** A tight retry loop is a real cost, not just wasted CPU.
- **Check `/v1/health` on repeated failures** to distinguish a GPU or gateway outage from a problem with your request.
- **Cache the `task_id`** so a crashed worker can resume polling instead of paying to regenerate.

---

## Implementation Guide

### Python — generate and poll

```python
import time
import requests

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

def generate(prompt, negative_prompt="", width=512, height=512, steps=4, seed=0):
    payload = {
        "prompt": prompt,
        "negative_prompt": negative_prompt,
        "width": width,
        "height": height,
        "steps": steps,
        "seed": seed,
    }

    task = requests.post(f"{BASE}/v1/sdxl/generate", json=payload, headers=HEADERS, timeout=60)
    task.raise_for_status()
    task_id = task.json()["task_id"]

    deadline = time.time() + 120
    while time.time() < deadline:
        time.sleep(1.5)
        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 120s")

print(generate("A cat wearing a hat, studio portrait", negative_prompt="blurry, watermark", seed=42))
```

### Node.js — batch generation

```javascript
const BASE = "https://prod.api.market/api/v1/mastera-ai/gpu-sdxl";
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 submit(prompt, opts = {}) {
  const res = await fetch(`${BASE}/v1/sdxl/generate`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ prompt, width: 512, height: 512, steps: 4, ...opts }),
  });
  if (!res.ok) throw new Error(`generate failed: ${res.status}`);
  const { task_id: taskId } = await res.json();
  return taskId;
}

async function await_result(taskId, timeoutMs = 120_000) {
  const deadline = Date.now() + timeoutMs;
  while (Date.now() < deadline) {
    await sleep(1500);
    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 ${timeoutMs}ms`);
}

// Submit the whole batch first, then collect — the GPU pipelines the queue.
async function batch(prompts) {
  const ids = [];
  for (const p of prompts) {
    ids.push(await submit(p));
    await sleep(100); // stay under 10 req/sec
  }
  return Promise.all(ids.map(await_result));
}
```

### Performance Optimization

- **Keep `steps` at 4 or lower.** SDXL-Turbo is distilled for single-digit steps. Raising it costs GPU time and generally does not improve the image, unlike a standard SDXL pipeline.
- **Stay near 512×512.** That is SDXL-Turbo's native training resolution; large departures cost time and tend to degrade composition. Upscale afterwards if you need more pixels.
- **Submit the batch, then poll.** Fire your generate calls up front (within 10 req/sec) and poll the `task_id`s together rather than waiting for each image in turn — the GPU queue keeps working while you wait.
- **Poll at 1–2 seconds.** Faster polling costs money and will not make the GPU finish sooner; slower polling wastes the model's speed advantage.
- **Invest in `negative_prompt` before `steps`.** On a distilled model, ruling out artefacts is usually a bigger quality win than extra compute.
- **Lock the `seed` while iterating.** Changing one word against a fixed seed shows you the effect of that word alone.
- **Cache by prompt + negative prompt + seed + size.** Identical inputs produce an identical image, so a cache hit costs nothing.

---

## FAQ

**What model does this API use?**

SDXL-Turbo, an adversarially distilled Stable Diffusion XL variant built for single-digit-step generation. It runs on a dedicated NVIDIA RTX 5090 and 5080.

**How is this different from the Flux.1-Schnell product?**

Speed versus fidelity. SDXL-Turbo returns in about **2 seconds** at **$0.0025** per call and supports `negative_prompt`. [Flux.1-Schnell](https://api.market/store/mastera-ai/gpu-image) is slower and $0.003 per call, but generally produces stronger prompt adherence and detail, and supports resolutions up to 2048px. Draft on SDXL-Turbo, finish on Flux.

**Is generation synchronous or asynchronous?**

Asynchronous. `POST /v1/sdxl/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.

**How many steps should I use?**

Four, the default. SDXL-Turbo is distilled to work at 1–4 steps, and pushing higher mostly buys latency rather than quality.

**What is `negative_prompt` for?**

It lists what you do *not* want — "blurry, watermark, extra limbs, text". It is often the most effective quality lever on a few-step model.

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

Yes. Pass the same `prompt`, `negative_prompt`, `seed`, `width`, `height`, and `steps`.

**What resolutions are supported?**

`width` and `height` default to 512×512, SDXL-Turbo's native size, and are configurable. Very large departures from the native resolution cost time and can weaken composition, so upscale afterwards rather than generating oversized.

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

Yes. Every request through the proxy is a billed API call, so poll on a 1–2 second interval rather than continuously.

**What happens if I exceed my Pro plan's 5,000 calls?**

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

**Which plan should I pick?**

Below about 4,000 calls a month, Pay As You Go. Above that, Pro's $9.99 for 5,000 calls works out cheaper per image.

**What is the rate limit?**

10 requests per second on both plans. Exceeding it returns `429`.

**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.


Ultra-fast text-to-image with SDXL-Turbo on NVIDIA RTX 5090 and 5080. ~2 seconds per image. Self-hosted GPU inference.