Name: SDXL Finetunes – Generate Image Variations | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-ai-image-variation-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖌️ High-Quality Image Variation API (SDXL-Finetunes)

## Overview
This API transforms existing images into new and creative variations using a powerful SDXL-finetuned model. It focuses on producing high-quality, photorealistic images suitable for visual content creation, marketing materials, or artistic projects. By combining control over prompts, prompts negativity, and adjustable parameters like denoising strength, it enables fine-grained control over the final image output.

Below is an example input image showcasing a lifestyle product photo of a perfume bottle on a wooden table:

![Example Input Image: A lifestyle product photo showcasing a glistening perfume bottle on a wooden table](https://replicate.delivery/pbxt/MkFZUXh7QUtpvY81ENJOEH0tueIRKIyn0jETUY8Q15RO29xe/DALL%C2%B7E%202023-10-27%2017.55.26%20-%20Lifestyle%20product%20photo%20showcasing%20a%20glistening%20perfume%20bottle%20on%20a%20wooden%20table%2C%20catching%20the%20ambient%20light.%20In%20the%20soft-focus%20background%2C%20a%20Swedish%20.png)

And here is a sample output variation (demonstrating the model’s photorealistic capabilities):

![Example Output Image Variation](https://replicate.delivery/xezq/fEGUWx6rBj1iGin9NY6qsMHEk05COT1epdAuwr6JrnRODe6oA/ComfyUI_00001_.webp)

## Features
- Fast, high-quality image transformation leveraging SDXL-based finetuning.  
- Rich control methods (denoise, controlnet, IP-Adapter, LoRA strengths) for detailed customization.  
- Support for multiple image output formats (WEBP, JPEG, PNG).  
- Configurable safety filter to help detect and filter NSFW content.  
- Adjustable width/height, along with advanced sampler and scheduler options.

## Use Cases
1. E-commerce Product Refresh: Rejuvenate product photos with fresh angles or backgrounds to keep listings attractive without scheduling new photoshoots.  
2. Marketing Campaign Visuals: Generate multiple variations of a key image for social media ads, landing pages, and promotional campaigns across different platforms.  
3. Gaming & 3D Design: Quickly iterate on textures or scene ideas for game assets, concept art, and environment design.  
4. Real Estate: Transform property interiors with different lighting or staging elements for visually appealing marketing materials.  
5. Artistic Expressions & Concept Artwork: Realize multiple styles of a concept (e.g., futuristic city, fantasy worlds) from a single reference image.

## Visual Examples
The following examples illustrate the input-to-output transformations:

1. Input Image (Perfume Bottle):
   ![Perfume Bottle on a Wooden Table](https://replicate.delivery/pbxt/MkFZUXh7QUtpvY81ENJOEH0tueIRKIyn0jETUY8Q15RO29xe/DALL%C2%B7E%202023-10-27%2017.55.26%20-%20Lifestyle%20product%20photo%20showcasing%20a%20glistening%20perfume%20bottle%20on%20a%20wooden%20table%2C%20catching%20the%20ambient%20light.%20In%20the%20soft-focus%20background%2C%20a%20Swedish%20.png)

2. Output Variation  
   ![Variation of Perfume Bottle Image](https://replicate.delivery/xezq/fEGUWx6rBj1iGin9NY6qsMHEk05COT1epdAuwr6JrnRODe6oA/ComfyUI_00001_.webp)

These examples show how the input image is used to generate a photorealistic variant, with different visual styles or slight adjustments in detail, lighting, and composition.

## Pricing
- 1 API unit = 1 image processed.  
- GET requests to check prediction status (GET /api/v1/magicapi/ai-image-variation-generator/predictions/{id}) are free and do not count towards API unit usage.  
- Various pricing tiers are available depending on projected usage volume.

## API Documentation

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

### Authentication
Use your API key in the request header:
```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing for predictions:

1. POST your image transformation request.  
2. The response returns a unique prediction ID.  
3. Poll the GET endpoint with the prediction ID to check the prediction status.  
4. When the status is "succeeded," the output contains the processed image URLs.  

Typical approach:
- Poll every 1 second.  
- Stop if the process takes longer than 600 seconds (10 minutes).  
- Manage "failed" status or timeouts gracefully in your code.

### Endpoints

#### 1) Create a Prediction
• Method: POST  
• Endpoint: /api/v1/magicapi/ai-image-variation-generator/predictions  
• Description: Create a new prediction to generate image variations.

Request Body (JSON):
```json
{
  "version": "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
  "input": {
    "cfg": 2.47,
    "steps": 50,
    "width": 2048,
    "height": 2048,
    "prompt": "squirrel sitting on a table with a candle and a bottle of perfume, highly detailed scene, ...",
    "denoise": 0.8,
    "scheduler": "sgm_uniform",
    "input_image": "https://your-input-image-url-here.png",
    "sampler_name": "ddim",
    "output_format": "webp",
    "output_quality": 95,
    "checkpoint_name": "realvisxlV50_v50Bakedvae.safetensors",
    "negative_prompt": "ugly, deformed, soft, watermark, abstract, big hands, ...",
    "ipadapter_end_at": 1,
    "controlnet_strength": 1,
    "lora1_strength_clip": 1,
    "lora2_strength_clip": 0,
    "lora3_strength_clip": 0,
    "lora1_strength_model": 0.5,
    "lora2_strength_model": 0,
    "lora3_strength_model": 0,
    "controlnet_end_percent": 0.5,
    "controlnet_start_percent": 0
  }
}
```

Example cURL:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-image-variation-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
    "input": {
      "cfg": 2.47,
      "steps": 50,
      "width": 2048,
      "height": 2048,
      "prompt": "squirrel sitting on a table with a candle and a bottle of perfume, highly detailed scene...",
      "denoise": 0.8,
      "scheduler": "sgm_uniform",
      "input_image": "https://example.com/input.png",
      "sampler_name": "ddim",
      "output_format": "webp",
      "safety_filter": true,
      "output_quality": 95,
      "checkpoint_name": "realvisxlV50_v50Bakedvae.safetensors",
      "negative_prompt": "ugly, deformed, watermark...",
      "ipadapter_end_at": 1,
      "ipadapter_weight": 0.9,
      "ipadapter_start_at": 0,
      "controlnet_strength": 1,
      "lora1_strength_clip": 1,
      "lora2_strength_clip": 0,
      "lora3_strength_clip": 0,
      "lora1_strength_model": 0.5,
      "lora2_strength_model": 0,
      "lora3_strength_model": 0,
      "controlnet_end_percent": 0.5,
      "controlnet_start_percent": 0
    }
  }'
```

**Response** (201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
  "status": "starting",
  "created_at": "2025-05-18T10:44:52.377Z"
}
```

#### 2) Get Prediction Status
• Method: GET  
• Endpoint: /api/v1/magicapi/ai-image-variation-generator/predictions/{id}  
• Description: Retrieve the status and (once complete) the output of your image variation request.

Example cURL:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-image-variation-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

**Response** (200 OK, succeeded example):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://some-cdn-service/output_image1.webp"
  ],
  "created_at": "2025-05-18T10:44:52.377Z",
  "started_at": "2025-05-18T10:45:00.047Z",
  "completed_at": "2025-05-18T10:45:15.128Z"
}
```

## Status Codes
- 200 OK: Request successful.  
- 201 Created: Prediction resource successfully created.  
- 400 Bad Request: Invalid parameters or malformed request.  
- 401 Unauthorized: Missing or invalid API key.  
- 403 Forbidden: Valid API key, but the request is disallowed.  
- 404 Not Found: Resource (prediction ID) not found.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: An unexpected server error occurred.  
- 503 Service Unavailable: The service is temporarily unavailable.

## Rate Limits
Depending on your plan, you may have rate limits on how many requests you can make per minute. If you exceed these limits, you will receive a 429 Too Many Requests error.  
• To handle rate limits, implement retries with exponential backoff.  
• Optimize polling frequency to avoid hitting rate limits.

## Error Handling
When an error occurs, the API returns a JSON response containing details, for example:

```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'input_image' is required",
    "status": 400
  }
}
```

- Check the HTTP status code to determine the error type.  
- Parse the error message to identify what went wrong.  
- If it’s a transient error (e.g., 429 or 503), implement a backoff retry strategy.

## Implementation Guide

### JavaScript Example (Async/Await)
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/ai-image-variation-generator";

/**
 * Create a new prediction and wait for completion
 */
async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const createResponse = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-key": apiKey
      },
      body: JSON.stringify({ 
        version: "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
        input: inputData 
      })
    });

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

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

    // Step 2: Poll for the results with a 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;  // 10 minutes
  const POLL_INTERVAL = 1000;  // 1 second

  const startTime = Date.now();

  while (Date.now() - startTime < MAX_TIMEOUT) {
    const statusResponse = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: { "x-magicapi-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;  // URLs of generated images
    }

    if (prediction.status === "failed") {
      throw new Error(`Prediction failed: ${prediction.error || "Unknown error"}`);
    }

    // Wait and poll again
    await delay(POLL_INTERVAL);
  }

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

// Usage Example
(async () => {
  try {
    const outputUrls = await createAndWaitForPrediction({
      input_image: "https://example.com/image.jpg",
      prompt: "Photorealistic new variation",
      steps: 30
      // ...other parameters as desired
    });
    console.log("Successfully generated images:", outputUrls);
  } catch (e) {
    console.error("Error generating images:", e.message);
  }
})();
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/ai-image-variation-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": "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
        "input": input_data
    }

    response = requests.post(f"{BASE_URL}/predictions", headers=headers, json=payload)
    if not response.ok:
        raise Exception(f"API error: {response.status_code} {response.text}")

    prediction = response.json()
    prediction_id = prediction["id"]

    # Step 2: Poll the results
    return poll_for_results(prediction_id)

