Name: Z-Image Turbo Img2Img API: Fast Image to Image
Brand: magicapi
SKU: api-magicapi-image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img
Availability: InStock
Author: API Market

Shashank Agarwal

# 🖼️ Image-to-Image Generator API (Pruna AI Z-Image Turbo Img2Img)

## Overview
Z-Image Turbo Img2Img is the image-to-image version of the Z-Image Turbo model, served by Pruna AI with LoRA support.

Send an input `image` and a text `prompt` describing the result you want. `strength` sets how far the result moves away from the input image. You can load your own LoRA weights from URLs. Each request returns the URL of one image in JPG, PNG or WebP.

## Features
- **Image-to-image**: transform an input image guided by a text prompt.
- **Strength control**: `strength` runs from 0.0 (no change) to 1.0 (full transformation), default 0.6.
- **Few steps**: `num_inference_steps` defaults to 8 (1 to 50). `guidance_scale` should stay at 0 for this Turbo model.
- **LoRA support**: pass `.safetensors`, tar or zip URLs in `lora_weights` and an optional scale per LoRA in `lora_scales` (1.0 each by default).
- **Output format**: `jpg` (default), `png` or `webp`, with `output_quality` from 0 to 100 for JPG and WebP.
- **Seed**: set `seed` to reproduce a result.

## Use Cases
1. **Restyle a photo**: keep the composition of an image and change its look with a prompt.
2. **Prompt-guided variations**: create versions of a product, portrait or scene image with a moderate `strength`.
3. **Custom styles**: apply your own LoRA weights to an input image.
4. **Refine a draft**: give a rough image and a detailed prompt, as in the example.

## Visual Examples
### Example Input
![Input image](https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-input-api-market.jpg)

Prompt: "A young Asian woman with long, vibrant purple hair stands on a sunlit sandy beach, posing confidently with her left hand resting on her hip. She gazes directly at the camera with a neutral expression. A sleek black ribbon bow is tied neatly on the right side of her head, just above her ear. She wears a flowing white cotton dress with a fitted bodice and a flared skirt that reaches mid-calf, slightly lifted by a gentle sea breeze. The beach behind her features fine, pale golden sand with subtle footprints, leading to calm turquoise waves under a clear blue sky with soft, wispy clouds. The lighting is natural daylight, casting soft shadows to her left, indicating late afternoon sun. The horizon line is visible in the background, with a faint silhouette of distant dunes. Her skin tone is fair with a natural glow, and her facial features are delicately defined. The composition is centered on her figure, framed from mid-thigh up, with shallow depth of field blurring the distant waves slightly."

Settings: `strength` `0.6`, `num_inference_steps` `8`, `guidance_scale` `0`, `output_format` `jpg`, `output_quality` `80`.

### Example Output
![Z-Image Turbo Img2Img output for the beach portrait prompt](https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-output-69w2ht9c-api-market.jpeg)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes | none |  | Text prompt for image generation |
| `image` | string (URL) | Yes | none |  | Input image URL to transform |
| `strength` | number | No | `0.6` | 0 to 1 | Strength of the img2img transformation. 0.0 is no change, 1.0 is full transformation |
| `num_inference_steps` | integer | No | `8` | 1 to 50 | Number of inference steps. This results in (num_inference_steps - 1) model forward passes |
| `guidance_scale` | number | No | `0` | 0 to 20 | Guidance scale. Should be 0 for Turbo models |
| `seed` | integer | No | none |  | Random seed. Set it for reproducible generation |
| `lora_weights` | array of strings | No | none |  | LoRA weights as an array of URLs. Supports .safetensors URLs, tar files and zip files |
| `lora_scales` | array of numbers | No | none |  | Scale for each LoRA as an array of numbers. Must match the number of `lora_weights`. Defaults to 1.0 for each if not provided |
| `output_format` | string | No | `jpg` | `png`, `jpg`, `webp` | Format of the output image |
| `output_quality` | integer | No | `80` | 0 to 100 | Quality when saving the output image, from 0 to 100. 100 is best quality, 0 is lowest quality. Not relevant for png output |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.043 per API unit.
- **1 API unit = 1 request with up to 25 seconds of processing.** A request that takes longer uses one unit per started block of 25 seconds (for example, 30 seconds of processing uses 2 units, $0.086).
- More `num_inference_steps` and LoRA loading take longer and can use more units.
- **Example cost**: the example request took 3.5 seconds of processing, which is 1 unit = **$0.043**.
- **Failed or cancelled predictions are not billed.**
- **GET requests to check prediction status** are free and don't count toward API unit usage.
- **No monthly subscription fee.**

