Name: Flux Kontext Fast – AI Image Editing | $0.01/call | API.market
Brand: magicapi
SKU: api-magicapi-ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast
Availability: InStock
Author: API Market

Shashank Agarwal

# ⚡ Ultra-Fast Contextual API (Flux-Kontent)

## Overview
The ⚡ Ultra-Fast Contextual API (Flux-Kontent) enables developers to access ultra-fast contextual data processing capabilities with minimal latency. Utilizing the `prunaai/flux-kontext-fast` model, the API can rapidly process and return precise contextual data, making it ideal for real-time applications.

## Features
- High-speed context processing 
- Support for image-based and text-based prompts
- Customizable output settings including image size and quality
- Flexible aspect ratio options to match various output needs
- Multiple speed optimization levels to balance performance and quality

## Use Cases
- **E-commerce Product Recommendations:** Enhance product listings by dynamically generating contextual product descriptions and recommendations based on user preferences.
- **Content Moderation:** Rapidly analyze and classify user-generated content to moderate platform content in real-time.
- **Social Media & Marketing:** Create engaging and contextually relevant content for social media campaigns quickly and efficiently.
- **Healthcare:** Process and analyze medical images for faster diagnostics and more accurate results.
- **Gaming:** Generate dynamic in-game graphics and scenarios on the fly to keep gameplay fresh and engaging.

## Visual Examples
**Input Image:**
![Prompt: Replace “schnell” by “Kontext” and make the prune blue](https://blog.api.market/wp-content/uploads/2026/01/flux-schnell-api-market.png)

**Output Image:**
![Result after processing](https://blog.api.market/wp-content/uploads/2026/01/output-flux-api-market.jpeg)

## Pricing
- **Pay As You Go (PAYG):** Only pay for what you use.
- **1 API Unit = 1 Image Processed.**
- **GET requests** to check prediction status are free and do not count toward API 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/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast
```

### Authentication
Authentication is handled via an 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 workflow 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.

### Endpoints

#### Create a Prediction
**Endpoint:** `POST /api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions`

**Summary:** Create a new prediction using the `prunaai/flux-kontext-fast` model.

**Example Request:**
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "6efb57153457f8c51fb813c6d15f45d896f1916dd7d732af49d6a4b09488e2a6",
    "input": {
      "seed": -1,
      "prompt": "Replace “schnell” by “Kontext” and make the prune blue",
      "guidance": 2.5,
      "image_size": 1024,
      "speed_mode": "Real Time",
      "aspect_ratio": "match_input_image",
      "img_cond_path": "https://blog.api.market/wp-content/uploads/2026/01/flux-schnell-api-market.png",
      "output_format": "jpg",
      "output_quality": 80,
      "num_inference_steps": 30
    }
  }'
```

**Example Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "6efb57153457f8c51fb813c6d15f45d896f1916dd7d732af49d6a4b09488e2a6",
  "status": "starting",
  "created_at": "2026-01-28T17:24:08.673Z"
}
```

#### Get Prediction Status and Results
**Endpoint:** `GET /api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions/{id}`

**Summary:** Retrieve the status and results of a prediction.

**Example Request:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

**Example Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/01/output-flux-api-market.jpeg",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

## 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
- Implement retry mechanisms to handle rate limits effectively.
- Follow the fair use policy and avoid overwhelming the API with excessive requests.

## Error Handling
### Interpreting Error Responses
- Check the HTTP status code.
- Read the error message provided in the response.

### Common Errors and Resolutions
- **400 Bad Request:** Ensure all required parameters are included and valid.
- **401 Unauthorized:** Verify that your API key is correct and properly included in the request headers.
- **429 Too Many Requests:** Implement exponential backoff for retry strategy to handle rate limit errors.

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

## Implementation Guide

### Example Code

**JavaScript example with async/await:**
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast";

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: "6efb57153457f8c51fb813c6d15f45d896f1916dd7d732af49d6a4b09488e2a6", 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 between checks
  
  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") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```

**Python example with requests:**
```python
import requests
import time

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

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": "6efb57153457f8c51fb813c6d15f45d896f1916dd7d732af49d6a4b09488e2a6", "input": input_data}
    )
    
    if response.status_code != 200:
        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 between checks
    
    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"] == "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
# create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "6efb57153457f8c51fb813c6d15f45d896f1916dd7d732af49d6a4b09488e2a6",
    "input": {
      "prompt": "Replace “schnell” by “Kontext” and make the prune blue",
      "img_cond_path": "https://blog.api.market/wp-content/uploads/2026/01/flux-schnell-api-market.png"
    }
  }'

# Check the prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/ultra-fast-flux-kontext-api-prunaai-flux-kontext-fast/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Optimize your requests to use the minimum necessary processing power and bandwidth.
- Adjust `guidance` and `num_inference_steps` to balance between speed and quality.
- Choose the appropriate `output_format` and `output_quality` for your use case.

## FAQ
**Q: How do I obtain my API key?**
A: After registering on API.market, you will receive your unique API key via email. You can also manage your API keys in the dashboard.

**Q: What is the expected response time for predictions?**
A: Depending on the complexity, most predictions are processed within a few seconds to a few minutes.

**Q: How do I handle rate limiting?**
A: Implement exponential backoff and retry strategies to handle rate limit errors gracefully.

## Contact Us
If you have any questions or need assistance, you can reach out to us through the embedded chat at the bottom right corner of the page or send an email to hello[at]api.market.

Edit images using text prompts with context-aware AI. Replace backgrounds, modify objects, and transfer styles. From $0.01/call. Try it free on API.market.