Name: Flux.1 Lite – AI Image Generation | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-text-to-image-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🎨 Ultra-Fast Text-to-Image Generator API (Flux.1 Lite)

## Overview
The Ultra-Fast Text-to-Image Generator API (Flux.1 Lite) transforms text prompts into vivid images in seconds. It leverages a lightweight yet powerful AI model to speed up creative workflows and rapid prototyping, making it ideal for use cases that demand high-quality visuals without steep resource requirements.

Key attributes:
- Generates high-resolution images from descriptive text prompts
- Offers multiple aspect ratios, guidance scales, and speed modes
- Delivers results in popular image formats (PNG, JPG, or WebP)
- Outputs optimized images ready for immediate use

## Features
- **Lightweight Model** – Quickly generates images thanks to an 8B parameter model that’s optimized for speed.  
- **Multiple Aspect Ratios** – Flexible image shaping to accommodate various design formats (social media posts, banners, product photos, etc.).
- **Quality & Format Control** – Specify output format (PNG/JPG/WebP) and fine-tune quality to optimize file size.
- **Seed Parameter** – Control variations by fixing or randomizing the seed value for consistent outcomes when needed.
- **Speed Modes** – Choose different levels of “juicing” to balance inference speed and output consistency.

## Use Cases
1. **E-commerce Product Imagery**  
   Generate product mockups or lifestyle photos by describing the subject, context, and environment—perfect for online retail and marketing campaigns.

2. **Marketing and Advertising**  
   Create eye-catching visuals for social media ads, banners, or print materials with minimal effort by describing themes, styles, or brand personalities.

3. **Entertainment & Game Development**  
   Quickly produce concept art for characters, props, and environments to streamline pre-production workflows in gaming, film, and animation.

4. **Educational Content**  
   Enliven course materials, infographics, and interactive slides with images illustrating complex concepts or historical scenarios.

5. **Social Media Content Creation**  
   Generate unique and attention-grabbing images for personal or corporate social channels, reinforcing brand identity and increasing engagement.

## Visual Examples

### Example Input and Output

Below is an example input image and a sample output image generated by the API for demonstration purposes:

