Name: Retro Diffusion RD Tile Pixel Art Tileset Generator API
Brand: magicapi
SKU: api-magicapi-pixel-art-tileset-generator-retro-diffusion-rd-tile
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧱 Pixel Art Tile and Tileset Generator API (Retro Diffusion RD Tile)

## Overview
RD Tile is the tileset model from Retro Diffusion. It makes full tilesets from a prompt, single seamless tiles, variations of a tile you provide, and small or large objects to place on tile maps.

Send a `prompt`, a `style` and the tile `width` and `height` (16 to 384 pixels). For tilesets, width and height are the size of each tile, not of the whole image. Each request returns a list of image URLs, one per image (`num_images`, 1 to 10).

## Features
- **Six styles**: `tileset` (a full tileset from one prompt), `tileset_advanced` (from two prompts or textures), `single_tile`, `tile_variation` (variations of `input_image`), `tile_object` (small assets for tiles) and `scene_object` (large assets for maps).
- **Tile sizes from 16 to 384 pixels** (default 32 x 32).
- **Two-texture tilesets**: `tileset_advanced` blends `prompt` or `input_image` with `extra_prompt` or `extra_input_image`.
- **Up to 10 images per request** with `num_images`.

## Use Cases
1. **Terrain tilesets** for top-down and side-scrolling games.
2. **Seamless floor, wall and ground textures**.
3. **Variations of an existing tile** to break up repetition.
4. **Trees, rocks, buildings and props** to place on tile maps.

## Visual Examples
### Example Input
Prompt: "dense jungle floor with ferns and moss", `single_tile` style, one 64 x 64 tile.

```json
{
  "style": "single_tile",
  "width": 64,
  "height": 64,
  "prompt": "dense jungle floor with ferns and moss",
  "num_images": 1,
  "bypass_prompt_expansion": false
}
```

### Example Output
![RD Tile output: a 64 x 64 pixel art tile of a mossy green jungle floor](https://blog.api.market/wp-content/uploads/2026/11/rd-tile-output-8546ym80-api-market.png)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Text prompt describing the pixel art to generate. |
| `style` | string | No | `tileset` | `tileset`, `tileset_advanced`, `single_tile`, `tile_variation`, `tile_object`, `scene_object` | What to generate: `tileset` (a full tileset of wang-style combinations from one prompt), `tileset_advanced` (a full tileset from two prompts or textures), `single_tile` (one detailed tile texture), `tile_variation` (variations of the tile in `input_image`), `tile_object` (small assets to place on tiles) or `scene_object` (large assets to place on maps). The style also sets the price row (see Pricing). |
| `width` | integer | No | `32` | 16 to 384 | Tile width in pixels. For tilesets this is the size of each tile, not of the whole image. |
| `height` | integer | No | `32` | 16 to 384 | Tile height in pixels. For tilesets this is the size of each tile, not of the whole image. |
| `num_images` | integer | No | `1` | 1 to 10 | Number of images to generate. Each image is billed. |
| `seed` | integer | No | none |  | Random seed. Set it for reproducible generation. |
| `input_image` | string (URL) | No | none |  | Image URL (jpeg, png, gif or webp) for image-to-image generation or as a reference. Converted to RGB without transparency. |
| `extra_input_image` | string (URL) | No | none |  | Second image URL (jpeg, png, gif or webp) for `tileset_advanced` only. |
| `extra_prompt` | string | No | none |  | Second prompt for `tileset_advanced` only. |
| `bypass_prompt_expansion` | boolean | No | `false` |  | Turn off the automatic expansion of your prompt and use it as written. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.001 per API unit.
- **Metered billing**: each output image is billed at the price for its style and, except for tilesets, its size (width x height in pixels). The total for the request is rounded up to a whole API unit.
- **Tilesets** (`tileset`, `tileset_advanced`): $0.118 per image, any tile size.

**Tiles and small objects** (`single_tile`, `tile_variation`, `tile_object`):

| Output pixels per image (width x height) | Price per output image |
| --- | --- |
| up to 256 (16x16) | $0.0283 |
| 257 to 1,024 (up to 32x32) | $0.0295 |
| 1,025 to 4,096 (up to 64x64) | $0.0353 |
| 4,097 to 9,216 (up to 96x96) | $0.0459 |
| above 9,216 | $0.06 |

**Large objects** (`scene_object`):

| Output pixels per image (width x height) | Price per output image |
| --- | --- |
| up to 4,096 (64x64) | $0.033 |
| 4,097 to 9,216 (up to 96x96) | $0.0353 |
| 9,217 to 16,384 (up to 128x128) | $0.04 |
| 16,385 to 36,864 (up to 192x192) | $0.0518 |
| 36,865 to 65,536 (up to 256x256) | $0.0683 |
| 65,537 to 102,400 (up to 320x320) | $0.0906 |
| above 102,400 | $0.117 |

- The default (`tileset`, 32 x 32 tiles) is $0.118 per image. `num_images` multiplies the cost.
- If the style family or the image size is not reported, the image can be billed at up to the highest price above.
- **Example cost**: one 64 x 64 `single_tile` image (4,096 pixels) at $0.0353, rounded up to 36 units ($0.036).
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/pixel-art-tileset-generator-retro-diffusion-rd-tile`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/pixel-art-tileset-generator-retro-diffusion-rd-tile/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "retro-diffusion/rd-tile",
    "input": {
      "style": "single_tile",
      "width": 64,
      "height": 64,
      "prompt": "dense jungle floor with ferns and moss",
      "num_images": 1,
      "bypass_prompt_expansion": false
    }
  }'
```

Response (201 Created):
```json
{
  "id": "8546ym80ynrmy0d1ngjryrc3gw",
  "version": "retro-diffusion/rd-tile",
  "status": "starting",
  "created_at": "2026-11-05T14:37:48.661Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/pixel-art-tileset-generator-retro-diffusion-rd-tile/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "8546ym80ynrmy0d1ngjryrc3gw",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/11/rd-tile-output-8546ym80-api-market.png"
  ],
  "error": null,
  "created_at": "2026-11-05T14:37:48.661Z",
  "started_at": "2026-11-05T14:37:48.680Z",
  "completed_at": "2026-11-05T14:38:09.317Z"
}
```

`output` is a list of image URLs (PNG), one per generated image.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or a `width` below 16.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
Requests are rate limited to keep usage fair. If you receive a 429 response, wait and retry with exponential backoff.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/pixel-art-tileset-generator-retro-diffusion-rd-tile";

async function createAndWaitForPrediction(input) {
  const response = await fetch(`${baseUrl}/predictions`, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      "x-api-market-key": apiKey
    },
    body: JSON.stringify({ version: "retro-diffusion/rd-tile", input })
  });

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < maxTimeout) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-api-market-key": apiKey }
    });

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

    if (prediction.status === "failed" || prediction.status === "canceled") {
      throw new Error(`Prediction ${prediction.status}: ${prediction.error || "Unknown error"}`);
    }

    await delay(pollInterval);
  }

  throw new Error("Prediction timed out after 10 minutes");
}

