Name: Infinite-You – AI Portrait Generator | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-portrait-style-transformation-api
Availability: InStock
Author: API Market

Shashank Agarwal

# 🧑‍🎨 Portrait Style Transformation API (Infinite-You)

## Overview
The Portrait Style Transformation API (Infinite-You) enables users to convert a single portrait photo into various styles, aesthetics, or backgrounds while preserving the subject’s facial identity. Leveraging high-fidelity AI, this API can produce professional portrait transformations for a wide array of use cases. 

Key strengths include:  
• Consistent identity preservation  
• Wide variety of visual styles (artistic or realistic)  
• Optional pose control using a second reference image  
• Adjustable guidance for fine-grained control over the result  

Below is an example of the sort of images you can transform:

![Sample portrait used as identity reference](https://blog.api.market/wp-content/uploads/2026/04/portrait-style-transform.webp)

## Features
- Preserve Facial Identity: Upload a headshot, and the model ensures the result matches the subject’s face.  
- Style Variety: From hyper-realistic to comic-style or stylized art – define a prompt and transform.  
- Pose Control (Optional): Provide a second image to dictate pose or composition.  
- High-Resolution Output: Generate images up to 1280×1280, with customizable width and height.  
- Anti-Blur & Realism Enhancements: Fine-tune your outcomes with anti-blur and realism toggles.  
- Advanced Control Settings: Adjust diffusion steps, guidance scale, or infusion settings for detailed styling.  

## Use Cases
1. Online Fashion Retail: Display your catalog with dynamic lifestyle backgrounds or complementary styles, all while showcasing consistent model faces.  
2. Photography Studios & Portrait Artists: Rapidly generate multiple creative versions of client portraits without extra photoshoots.  
3. Social Media Branding: Produce on-brand portrait transformations for content creators and influencers.  
4. Entertainment & Gaming: Create fantasy-styled or futuristic avatar images for characters in a game’s social ecosystem.  
5. Professional Profile Images: Transform your headshot into diverse settings for promotions or corporate events, retaining brand identity.

## Visual Examples

### Example Inputs
Below are some example images and parameters you might use with this API:

**Identity Image** (required):  
![Portrait used as the identity reference (id_image)](https://blog.api.market/wp-content/uploads/2026/04/portrait-style-transform.webp)

**Control Image** (optional; controls pose/position):  
![Optional control image that influences pose or style (control_image)](https://example.com/image.jpg)

### Example Output
After processing, an example output might look like this:  
![Example output after transformation](https://blog.api.market/wp-content/uploads/2026/04/output-style-transform-api-market.webp)

## Pricing
• 1 API unit = 1 image processed  
• Queries to check prediction status (GET /api/v1/magicapi/portrait-style-transformation-api/predictions/{id}) are free  
• Various pricing tiers are available to match your usage volume  

## API Documentation

### Base URL
All requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api
```

### Authentication
Include your API key in the request header:

```
x-magicapi-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
This API uses asynchronous processing. Typical flow:

1. Submit a prediction (POST /api/v1/magicapi/portrait-style-transformation-api/predictions).  
2. Receive a prediction ID in the response.  
3. Poll the status endpoint (GET /api/v1/magicapi/portrait-style-transformation-api/predictions/{id}) until the status is “succeeded” or “failed.”  
4. Once it’s “succeeded,” retrieve the “output” field for the resulting image.  

It’s recommended to:  
• Poll every 1 second  
• Use a 600-second (10-minute) max timeout  
• Stop polling if the status transitions to “succeeded” or “failed”

### Endpoints

#### 1) Create a Prediction
• Endpoint:  
  POST /api/v1/magicapi/portrait-style-transformation-api/predictions  

• Description:  
  Starts a new portrait transformation with your desired parameters.

• Request Body Example:
```json
{
  "input": {
    "width": 864,
    "height": 1152,
    "prompt": "a woman with perfect eyes",
    "id_image": "https://blog.api.market/wp-content/uploads/2026/04/portrait-style-transform.webp",
    "num_steps": 30,
    "model_version": "sim_stage1",
    "enable_realism": true,
    "guidance_scale": 3.5,
    "enable_anti_blur": true,
    "infusenet_guidance_end": 1,
    "infusenet_guidance_start": 0,
    "infusenet_conditioning_scale": 1
  }
}
```

• Example curl:
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "width": 864,
      "height": 1152,
      "prompt": "a woman with perfect eyes",
      "id_image": "https://blog.api.market/wp-content/uploads/2026/04/portrait-style-transform.webp",
      "num_steps": 30,
      "model_version": "sim_stage1",
      "enable_realism": true,
      "guidance_scale": 3.5,
      "enable_anti_blur": true,
      "infusenet_guidance_end": 1,
      "infusenet_guidance_start": 0,
      "infusenet_conditioning_scale": 1
    }
  }'
```

• Example Success Response:
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "b1370c5f5b1bb078eaa87332641c9cc6b89fff1bbd5c61f9e0e81370541b24f0",
  "status": "starting",
  "created_at": "2025-05-18T10:44:48.408Z"
}
```

#### 2) Get Prediction Status & Result
• Endpoint:  
  GET /api/v1/magicapi/portrait-style-transformation-api/predictions/{id}

• Description:  
  Queries the status of your prediction and returns the output once completed.

• Path Parameter:  
  id (string) – The unique ID of the prediction you received from the POST request

• Example curl:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

• Example Success Response (status = succeeded):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2026/04/output-style-transform-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"
}
```

## Status Codes
• 200 OK: Request was successful  
• 201 Created: Resource (prediction) successfully created  
• 400 Bad Request: Invalid input or malformed request  
• 401 Unauthorized: Missing or invalid API key  
• 403 Forbidden: You lack permissions for this resource  
• 404 Not Found: Resource (prediction or endpoint) not found  
• 429 Too Many Requests: Rate limit exceeded  
• 500 Internal Server Error: Server-side error occurred  
• 503 Service Unavailable: Service temporarily unavailable, try again  

## Rate Limits
This API may enforce call-per-minute or daily usage limits. If you exceed these limits, you may receive 429 Too Many Requests. Reduce request frequency or contact support for higher limits.

## Error Handling
When requests fail or encounter invalid parameters, a JSON error response is returned. Example:

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

Recommendations:
• Check the "error.code" and "error.message" fields to pinpoint the issue.  
• Retry for transient errors (like 5xx).  
• For repeated 429 responses, pause or back off your request rate.

## Implementation Guide

Below are code samples illustrating how to submit a prediction and poll for results properly. Remember to replace YOUR_API_MARKET_KEY with your actual key.

### Example Code

#### JavaScript (Async/Await)
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api";

async function createAndWaitForPrediction(inputData) {
  try {
    // Step 1: Create the prediction
    const response = await fetch(`${baseUrl}/predictions`, {
      method: "POST",
      headers: {
        "Content-Type": "application/json",
        "x-magicapi-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) {
    const response = await fetch(`${baseUrl}/predictions/${predictionId}`, {
      headers: {
        "x-magicapi-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
```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/portrait-style-transformation-api"

def create_and_wait_for_prediction(input_data):
    # Step 1: Create the prediction
    headers = {
        "Content-Type": "application/json",
        "x-magicapi-key": API_KEY
    }
    
    response = requests.post(
        f"{BASE_URL}/predictions",
        headers=headers,
        json={"input": input_data}
    )
    
    if response.status_code != 200 and response.status_code != 201:
        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-magicapi-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
```bash
# Step 1: Create a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "id_image": "https://example.com/image.jpg"
    }
  }'

# Example response:
# {"id": "abcd1234", "status": "starting"}

# Step 2: Check prediction status
curl -X GET "https://prod.api.market/api/v1/magicapi/portrait-style-transformation-api/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
# Continue polling until "status":"succeeded"
```

### Performance Optimization
- Choose lower “num_steps” if speed is more critical than ultimate detail.  
- Use a smaller image resolution if you only need quick thumbnail results.  
- Adjust “guidance_scale” or “infusenet_conditioning_scale” carefully to reduce iteration time.  

## FAQ

• How long does a transformation take?  
  Typically between 5-30 seconds, depending on image size and complexity.  

• Can I get multiple outputs from a single request?  
  Currently, each API call produces one image. For more variations, submit multiple requests with different seeds or prompts.  

• Why does the face occasionally fail to match the identity?  
  Check your “infusenet_conditioning_scale” and ensure your prompt isn’t overshadowing identity details.  

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

Convert portrait photos into any artistic or realistic style. Optional pose control. From $0.05/call. Try it free on API.market.