## API Documentation

### Base URL
All API requests go to: `https://prod.api.market/api/v1/magicapi/image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img`

### Authentication
Send your api.market API key in the `x-api-market-key` header:
```
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API is asynchronous. The flow is:
1. Send a POST request to `/predictions`. A successful request returns **201 Created** with a prediction `id` and a `status` of `starting` or `processing`.
2. Poll GET `/predictions/{id}` with that ID.
3. Keep polling while `status` is `starting` or `processing`.
4. Stop when `status` is `succeeded` (read `output`), `failed` or `canceled` (read `error`).

A polling interval of 1 second and an overall timeout of 600 seconds (10 minutes) work well.

### Endpoints

#### Create a Prediction
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "7142e836070262fece6f2c4356aec87e9aec27bf31c65ef6b3983e0153e9518c",
    "input": {
      "image": "https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-input-api-market.jpg",
      "prompt": "A young Asian woman with long, vibrant purple hair stands on a sunlit sandy beach, posing confidently with her left hand resting on her hip. She gazes directly at the camera with a neutral expression. A sleek black ribbon bow is tied neatly on the right side of her head, just above her ear. She wears a flowing white cotton dress with a fitted bodice and a flared skirt that reaches mid-calf, slightly lifted by a gentle sea breeze. The beach behind her features fine, pale golden sand with subtle footprints, leading to calm turquoise waves under a clear blue sky with soft, wispy clouds. The lighting is natural daylight, casting soft shadows to her left, indicating late afternoon sun. The horizon line is visible in the background, with a faint silhouette of distant dunes. Her skin tone is fair with a natural glow, and her facial features are delicately defined. The composition is centered on her figure, framed from mid-thigh up, with shallow depth of field blurring the distant waves slightly.",
      "strength": 0.6,
      "output_format": "jpg",
      "guidance_scale": 0,
      "output_quality": 80,
      "num_inference_steps": 8
    }
  }'
```

Response (201 Created):
```json
{
  "id": "69w2ht9cpnrp00d1d21ae6vaf0",
  "version": "7142e836070262fece6f2c4356aec87e9aec27bf31c65ef6b3983e0153e9518c",
  "status": "starting",
  "created_at": "2026-10-23T11:25:24.186Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "69w2ht9cpnrp00d1d21ae6vaf0",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-output-69w2ht9c-api-market.jpeg",
  "error": null,
  "created_at": "2026-10-23T11:25:24.186Z",
  "started_at": "2026-10-23T11:27:19.707Z",
  "completed_at": "2026-10-23T11:27:23.220Z"
}
```

`output` is a single URL string pointing to the generated image.

### Status Codes
- **201 Created**: prediction created (POST `/predictions`). This is the normal success response.
- **200 OK**: prediction details returned (GET `/predictions/{id}`).
- **400 Bad Request**: invalid input, for example a missing `prompt` or `image`, a `strength` outside 0 to 1, or a `num_inference_steps` above 50.
- **401 Unauthorized**: missing or invalid API key.
- **404 Not Found**: no prediction with that ID.
- **429 Too Many Requests**: rate limit exceeded.
- **500 Internal Server Error** or **503 Service Unavailable**: temporary server problem; retry later.

## Rate Limits
All plans allow 10 requests per second. Requests above that return `429 Too Many Requests`; back off before retrying and honour any `Retry-After` header. Polling a prediction with GET is free but still counts toward the per-second limit, so poll every 1 to 5 seconds rather than in a tight loop.

## Error Handling
- Check the HTTP status code of every request and read the response body for the error message.
- A prediction can also end with `status` set to `failed`; the `error` field then explains why. Failed predictions are not billed.
- Retry 429, 500 and 503 responses with exponential backoff. Fix the input before retrying a 400.

## Implementation Guide
### Example Code

#### JavaScript
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img";

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

  if (response.status !== 201) {
    throw new Error(`API error: ${response.status} ${await response.text()}`);
  }

  const prediction = await response.json();
  return pollForResults(prediction.id);
}

const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