createAndWaitForPrediction({
  "style": "single_tile",
  "width": 64,
  "height": 64,
  "prompt": "dense jungle floor with ferns and moss",
  "num_images": 1,
  "bypass_prompt_expansion": false
}).then((output) => console.log(output));
```

#### Python
```python
import time
import requests

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/pixel-art-tileset-generator-retro-diffusion-rd-tile"


def create_and_wait_for_prediction(input_data):
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"version": "retro-diffusion/rd-tile", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["id"])


def poll_for_results(prediction_id):
    max_timeout = 600
    poll_interval = 1
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()

    while time.time() - start_time < max_timeout:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers=headers)

        if response.status_code != 200:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()

        if prediction["status"] == "succeeded":
            return prediction["output"]

        if prediction["status"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

    raise Exception("Prediction timed out after 10 minutes")


print(create_and_wait_for_prediction({
    "style": "single_tile",
    "width": 64,
    "height": 64,
    "prompt": "dense jungle floor with ferns and moss",
    "num_images": 1,
    "bypass_prompt_expansion": False
}))
```

## FAQ
- **What is the difference between `width`/`height` for tiles and tilesets?**
  - They are always the size of one tile. A `tileset` image contains many tiles of that size.
- **How is the price calculated?**
  - Tilesets cost $0.118 per image. Single tiles, variations and objects are priced per image by pixel count, from $0.0283. The total is rounded up to a whole $0.001 unit per request. The 64 x 64 example tile cost $0.036.
- **How do I make variations of my own tile?**
  - Use `style` `tile_variation` and pass your tile as `input_image`.
- **What does `tileset_advanced` add?**
  - A tileset built from two textures: `prompt` or `input_image` for the first, `extra_prompt` or `extra_input_image` for the second.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page.


Generate pixel art tilesets, seamless single tiles, tile variations and map objects with Retro Diffusion RD Tile. From $0.0283 per image, pay as you go.