Name: Flux 2 Pro – Generate & Edit Images | $0.02/call | API.market
Brand: magicapi
SKU: api-magicapi-high-quality-image-generation-editing-black-forest-labs-flux-2-pro
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ High-Quality Image Generator & Editor API (Flux 2 Pro)

## Overview
The Flux 2 Pro API provides high-quality image generation and editing capabilities. This API allows users to generate and edit images with exceptional precision and customization by supporting up to eight reference images.

Key capabilities include:
- High-quality image generation
- Image editing with multiple inputs
- Custom aspect ratios and resolutions
- Support for various output formats

## Features
- 🌟 High-quality image generation with customizable prompts
- 🖼️ Support for up to 8 reference images for precise customizations
- 📏 Adjustable image dimensions with custom width and height
- 📷 Various output formats (JPEG, PNG, WebP)
- ⚙️ Configurable output quality and resolution
- 🔒 Safety tolerance settings for content moderation

## Use Cases
1. **Digital Marketers**
   - Create eye-catching visual content for social media campaigns.
   - Generate customized banners and posters based on specific prompts.

2. **E-commerce Platforms**
   - Generate high-quality product images with different backgrounds.
   - Automated editing of product images, adjusting dimensions, and formats.

3. **Creative Professionals**
   - Generate artwork and visual assets for design projects.
   - Enhance and edit photographs with custom prompts and settings.

4. **Developers and AI Enthusiasts**
   - Integrate image generation and editing into applications and services.
   - Experiment and build AI-based imaging solutions.

5. **Advertising Agencies**
   - Create tailored advertorial images based on campaign requirements.
   - Generate multiple variations of ad creatives for A/B testing.

## Visual Examples

### Example Input and Output
Input Prompt: Glossy candy-colored 3D letters in hot pink, electric orange, and lime green on a sun-drenched poolside patio with bold terrazzo tiles and vintage lounge chairs in turquoise and yellow. Shot on Kodachrome film with a Hasselblad 500C, warm golden afternoon sunlight, dramatic lens flare, punchy oversaturated colors with that distinctive 70s yellow-orange cast, shallow depth of field with the text sharp in the foreground, tropical palms and a sparkling aquamarine pool behind that spells out "Run FLUX.2 [pro] on 'API.market!'" Make it grand and nice.   (API.market is the platform name, make it super huge)"

Input Image:
Add any Image URL you want to use as the Input image