async function pollForResults(predictionId) {
  const maxTimeout = 600000;
  const pollInterval = 1000;
  const startTime = Date.now();

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

    if (!response.ok) {
      throw new Error(`API error: ${response.status} ${await response.text()}`);
    }

    const prediction = await response.json();

    if (prediction.status === "succeeded") {
      return prediction.output;
    }

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

    await delay(pollInterval);
  }

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

createAndWaitForPrediction({
  "image": "https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-input-api-market.jpg",
  "prompt": "A young Asian woman with long, vibrant purple hair stands on a sunlit sandy beach, posing confidently with her left hand resting on her hip. She gazes directly at the camera with a neutral expression. A sleek black ribbon bow is tied neatly on the right side of her head, just above her ear. She wears a flowing white cotton dress with a fitted bodice and a flared skirt that reaches mid-calf, slightly lifted by a gentle sea breeze. The beach behind her features fine, pale golden sand with subtle footprints, leading to calm turquoise waves under a clear blue sky with soft, wispy clouds. The lighting is natural daylight, casting soft shadows to her left, indicating late afternoon sun. The horizon line is visible in the background, with a faint silhouette of distant dunes. Her skin tone is fair with a natural glow, and her facial features are delicately defined. The composition is centered on her figure, framed from mid-thigh up, with shallow depth of field blurring the distant waves slightly.",
  "strength": 0.6,
  "output_format": "jpg",
  "guidance_scale": 0,
  "output_quality": 80,
  "num_inference_steps": 8
}).then((output) => console.log(output));
```

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

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/image-to-image-generator-lora-support-prunaai-z-image-turbo-img2img"


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": "7142e836070262fece6f2c4356aec87e9aec27bf31c65ef6b3983e0153e9518c", "input": input_data},
    )

    if response.status_code != 201:
        raise Exception(f"API error: {response.status_code} {response.text}")

    return poll_for_results(response.json()["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}/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"] in ("failed", "canceled"):
            raise Exception(f"Prediction {prediction['status']}: {prediction.get('error') or 'Unknown error'}")

        time.sleep(poll_interval)

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


output = create_and_wait_for_prediction({
    "image": "https://blog.api.market/wp-content/uploads/2026/10/z-image-turbo-img2img-input-api-market.jpg",
    "prompt": "A young Asian woman with long, vibrant purple hair stands on a sunlit sandy beach, posing confidently with her left hand resting on her hip. She gazes directly at the camera with a neutral expression. A sleek black ribbon bow is tied neatly on the right side of her head, just above her ear. She wears a flowing white cotton dress with a fitted bodice and a flared skirt that reaches mid-calf, slightly lifted by a gentle sea breeze. The beach behind her features fine, pale golden sand with subtle footprints, leading to calm turquoise waves under a clear blue sky with soft, wispy clouds. The lighting is natural daylight, casting soft shadows to her left, indicating late afternoon sun. The horizon line is visible in the background, with a faint silhouette of distant dunes. Her skin tone is fair with a natural glow, and her facial features are delicately defined. The composition is centered on her figure, framed from mid-thigh up, with shallow depth of field blurring the distant waves slightly.",
    "strength": 0.6,
    "output_format": "jpg",
    "guidance_scale": 0,
    "output_quality": 80,
    "num_inference_steps": 8
})
print(output)
```

## FAQ
- **How much does the result change from my image?**
  - That is set by `strength`: 0.0 keeps the input, 1.0 is a full transformation, and the default 0.6 is in between.
- **Should I change `guidance_scale`?**
  - The model description says it should be 0 for Turbo models, which is the default.
- **How do I use a LoRA?**
  - Put one or more LoRA URLs (.safetensors, tar or zip) in `lora_weights`. Add `lora_scales` with one number per LoRA, or leave it out to use 1.0 for each.
- **How many steps should I use?**
  - The default 8 `num_inference_steps` suits this Turbo model. You can set 1 to 50; more steps take longer and can use more units.
- **What if my prediction fails?**
  - Failed predictions are not billed. Read the `error` field, adjust the input and try again.

## Contact Us
If you have any questions, reach out to us through the chat on the bottom right of the page. You can also email our support team at hello@magicapi.com.


Turn an input image into a new one guided by a text prompt with Z-Image Turbo Img2Img, with strength control and LoRA support. Pay as you go, no monthly fee.