Name: Mindprint FLUX.2 Klein Seamless Pattern Generator API
Brand: magicapi
SKU: api-magicapi-pattern-generator-okgodoit-repos-mindprint-flux2-klein
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧩 Seamless Pattern Generator API (okgodoit-repos Mindprint FLUX.2 Klein)

## Overview
Mindprint FLUX.2 Klein, published by okgodoit-repos, generates seamless repeating patterns from a text prompt. Its developer describes it as FLUX.2 Klein 4B with toroidal RoPE and a circular VAE, so the image wraps pixel for pixel at its edges.

Send a `prompt` and the API returns a list of image URLs (1 to 4, set by `num_outputs`). Tiling can be turned on per axis with `tile_x` and `tile_y`, and `rope_mode` sets how strictly the pattern repeats.

## Features
- **Seamless tiles**: the left and right edges (`tile_x`) and the top and bottom edges (`tile_y`) wrap, so the image repeats without seams.
- **Tiling strength**: `rope_mode` `all0` forces a fully periodic all-over pattern; `high` keeps more of the composition; `default` uses the built-in default.
- **Sizes**: `width` and `height` of 512, 768, 1024 (default), 1152, 1280 or 1536 pixels.
- **1 to 4 images per request**: set `num_outputs`.
- **Negative prompt and guidance**: `negative_prompt` and `guidance_scale` (model default when below 0).
- **Seed**: set `seed` to repeat a result; -1 picks a random seed.

## Use Cases
1. **Textile and fabric prints**: all-over designs for clothing, bedding and upholstery.
2. **Wallpaper and wrapping paper**: repeating designs that tile across large surfaces.
3. **Game and 3D textures**: tileable surfaces for materials.
4. **Print-on-demand**: generate fresh pattern designs for products.

## Visual Examples
### Example Input
Prompt: "seamless repeating watercolor wildflower and eucalyptus pattern, textile surface design, flat even lighting, dense allover print"

Settings: `width` and `height` `1024`, `tile_x` and `tile_y` `true`, `seed` `42`, `num_inference_steps` `0` (model default).

```json
{
  "seed": 42,
  "width": 1024,
  "height": 1024,
  "prompt": "seamless repeating watercolor wildflower and eucalyptus pattern, textile surface design, flat even lighting, dense allover print",
  "tile_x": true,
  "tile_y": true,
  "num_inference_steps": 0
}
```

