Name: Fast Text-to-Image API - FLUX Pro 1.1
Brand: magicapi
SKU: api-magicapi-fast-text-to-image-generator-black-forest-labs-flux-1-1-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# ⚡ Fast Text-to-Image API (FLUX Pro 1.1)

## Overview

The Fast Text-to-Image API (FLUX Pro 1.1) by Black Forest Labs turns text prompts into high-quality images. Black Forest Labs describes FLUX 1.1 Pro as a faster, better FLUX Pro with excellent image quality, prompt adherence and output diversity.

## Features

- **High-Quality Image Generation**: Render accurate, high-resolution images from text prompts.
- **Fast Processing**: Faster than the original FLUX Pro, per Black Forest Labs.
- **Prompt Adherence**: Ensures the output closely matches the provided prompt.
- **Output Diversity**: Produces varied results for the same prompt across different seeds. Each request returns one image.
- **Flexible Parameters**: Customize image dimensions, aspect ratio, output format, and quality.
- **Safety and Prompt Controls**: Set `safety_tolerance` (1 to 6) and turn on `prompt_upsampling` to let the model rewrite the prompt for more creative results.

## Use Cases

1. **E-commerce Visual Content Creation**:
   Generate product images from descriptions, perfect for catalogs and online stores.

2. **Social Media Content**:
   Quickly create engaging and visually appealing content for social media campaigns.

3. **Advertising and Marketing**:
   Develop unique advertising visuals from marketing copy to grab audience attention.

4. **Gaming Character Generation**:
   Create diverse character images for games based on textual descriptions.

5. **Publishing**:
   Illustrate stories, articles, and concepts with bespoke images, enhancing content richness.

## Visual Examples

### Example Input

```json
{
  "input": {
    "prompt": "black forest gateau cake spelling out the words \"FLUX 1.1 Pro\", tasty, food photography",
    "aspect_ratio": "1:1",
    "output_format": "webp"
  }
}
```

### Example Output

![Example output from Fast Text-to-Image API (FLUX Pro 1.1)](https://blog.api.market/wp-content/uploads/2026/09/flux-1-1-pro-output-api-market.webp)

This exact request was run through api.market and billed 1 API unit ($0.05).
## Pricing

- **Pay As You Go (PAYG) pricing** - you only pay for what you use
- **Price**: $0.05 per API unit
- **1 API unit = 1 output image; a request that returns several images is billed for each one.**
- **Failed or cancelled predictions are not billed**
- **GET requests to check prediction status are free**
- **No monthly subscription fee**

## API Documentation

### Base URL

All API requests should be made to: `https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro`

### Authentication

Authentication is handled via API key. Include your API key in the request header:

```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing

**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow is:

1. Submit a prediction request to the **POST** endpoint.
2. Receive a prediction ID in the response.
3. Poll the **GET** endpoint with the prediction ID to check status.
4. Continue polling until the prediction is complete.

Your code should implement:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic that continues while status is "starting" or "processing".
- Result handling when status becomes "succeeded".
- Error handling when status becomes "failed" or timeout is reached.

## Endpoints

### POST /predictions

**Create a new prediction**

```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "609793a667ed94b210242837d3c3c9fc9a64ae93685f15d75002ba0ed9a97f2b",
    "input": {
      "prompt": "black forest gateau cake spelling out the words \"FLUX 1.1 Pro\", tasty, food photography",
      "aspect_ratio": "1:1",
      "output_format": "webp",
      "output_quality": 80,
      "safety_tolerance": 2,
      "prompt_upsampling": true
    }
  }'
```

**Response**:
```json
{
  "id": "abcd1234",
  "status": "starting"
}
```

### GET /predictions/{id}

**Check prediction status**

```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response**:
```json
{
  "id": "abcd1234",
  "status": "processing",
  "output": null
}
```

## Input Parameters

