Name: GPU Image Generation API — Flux.1-Schnell on RTX 5090 and 5080
Brand: mastera-ai
SKU: api-mastera-ai-gpu-image
Availability: InStock
Author: API Market

# GPU Image Generation — Flux.1-Schnell on NVIDIA RTX 5090 and 5080

**MasterA AI GPU Image Generation** turns a text prompt into a high-quality image using **Flux.1-Schnell GGUF** running on dedicated, self-hosted **NVIDIA RTX 5090 and 5080** hardware powered by solar energy. There is no shared queue, no third-party cloud in the path, and no model-provider account to set up — you send JSON, you get an image back.

Generation is **asynchronous**. Typical flow:

1. **POST** your prompt and parameters to `/v1/flux/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 image from the completed task payload.

A lightweight **`/v1/health`** endpoint is available to check GPU and gateway availability before you dispatch a batch.

---

## Features

- **Flux.1-Schnell GGUF** — a distilled, few-step Flux model tuned for speed. Good results at as few as 4–8 inference steps.
- **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 the seller's own renewable-powered hardware, not on rented third-party cloud GPUs.
- **Full resolution control** — any width and height from **256** to **2048** pixels, independently set.
- **Deterministic output** — pass a fixed `seed` to reproduce the exact same image from the same prompt and settings.
- **Quality/latency dial** — `steps` from **1** to **50** lets you trade generation time against detail.
- **Asynchronous with polling** — POST returns instantly, so your request threads are never blocked on GPU time.
- **Health endpoint** — check GPU, gateway, and loaded models 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 content** — generate on-brand post images, story backgrounds, and thumbnails at scale instead of sourcing stock photography.
- **Product mockups & e-commerce visuals** — render lifestyle scenes, packaging concepts, and category art without a photoshoot.
- **Blog and editorial illustration** — give every article a unique header image generated from its title or summary.
- **Concept art & pre-production** — explore dozens of visual directions for characters, environments, and props in minutes.
- **Ad creative testing** — produce many variants of the same concept with a fixed `seed` and varied prompts, then test which performs.
- **App and game assets** — icons, tiles, backgrounds, and placeholder art generated programmatically at build time.
- **Rapid visual prototyping** — fill designs and pitch decks with realistic imagery before final art exists.
- **Personalization at scale** — generate a unique image per user, per campaign, or per record from templated prompts.
- **Creative tooling** — embed text-to-image in your own editor, CMS, or chatbot with a few lines of HTTP.

---

## Pricing

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

Pro pays for itself at roughly **3,300 images per month** and drops your marginal cost by a third beyond the included quota. Both plans are soft-limited, so traffic above the quota is billed rather than blocked.

> Every call to the API counts toward your quota, including `GET /v1/tasks/{task_id}` polls and `GET /v1/health` checks. Poll on a sensible interval (every 2–3 seconds) rather than in a tight loop.

---

## API Documentation

### Base URL

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

### 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 — MasterA AI's own GPU authentication is handled by the API.market proxy.

### Endpoints

| Method | Path | Description |
|:-------|:-----|:------------|
| `POST` | `/v1/flux/generate` | Submit a text-to-image generation job |
| `GET`  | `/v1/tasks/{task_id}` | Poll job status and retrieve the result |
| `GET`  | `/v1/health` | Check GPU, gateway, and loaded models |

---

### POST `/v1/flux/generate`

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

**Request body**

| Field | Type | Required | Default | Range | Description |
|:------|:-----|:---------|:--------|:------|:------------|
| `prompt` | string | **Yes** | — | — | Text description of the image to generate. |
| `width` | integer | No | `1024` | 256–2048 | Output width in pixels. |
| `height` | integer | No | `1024` | 256–2048 | Output height in pixels. |
| `seed` | integer | No | random | — | Fixed seed for reproducible generation. |
| `steps` | integer | No | `8` | 1–50 | Inference steps. Higher = more detail, slower. |

**Example**

```bash
curl -X POST "https://prod.api.market/api/v1/mastera-ai/gpu-image/v1/flux/generate" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "A serene mountain lake at sunset, oil painting style",
    "width": 1024,
    "height": 1024,
    "steps": 8,
    "seed": 42
  }'