### Example Output
![Example output: a seamless watercolor wildflower and eucalyptus pattern](https://blog.api.market/wp-content/uploads/2026/10/mindprint-flux2-klein-output-brjgncj2-api-market.jpg)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | No | `seamless repeating art deco geometric pattern, gold and navy, textile print` |  | Text description of the pattern. |
| `negative_prompt` | string | No | `""` |  | Things to avoid in the pattern. Only used if the model supports classifier-free guidance. |
| `width` | integer | No | `1024` | `512`, `768`, `1024`, `1152`, `1280`, `1536` | Output width in pixels. |
| `height` | integer | No | `1024` | `512`, `768`, `1024`, `1152`, `1280`, `1536` | Output height in pixels. |
| `num_inference_steps` | integer | No | `0` | 0 to 40 | Number of denoising steps. 0 uses the model default. |
| `guidance_scale` | number | No | `-1` | -1 to 8 | Classifier-free guidance scale. A value below 0 uses the model default. |
| `seed` | integer | No | `-1` |  | Random seed. -1 (default) picks a random seed. |
| `tiling` | string | No | `enable` | `enable`, `disable` | Master tiling switch. `enable` makes the image repeat seamlessly; `disable` turns tiling off. |
| `tile_x` | boolean | No | `true` |  | Make the image wrap horizontally (left edge meets right edge). |
| `tile_y` | boolean | No | `true` |  | Make the image wrap vertically (top edge meets bottom edge). |
| `rope_mode` | string | No | `default` | `default`, `all0`, `high` | How strongly tiling is enforced. `all0` is fully periodic and forces a wrapping all-over pattern whatever the prompt (recommended by the developer). `high` keeps the coarse composition but may show seams on scene-like prompts. `default` uses the built-in default. |
| `num_outputs` | integer | No | `1` | 1 to 4 | Number of images to generate. |
| `pattern_collection_id` | integer | No | `-1` |  | Pattern collection ID. |
| `metadata` | string | No | `""` |  | Free-form metadata string that is passed through unchanged. It does not change the image. |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.0074 per API unit.
- **1 API unit = 1 request with up to 6 seconds of processing.** A request that runs longer is billed one more unit for each started 6-second block (for example, more than 6 and up to 12 seconds of processing is 2 units, $0.0148).
- More images (`num_outputs`), larger sizes and more steps take longer and can add units.
- **Example cost**: the example request (one 1024x1024 image) took 3.6 seconds of processing, which fits in one 6-second block: 1 API unit, $0.0074.
- **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/pattern-generator-okgodoit-repos-mindprint-flux2-klein`

### 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/pattern-generator-okgodoit-repos-mindprint-flux2-klein/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "ac73ae32ae38324b49833d8077edd69caf4311ac70d771a12d0195e5cd20c483",
    "input": {
      "seed": 42,
      "width": 1024,
      "height": 1024,
      "prompt": "seamless repeating watercolor wildflower and eucalyptus pattern, textile surface design, flat even lighting, dense allover print",
      "tile_x": true,
      "tile_y": true,
      "num_inference_steps": 0
    }
  }'
```

Response (201 Created):
```json
{
  "id": "brjgncj26xrmw0d1f1pspfcz58",
  "version": "ac73ae32ae38324b49833d8077edd69caf4311ac70d771a12d0195e5cd20c483",
  "status": "starting",
  "created_at": "2026-10-26T13:36:28.873Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/pattern-generator-okgodoit-repos-mindprint-flux2-klein/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "brjgncj26xrmw0d1f1pspfcz58",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/mindprint-flux2-klein-output-brjgncj2-api-market.jpg"
  ],
  "error": null,
  "created_at": "2026-10-26T13:36:28.873Z",
  "started_at": "2026-10-26T13:38:54.908Z",
  "completed_at": "2026-10-26T13:38:58.459Z"
}
```

`output` is an array of image URLs, one per generated image (`num_outputs`).

### 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 `width` that is not in the list, `num_outputs` above 4 or `num_inference_steps` above 40.
- **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/pattern-generator-okgodoit-repos-mindprint-flux2-klein";

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: "ac73ae32ae38324b49833d8077edd69caf4311ac70d771a12d0195e5cd20c483", 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({
  "seed": 42,
  "width": 1024,
  "height": 1024,
  "prompt": "seamless repeating watercolor wildflower and eucalyptus pattern, textile surface design, flat even lighting, dense allover print",
  "tile_x": true,
  "tile_y": true,
  "num_inference_steps": 0
}).then((output) => output.forEach((url) => console.log(url)));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/pattern-generator-okgodoit-repos-mindprint-flux2-klein"


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": "ac73ae32ae38324b49833d8077edd69caf4311ac70d771a12d0195e5cd20c483", "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")


output = create_and_wait_for_prediction({
    "seed": 42,
    "width": 1024,
    "height": 1024,
    "prompt": "seamless repeating watercolor wildflower and eucalyptus pattern, textile surface design, flat even lighting, dense allover print",
    "tile_x": True,
    "tile_y": True,
    "num_inference_steps": 0,
})
for url in output:
    print(url)
```

## FAQ
- **Is the output really seamless?**
  - With `tiling` `enable` and `tile_x` and `tile_y` `true` (the defaults), the edges wrap so copies of the image line up without a seam. Use `rope_mode` `all0` for the strictest repeat.
- **Can I tile in only one direction?**
  - Yes. Set `tile_x` or `tile_y` to `false` to stop wrapping on that axis, for example for a border strip.
- **Which sizes can I request?**
  - `width` and `height` each take 512, 768, 1024, 1152, 1280 or 1536 pixels.
- **Is `prompt` required?**
  - No. Without it the model uses its default prompt, an art deco geometric pattern in gold and navy.
- **How much does a request cost?**
  - $0.0074 for each started 6 seconds of processing. The example (one 1024x1024 image) took 3.6 seconds and cost 1 unit ($0.0074); more images, larger sizes and more steps take longer.
- **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 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.


Create seamless, tileable patterns from text with Mindprint FLUX.2 Klein: per-axis tiling, 512 to 1536 px, up to 4 images. $0.0074 per request.