| Parameter | Type | Required | Default | Allowed values and notes |
|---|---|---|---|---|
| `prompt` | string | Yes | none | Text prompt for image generation |
| `aspect_ratio` | string | No | `1:1` | `custom`, `1:1`, `16:9`, `3:2`, `2:3`, `4:5`, `5:4`, `9:16`, `3:4`, `4:3` |
| `width` | integer | No | none | 256 to 1440. Only used when `aspect_ratio` is `custom`; rounded to the nearest multiple of 32 |
| `height` | integer | No | none | 256 to 1440. Only used when `aspect_ratio` is `custom`; rounded to the nearest multiple of 32 |
| `image_prompt` | string (URL) | No | none | Image (jpeg, png, gif or webp) used with Flux Redux to guide the composition together with the text prompt |
| `prompt_upsampling` | boolean | No | `false` | Automatically modifies the prompt for more creative generation |
| `seed` | integer | No | none | Set for reproducible generation |
| `safety_tolerance` | integer | No | `2` | 1 (most strict) to 6 (most permissive) |
| `output_format` | string | No | `webp` | `webp`, `jpg`, `png` |
| `output_quality` | integer | No | `80` | 0 to 100. Not relevant for png output |

Each request returns one image URL in `output`.

## Status Codes

- **200 OK**: Request successful
- **201 Created**: Resource successfully created
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key
- **403 Forbidden**: Valid API key but insufficient permissions
- **404 Not Found**: Resource not found
- **429 Too Many Requests**: Rate limit exceeded
- **500 Internal Server Error**: Server-side error
- **503 Service Unavailable**: Service temporarily unavailable

## Rate Limits

Information about rate limits and how to handle them is currently unavailable. Make sure to handle any rate limit responses appropriately.

## Error Handling

### Interpreting Error Responses

- **Invalid Parameter**: Ensure all required parameters are correctly provided.
- **Authentication Errors**: Double-check that the API key is valid and active.
- **Rate Limit Errors**: Implement exponential backoff or retry mechanisms to handle temporary rate limits.

**Example Error Response**:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code

#### JavaScript

```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro";

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

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

    const prediction = await response.json();
    const predictionId = prediction.id;
    return await pollForResults(predictionId);
  } catch (error) {
    console.error("Error:", error);
    throw error;
  }
}

function delay(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

async function pollForResults(predictionId) {
  const MAX_TIMEOUT = 600000; // 600 seconds (10 minutes)
  const POLL_INTERVAL = 1000; // 1 second

  const startTime = Date.now();

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

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

    const prediction = await response.json();

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

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

    await delay(POLL_INTERVAL);
  }

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

#### Python

```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro"

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": "609793a667ed94b210242837d3c3c9fc9a64ae93685f15d75002ba0ed9a97f2b", "input": input_data}
    )

    if response.status_code not in (200, 201):
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 600 seconds (10 minutes)
    POLL_INTERVAL = 1  # 1 second

    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"):
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")

        time.sleep(POLL_INTERVAL)

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

#### cURL

```bash
# Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "609793a667ed94b210242837d3c3c9fc9a64ae93685f15d75002ba0ed9a97f2b",
    "input": {
      "prompt": "black forest gateau cake spelling out the words \"FLUX 1.1 Pro\", tasty, food photography",
      "aspect_ratio": "1:1",
      "output_format": "webp",
      "output_quality": 80,
      "safety_tolerance": 2,
      "prompt_upsampling": true
    }
  }'

# Check prediction status (replace abcd1234 with the actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/fast-text-to-image-generator-black-forest-labs-flux-1-1-pro/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Poll the status endpoint about once per second; most images finish within a few seconds.
- Each request returns one image and bills one unit, so send requests in parallel (up to 10 per second on the PAYG plan) when you need several images.
- Leave `prompt_upsampling` off when the image must follow your prompt literally.
- Use `output_format` `webp` for smaller files.

## FAQ

1. **How do I authenticate with the API?**
   Include your API key in the request header with the field `x-api-market-key`.

2. **What is asynchronous processing, and how do I handle it?**
   Asynchronous processing allows the API to handle requests that take longer to complete by returning a prediction ID which you can poll for completion status.

3. **What should I do if I encounter a rate limit?**
   Implement exponential backoff or retry mechanisms to handle temporary rate limits.

## 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 high-quality, diverse images rapidly from text prompts using FLUX Pro 1.1. Ideal for creative projects.