**Input (placeholder example from the request schema):**  
![Example input - a sample placeholder image from example.com for demonstration purposes](https://example.com/image.jpg)

**Output (for the prompt "a portrait of a woman with blue eyes"):**  
![Example output of a generated portrait](https://blog.api.market/wp-content/uploads/2026/04/ai-text-to-image.webp)

These examples illustrate how the API can transform text prompts (and optional image references) into finished visuals. Your actual results will vary based on your prompt details, aspect ratio, guidance, and speed settings.

## Pricing
- 1 API unit = 1 image processed (i.e., every new POST request that creates a prediction).
- GET requests to check prediction status (GET /api/v1/magicapi/ai-text-to-image-generator/predictions/{id}) are free and do not count toward API usage.
- Various pricing tiers are available based on usage volume to support experimentation, MVPs, and high-scale production needs.

## API Documentation

### Base URL
All requests to this API are made to:  
```
https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator
```

### Authentication
Include your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```
Ensure this header is present for every request; otherwise, you will receive an HTTP 401 Unauthorized error.

### Asynchronous Processing
This API uses an asynchronous flow for predictions:

1. Submit a prediction request with a POST request.  
2. Receive a prediction ID in the response.  
3. Check status with the GET endpoint using the prediction ID.  
4. Continue polling until `status` is `succeeded`, `failed`, or you reach a timeout.

Typical processing times range from a few seconds to a few minutes, depending on your chosen settings (e.g., larger image sizes or higher speed modes may require more computation time).

**Recommended polling strategy**:
- Wait 1 second between status checks.
- Use a maximum timeout of 600 seconds (10 minutes).
- If `status` is `"failed"`, handle the error accordingly.
- If the timeout elapses without success, cancel the request and handle it as a timeout error.

### Endpoints

#### 1. Create a Prediction
• **Endpoint**:  
  ```
  POST /api/v1/magicapi/ai-text-to-image-generator/predictions
  ```
• **Description**: Start a new image generation prediction based on provided input parameters.  
• **Request Body** (JSON):
```json
{
  "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
  "input": {
    "prompt": "a portrait of a woman with blue eyes",
    "seed": -1,
    "guidance": 3.5,
    "num_inference_steps": 28,
    "speed_mode": "Extra Juiced 🔥 (more speed)",
    "aspect_ratio": "1:1",
    "image_size": 1024,
    "output_format": "webp",
    "output_quality": 80
  }
}
```
• **Example cURL**:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
    "input": {
      "prompt": "a portrait of a woman with blue eyes",
      "seed": -1,
      "guidance": 3.5,
      "num_inference_steps": 28,
      "speed_mode": "Extra Juiced 🔥 (more speed)",
      "aspect_ratio": "1:1",
      "image_size": 1024,
      "output_format": "webp",
      "output_quality": 80
    }
  }'
```
• **Successful Response** (HTTP 201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
  "status": "starting",
  "created_at": "2025-05-18T08:21:09.498Z"
}
```
You will get a unique `id` that can be used to poll for status.

#### 2. Check Prediction Status and Results
• **Endpoint**:  
  ```
  GET /api/v1/magicapi/ai-text-to-image-generator/predictions/{id}
  ```
• **Description**: Retrieve the status and, if complete, the final output of your prediction. The output value is a direct link to the generated image.  
• **Path Parameter**:  
  - **id** (string) – Required. Prediction ID obtained from the create endpoint.  
• **Example cURL**:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```
• **Possible Response** (HTTP 200, if succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://some.storage.server/path/to/generated-image.webp",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```
• **Other Statuses**:
  - `"starting"` – The request has been received and is pending initialization.  
  - `"processing"` – The prediction is currently in progress.  
  - `"failed"` – The prediction encountered an error.  
  - `"canceled"` – The prediction was canceled (rare scenarios).  

## Status Codes
- **200 OK** – Request succeeded and returned a result.  
- **201 Created** – A new resource (e.g., prediction) has been successfully created.  
- **400 Bad Request** – Invalid or missing input parameters.  
- **401 Unauthorized** – Your API key was invalid or missing.  
- **403 Forbidden** – Your API key is valid, but you don’t have permission to perform the requested action.  
- **404 Not Found** – The specified resource wasn’t found (e.g., an invalid prediction ID).  
- **429 Too Many Requests** – You hit your rate limit; consider exponential backoff or upgrading your plan.  
- **500 Internal Server Error** – Something went wrong on our server; try again later or contact support.  
- **503 Service Unavailable** – The service is temporarily down or overloaded; wait or retry later.

## Rate Limits
This API may enforce a rate limit to protect service integrity:
- A set number of requests allowed per minute/hour.
- If exceeded, a **429 Too Many Requests** error is returned.  
Use a retry strategy with exponential backoff if you encounter this error.

## Error Handling
When an error occurs, you’ll typically receive a JSON payload describing what went wrong:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
**Common errors**:
- Missing required fields (e.g., `"prompt"` not provided).
- Invalid data types or out-of-range values (e.g., negative numbers for parameters that require nonnegative integers).
- Authentication or permission issues (401/403).

**Best Practices**:
- Inspect the `"code"` or `"message"` for user-correctable issues.
- Retry on transient errors or rate limit (429).
- Use a longer waiting period for server errors (5xx) before retrying.

## Implementation Guide

Below are sample code snippets showing how to integrate this API into your application. All examples follow the asynchronous prediction flow:

1. **Send a POST request** to create a new prediction and get the `id`.
2. **Poll the GET endpoint** using the returned `id` every ~1 second until the prediction completes or fails.
3. **Handle timeouts** if the prediction takes longer than 10 minutes.

### JavaScript Example (Node.js)

```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({
        version: "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
        input: inputData
      })
    });

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

    const prediction = await response.json();
    const predictionId = prediction.id;

    // Step 2: Poll for results with timeout
    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-magicapi-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") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

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

// Usage example:
// (async () => {
//   const outputUrl = await createAndWaitForPrediction({
//     prompt: "a surreal forest with neon trees"
//   });
//   console.log("Generated image URL:", outputUrl);
// })();
```

### Python Example

```python
# Python example with proper polling and timeout
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    payload = {
        "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
        "input": input_data
    }
    
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=payload)
    
    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"]

    # Step 2: Poll for results with timeout
    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-magicapi-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"] == "failed":
            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")

# Usage example
# if __name__ == "__main__":
#     result_url = create_and_wait_for_prediction({
#         "prompt": "a futuristic city skyline at sunset",
#         "image_size": 512,
#     })
#     print("Generated image URL:", result_url)
```

### cURL Example

```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
    "input": {
      "prompt": "a portrait of a woman with blue eyes"
    }
  }'

# Response example:
# {
#   "id": "ufawqhfynnddngldkgtslldrkq",
#   "version": "a42519481809615a79cc7ed496686c31d6336d1961be244ce20e912f9cbf3de7",
#   "status": "starting",
#   "created_at": "2025-05-18T08:21:09.498Z"
# }

# Step 2: Poll for status (repeat until status = 'succeeded' or 'failed')
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-text-to-image-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- **Adjust `num_inference_steps`** to reduce generation time if you don’t require maximum quality.  
- **Use smaller `image_size`** for prototyping or quick previews; scale up if you need bigger images.  
- **Speed modes** offer a trade-off between result consistency and processing speed—experiment to find the right balance.

## FAQ
1. **What is the maximum resolution supported?**  
   You can typically go up to 1024 on the longest side. For larger dimensions, consider upscaling the output externally.

2. **Do I get charged for status checks?**  
   No. GET requests to check prediction status are free and do not count toward your usage.

3. **Why are my images generating slowly?**  
   Higher image dimensions and more inference steps can increase processing time. Try a lower setting or a different speed mode.

4. **How can I ensure consistent results for A/B comparisons?**  
   Provide a fixed seed in your request. Reusing the same seed and prompt tends to produce consistent results.

5. **What if my prediction fails?**  
   Check the error message in the response. Often, refining the prompt or adjusting parameters can resolve issues. You can also retry if it’s a transient error.

## 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[at]api.market.

We hope this comprehensive guide helps you integrate and maximize the benefits of the Ultra-Fast Text-to-Image Generator API (Flux.1 Lite). Happy building!

Generate vivid, high-resolution images from text prompts. Fast 8B parameter model. From $0.05/call. Try it free on API.market.