Name: Flux Schnell – AI Image Generation | $0.01/call | API.market
Brand: magicapi
SKU: api-magicapi-ultra-fast-ai-image-generator-prunaai-flux-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# ⚡ Ultra-Fast AI Image Generator API (Flux-Fast)

## Overview
The Ultra-Fast AI Image Generator API (Flux-Fast) by prunaai is the fastest endpoint for generating high-quality AI images. With unparalleled speed and state-of-the-art performance, this API allows developers to create detailed and consistent images using the most advanced AI models.

## Features
- **Lightning-Fast Processing:** Generate images at unprecedented speeds.
- **State-of-the-Art Performance:** Utilize cutting-edge AI technology for image generation.
- **Customizable Parameters:** Adjust guidance, image size, aspect ratio, and more.
- **High-Quality Outputs:** Choose output formats (jpg, png, webp) with customizable quality.
- **Scalable Options:** Suitable for a range of applications from prototyping to production.

## Use Cases
1. **E-commerce Product Images:**
   - Generate high-quality images for product listings instantly.
   - Example: "AI-generated jewelry images with custom backgrounds."

2. **Creative Content Creation:**
   - Artists and designers can quickly create concept art and illustrations.
   - Example: "Concept art for a new fantasy landscape."

3. **Marketing Campaigns:**
   - Create visually appealing graphics for digital marketing.
   - Example: "Ad images showcasing various products with dynamic visuals."

4. **Social Media Content:**
   - Generate eye-catching images for social media posts and stories.
   - Example: "Customized images for Instagram stories promoting events."

5. **Virtual Environments:**
   - Develop backgrounds and scenery for virtual reality or game design.
   - Example: "Virtual environments for a new game level."

## Visual Examples

### Example Image
![Generated Image](https://blog.api.market/wp-content/uploads/2026/01/ultra-fast-image-api-market.jpeg)
*Example output for the prompt "a man staring into the sunset"*

### Input JSON
```json
{
  "seed": -1,
  "prompt": "a man staring into the sunset",
  "guidance": 3.5,
  "image_size": 1024,
  "speed_mode": "Extra Juiced 🔥 (more speed)",
  "aspect_ratio": "1:1",
  "output_format": "jpg",
  "output_quality": 80,
  "num_inference_steps": 28
}
```

## Pricing
- **Pay As You Go (PAYG):** Only pay for the images you generate.
- **1 API Unit = 1 Image Processed**
- **GET requests to check prediction status are free and do not count toward API usage units.**
- **No monthly subscription fees or usage limits – simple per-call pricing.**

## API Documentation

### Base URL
All API requests should be made to:
`https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator-prunaai-flux-fast`

### 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. Follow this flow:
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.

### Endpoints

#### Create a Prediction
```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator-prunaai-flux-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "4f22c6cd75e0f95f12f55d1616a4d163e9166087ed4979f5cecc40418a522703",
    "input": {
      "seed": -1,
      "prompt": "a man staring into the sunset",
      "guidance": 3.5,
      "image_size": 1024,
      "speed_mode": "Extra Juiced 🔥 (more speed)",
      "aspect_ratio": "1:1",
      "output_format": "jpg",
      "output_quality": 80,
      "num_inference_steps": 28
    }
  }'
```

#### Get Prediction Status
```bash
# Example for getting status of a prediction
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator-prunaai-flux-fast/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## 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 on specific rate limits is available upon request. Handle 429 errors by implementing exponential backoff in your retry logic.

## Error Handling
### Common Errors
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'prompt' is required",
    "status": 400
  }
}
```
1. **400 Bad Request:** Ensure all required parameters are included and correctly formatted.
2. **401 Unauthorized:** Verify that the API key is correct and active.
3. **429 Too Many Requests:** Implement retries with exponential backoff.

## Implementation Guide

### Example Code
#### JavaScript (Node.js)
```javascript
const fetch = require('node-fetch');

const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator-prunaai-flux-fast";

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

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

    const prediction = await createResponse.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 between checks

  const startTime = Date.now();

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

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

    const prediction = await statusResponse.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");
}
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ultra-fast-ai-image-generator-prunaai-flux-fast"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }
    
    create_response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={
            "version": "4f22c6cd75e0f95f12f55d1616a4d163e9166087ed4979f5cecc40418a522703",
            "input": input_data
        }
    )
    
    if create_response.status_code != 201:
        raise Exception(f"API error: {create_response.status_code} {create_response.text}")
    
    prediction = create_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 between checks
    
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()
    
    while time.time() - start_time < MAX_TIMEOUT:
        status_response = requests.get(
            f"{BASE_URL}/predictions/{prediction_id}",
            headers=headers
        )
        
        if status_response.status_code != 200:
            raise Exception(f"API error: {status_response.status_code} {status_response.text}")
        
        prediction = status_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")
```

## Performance Optimization
- Use the "Extra Juiced 🔥 (more speed)" speed mode to optimize speed.
- Adjust image size and inference steps to balance quality and processing time.
- Use consistent seeds to generate reproducible results quickly.

## FAQ
### How fast is the Ultra-Fast AI Image Generator API?
- It is the fastest image generation API provided by prunaai with state-of-the-art performance, designed to generate high-quality images in the shortest time possible.

### What are the supported output formats?
- The API supports `jpg`, `png`, and `webp` formats.

### What is the maximum image size?
- The maximum image size is defined by the "image_size" parameter. The default and recommended maximum size is 1024 pixels on the longest side.

### How do I handle rate limiting?
- Implement exponential backoff and retry logic in your code to handle 429 Too Many Requests responses.

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

Generate high-quality AI images from text at lightning speed. From $0.01/call. Try it free on API.market.