```

The response carries the **`task_id`** you use to poll for the result.

---

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

Poll generation progress. Call this every 2–3 seconds until the task reports that it is finished; the completed payload carries the generated image (base64-encoded or as a URL).

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

---

### GET `/v1/health`

Check that 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-image/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"]
}
```

---

## Status Codes

| Code | Meaning | What to do |
|:-----|:--------|:-----------|
| `200` | Success | Read the response body. |
| `400` | Bad request | A parameter is missing or out of range — check `prompt`, and that `width`/`height` are 256–2048 and `steps` is 1–50. |
| `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; expired 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 processes the queue behind your `task_id`s — sustained throughput is bounded by GPU time, not by the request rate, so prefer smaller `steps` values for high-volume workloads.

---

## 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 key is fixed.
- **Cap your polling loop.** Abort after ~300 seconds if a task never completes, and surface a timeout to your caller rather than polling forever (each poll is a billed call).
- **Validate before you send.** Clamp `width` and `height` to 256–2048 and `steps` to 1–50 client-side to turn would-be `400`s into corrected requests.
- **Check `/v1/health` on repeated failures** to distinguish a GPU 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-image"
HEADERS = {"x-api-market-key": "YOUR_API_KEY", "Content-Type": "application/json"}

def generate(prompt, width=1024, height=1024, steps=8, seed=None):
    payload = {"prompt": prompt, "width": width, "height": height, "steps": steps}
    if seed is not None:
        payload["seed"] = seed

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

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

print(generate("A serene mountain lake at sunset, oil painting style", seed=42))
```

### Node.js — generate and poll

```javascript
const BASE = "https://prod.api.market/api/v1/mastera-ai/gpu-image";
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 generate(prompt, opts = {}) {
  const res = await fetch(`${BASE}/v1/flux/generate`, {
    method: "POST",
    headers: HEADERS,
    body: JSON.stringify({ prompt, width: 1024, height: 1024, steps: 8, ...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(3000);
    const poll = await fetch(`${BASE}/v1/tasks/${taskId}`, { headers: HEADERS });
    const result = await poll.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

- **Start at `steps: 4`.** Flux.1-Schnell is a few-step distilled model; 4–8 steps is usually indistinguishable from 20 and several times faster and cheaper in GPU time.
- **Generate small, upscale later.** A 512×512 draft costs the same per call but finishes far sooner — settle the composition first, then re-run the winning prompt and `seed` at 1024×1024 or higher.
- **Lock the `seed` while iterating.** Changing one word of the prompt against a fixed seed shows you the effect of that word alone.
- **Poll at 2–3 seconds, not 200 ms.** Polls are billed calls, and tighter polling will not make the GPU finish sooner.
- **Pipeline, don't serialize.** Submit several generate calls up front (within 10 req/sec) and poll their `task_id`s together instead of waiting for each image in turn.
- **Cache by prompt + seed + size.** Identical inputs produce an identical image, so a cache hit costs nothing.

---

## FAQ

**What model does this API use?**

Flux.1-Schnell in GGUF format, a distilled Flux variant built for few-step, low-latency generation. It runs on a dedicated NVIDIA RTX 5090 and 5080.

**Is generation synchronous or asynchronous?**

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

**What image sizes are supported?**

Any width and height between 256 and 2048 pixels, set independently. Non-square aspect ratios are supported.

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

Yes. Pass the same `prompt`, `seed`, `width`, `height`, and `steps` and you get the same image.

**How many steps should I use?**

Start at 4–8. Flux.1-Schnell is distilled for low step counts, and beyond ~12 steps the quality gain is usually not worth the extra latency.

**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 2–3 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.002 each rather than rejected.

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


Generate images with Flux.1-Schnell GGUF on NVIDIA RTX 5090 and 5080. Solar-powered, self-hosted GPU inference. Simple REST API.