Output Image:
![Description of what the output image shows](https://blog.api.market/wp-content/uploads/2025/12/flux-pro-api-market.webp)

## Pricing
- **Pay As You Go (PAYG) pricing**: Pay only for what you use.
- 1 API unit equals 1 image processed.
- GET requests to check prediction status are free and don't count toward API unit usage.
- 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/high-quality-image-generation-editing-black-forest-labs-flux-2-pro`

### Authentication
Include your API key in the request header:
```http
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 the status.
4. Continue polling until the prediction is complete.

Implementation guidelines include:
- A polling interval of 1 second between status checks.
- A maximum timeout of 600 seconds (10 minutes).
- Status checking logic while status is "starting" or "processing".
- Result handling when the status becomes "succeeded".
- Error handling when the status becomes "failed" or timeout is reached.

### Endpoints

#### Create a Prediction
**Endpoint:** `POST /api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions`

**Description:** Run inference with the black-forest-labs/flux-2-pro model.

**Request Body:**
```json
{
  "version": "285631b5656a1839331cd9af0d82da820e2075db12046d1d061c681b2f206bc6",
  "input": {
    "prompt": "Your prompt here",
    "resolution": "1 MP",
    "aspect_ratio": "1:1",
    "input_images": ["https://example.com/image.jpg"],
    "output_format": "webp",
    "output_quality": 80,
    "safety_tolerance": 2
  }
}
```

**Example Curl:**
```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "prompt": "Glossy candy-colored 3D letters in hot pink, electric orange, and lime green on a sun-drenched poolside patio with bold terrazzo tiles and vintage lounge chairs in turquoise and yellow.",
      "resolution": "1 MP",
      "aspect_ratio": "1:1",
      "input_images": [],
      "output_format": "webp",
      "output_quality": 80,
      "safety_tolerance": 2
    }
  }'
```

**Response:**
- Success (201):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "285631b5656a1839331cd9af0d82da820e2075db12046d1d061c681b2f206bc6",
  "status": "starting",
  "created_at": "2023-01-01T12:00:00.000Z"
}
```

- Error (400):
```json
{
  "detail": [
    {
      "loc": ["body", "input", "prompt"],
      "msg": "field required",
      "type": "value_error.missing"
    }
  ]
}
```

#### Get Prediction Status
**Endpoint:** `GET /api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions/{id}`

**Description:** Get the status and results of a Flux 2 Pro prediction.

**Parameters:**
- `id` (string, required): The prediction ID.

**Example Curl:**
```bash
# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Response:**
- Success (200):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/flux-pro-api-market.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"
}
```

- Error (404):
```json
{
  "detail": "Prediction not found"
}
```

## 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:
- Users are allowed a certain number of requests per minute. 
- If the rate limit is exceeded, the API will respond with a 429 Too Many Requests status.

## Error Handling
Guidance on error handling:
- Interpret error responses using the "error" field.
- Common errors include invalid parameters and exceeding rate limits.
- Implement retries for errors related to excessive requests or server availability.

**Error Response Example:**
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```

## Implementation Guide

### Example Code
Implementing and using the API in JavaScript, Python, and cURL.

1. Authenticate with the API
2. Make API requests
3. Handle responses and errors
4. Implement retries for long-running operations

**JavaScript Example:**
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions";

async function createAndWaitForPrediction(inputData) {
  try {
    const response = await fetch(`${baseUrl}`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({
        version: "285631b5656a1839331cd9af0d82da820e2075db12046d1d061c681b2f206bc6",
        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;
  const POLL_INTERVAL = 1000;
  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const response = await fetch(`${baseUrl}/${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") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    await delay(POLL_INTERVAL);
  }

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

**Python Example:**
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions"

def create_and_wait_for_prediction(input_data):
    headers = {
        "Content-Type": "application/json",
        "x-api-market-key": API_KEY
    }

    response = requests.post(
        BASE_URL,
        headers=headers,
        json={"version": "285631b5656a1839331cd9af0d82da820e2075db12046d1d061c681b2f206bc6", "input": input_data}
    )

    if response.status_code != 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
    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}/{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")
```

**cURL Example:**
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "285631b5656a1839331cd9af0d82da820e2075db12046d1d061c681b2f206bc6",
    "input": {
      "prompt": "Your prompt here",
      "resolution": "1 MP",
      "aspect_ratio": "1:1",
      "input_images": ["https://example.com/image.jpg"],
      "output_format": "webp",
      "output_quality": 80,
      "safety_tolerance": 2
    }
  }'

# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/high-quality-image-generation-editing-black-forest-labs-flux-2-pro/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Optimize image inputs to match the required formats and sizes.
- Batch requests for multiple images processing to save time.
- Adjust the image resolution and quality settings to balance quality and performance.

## FAQ
**Q: How many images can I process per request?**
A: You can process up to 8 reference images per request.

**Q: What formats are supported for output?**
A: The API supports JPEG, PNG, and WebP formats for output images.

**Q: Is there a rate limit on the API?**
A: Yes, the API enforces rate limits on requests per minute. Handle 429 errors by implementing retry logic.

**Q: How do I handle errors?**
A: Check error responses for specific error codes and messages. Implement retries for temporary issues and correct request parameters for persistent errors.

## 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 and edit high-quality images using text and up to 8 reference photos. Supports custom aspect ratios. From $0.02/call. Try it free on API.market.