Name: PrunaAI – Batch Image Editing | $0.02/call | API.market
Brand: magicapi
SKU: api-magicapi-multi-image-editing-api-prunaai-p-image-edit
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ Ultra-Fast Multi-Image Editing API (PrunaAI)

## Overview
Leverage the power of PrunaAI's cutting-edge technology to perform ultra-fast multi-image editing with unparalleled efficiency and precision. Designed for production use cases, this API allows you to edit multiple images in under 1 second at a cost-effective rate of $0.02 per image.

## Features
- ⚡ Ultra-fast editing: Process multiple images in under 1 second
- 🎨 High precision and efficiency: Utilize advanced AI algorithms for accurate results
- 📷 Multiple image support: Edit multiple images at once with ease
- 🌐 Asynchronous processing: Efficiently manage predictions with async task handling
- 🧩 Flexible customization: Control image generation through seed values, aspect ratios, and safety checks

## Use Cases
1. **E-commerce**: Quickly enhance product images by adjusting colors, lighting, or adding logos.
2. **Social Media**: Automatically edit and optimize images for various social media platforms.
3. **Marketing**: Create variations of promotional images for A/B testing campaigns.
4. **Photography**: Streamline bulk editing tasks such as color correction or applying filters.
5. **Content Creation**: Generate unique imagery for blogs, websites, and digital content.

## Visual Examples
### Input and Output Examples
#### Example 1
**Input:**
![Original Image](https://blog.api.market/wp-content/uploads/2025/12/p-image-edit-input-api-market.jpeg)

**Prompt**: "The woman's dress is changed to black"

**Output:**
![Edited Image](https://blog.api.market/wp-content/uploads/2025/12/p-image-edit-output-api-market.jpeg)

## Pricing
- **Pay As You Go (PAYG)**: Only pay for what you use
- **Cost**: $0.02 per image processed
- **Free Status Checks**: GET requests to check prediction status are free and don't count toward API unit usage
- **No Subscription Fees**: Simple per-call pricing with no monthly subscription fees or usage limits

## API Documentation
Detailed documentation on how to use each endpoint, including example requests and responses.

### Base URL
All API requests should be made to:
```
https://prod.api.market/api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit
```

### Authentication
Include your API key in the request header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API utilizes 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.

Guidelines to implement:
- Use a polling interval of 1 second between status checks.
- Set a maximum timeout of 600 seconds (10 minutes).
- Handle status checking while status is "starting" or "processing".
- Handle results when status becomes "succeeded" or error when "failed" or timeout is reached.

### Endpoints

## Create Prediction
**Endpoint:** `POST /api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit/predictions`

```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "turbo": true,
      "images": [
        "https://blog.api.market/wp-content/uploads/2025/12/p-image-edit-input-api-market.jpeg"
      ],
      "prompt": "The woman's dress is changed to black",
      "aspect_ratio": "1:1"
    }
  }'
```

### Parameters
- **input**: An object containing the parameters for the image editing task.

### Responses
- **201 Created**: Prediction created successfully
  ```json
  {
    "id": "ufawqhfynnddngldkgtslldrkq",
    "version": "21572612bd5577c2cddc926e177b7e50640a8fae9cd51a69677f0d29d37e3df5",
    "status": "starting",
    "created_at": "2025-12-08T09:33:09.821Z"
  }
  ```
- **400 Bad Request**: Invalid input parameters or malformed request
- **401 Unauthorized**: Missing or invalid API key

## Get Prediction Status
**Endpoint:** `GET /api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit/predictions/{id}`

```bash
# Example for checking prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Parameters
- **id**: The unique identifier of the prediction

### Responses
- **200 OK**: Prediction details retrieved successfully
  ```json
  {
    "id": "ufawqhfynnddngldkgtslldrkq",
    "status": "succeeded",
    "output": "https://blog.api.market/wp-content/uploads/2025/12/p-image-edit-output-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"
  }
  ```
- **401 Unauthorized**: Missing or invalid API key
- **404 Not Found**: 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
Subject to rate limits. Ensure proper handling by implementing retry logic.

## Error Handling
### Common Errors
- **400 Bad Request**: Ensure all required parameters are included.
- **401 Unauthorized**: Verify your API key.
- **404 Not Found**: Check if the prediction ID is correct.
- **500 Internal Server Error**: Retry the request.

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

## Implementation Guide
### Example Code in JavaScript
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/multi-image-editing-api-prunaai-p-image-edit";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-api-market-key": apiKey
      },
      body: JSON.stringify({ 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 between checks
  const startTime = Date.now();
  
  while (Date.now() - startTime < MAX_TIMEOUT) {
    // Check prediction status
    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();
    
    // Check status and return if completed
    if (prediction.status === "succeeded") {
      return prediction.output;
    }
    
    // Handle failure
    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }
    
    // Wait before next poll
    await delay(POLL_INTERVAL);
  }
  
  throw new Error("Prediction timed out after 10 minutes");
}
```

### Example Code in Python
```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/multi-image-editing-api-prunaai-p-image-edit"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {"Content-Type": "application/json", "x-api-market-key": API_KEY}
    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json={"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"]
    
    # 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 between checks
    
    headers = {"x-api-market-key": API_KEY}
    start_time = time.time()
    
    while time.time() - start_time < MAX_TIMEOUT:
        # Check prediction status
        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()
        
        # Check status and return if completed
        if prediction["status"] == "succeeded":
            return prediction["output"]
        
        # Handle failure
        if prediction["status"] == "failed":
            error_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {error_msg}")
        
        # Wait before next poll
        time.sleep(POLL_INTERVAL)
    
    raise Exception("Prediction timed out after 10 minutes")
```

### Performance Optimization
- Use the "turbo" mode for faster results when possible.
- Polling interval should be set to 1 second to avoid excessive API calls.
- Implement caching for repeated requests with identical parameters.

## FAQ
**Q: What image formats are supported?**
A: The API supports standard image formats such as JPEG and PNG.

**Q: Can I edit multiple images simultaneously?**
A: Yes, the API allows you to edit multiple images in one request.

**Q: How do I handle errors in my application?**
A: Implement error handling logic based on the status codes and error messages returned by the API.

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

Edit multiple images simultaneously in under 1 second with AI. Supports async processing for efficient, high-volume workflows. Try it free on API.market.