def poll_for_results(prediction_id):
    MAX_TIMEOUT = 600  # 10 minutes
    POLL_INTERVAL = 1  # 1 second
    start_time = time.time()

    while time.time() - start_time < MAX_TIMEOUT:
        response = requests.get(f"{BASE_URL}/predictions/{prediction_id}", headers={"x-magicapi-key": API_KEY})
        if not response.ok:
            raise Exception(f"API error: {response.status_code} {response.text}")

        prediction = response.json()
        if prediction["status"] == "succeeded":
            return prediction["output"]
        if prediction["status"] == "failed":
            err_msg = prediction.get("error", "Unknown error")
            raise Exception(f"Prediction failed: {err_msg}")

        time.sleep(POLL_INTERVAL)

    raise Exception("Prediction timed out after 10 minutes")

# Usage
if __name__ == "__main__":
    try:
        output_urls = create_and_wait_for_prediction({
            "input_image": "https://example.com/image.jpg",
            "prompt": "Photorealistic variations",
            "width": 1024,
            "height": 1024
            # ...other parameters
        })
        print("Output URLs:", output_urls)
    except Exception as e:
        print("Error:", e)
```

### cURL Example
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/ai-image-variation-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "08807c2a252379c60ca5bc07e25d8f26fecfa9ad1d899987be8865e6d6a47ef2",
    "input": {
      "input_image": "https://example.com/image.jpg",
      "prompt": "Some photorealistic style",
      "steps": 30
    }
  }'

# Sample response:
# {
#   "id": "abcd1234",
#   "status": "starting",
#   "created_at": "2025-05-18T10:44:52.377Z"
# }

# Step 2: Check prediction status repeatedly until it is "succeeded"
curl -X GET "https://prod.api.market/api/v1/magicapi/ai-image-variation-generator/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Reduce image dimensions for faster processing and to save on costs (e.g., 512x512 or 768x768) before generating final high-resolution images.  
- Use a suitable sampler and fewer steps (while maintaining image quality) for quicker generation.  
- Employ negative prompts to remove unwanted artifacts, reducing the need for repeated attempts.

## FAQ
1. **How long does it take to generate a single image?**  
   Typically, a few seconds to a few minutes, depending on the complexity of the prompt and resolution.  
2. **Are the results always guaranteed to be safe?**  
   The safety filter helps, but it’s not infallible. If you have specific content restrictions, always inspect results.  
3. **Can I customize the output dimensions?**  
   Yes. You can set the width and height in the request body.  
4. **Is there a limit to how many images I can generate?**  
   This depends on your plan’s usage tier.  
5. **How do I handle partial or corrupted image results?**  
   Check the logs or error response. If necessary, retry with adjusted parameters or a different checkpoint.

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

Transform existing images into new, photorealistic variations using a powerful SDXL-finetuned model. From $0.05/call. Try it free on API.market.