Name: Flux – AI Headshot Generator | $0.08/call | API.market
Brand: magicapi
SKU: api-magicapi-professional-headshot-generator-flux-kontext-apps-professional-headshot
Availability: InStock
Author: API Market

Shashank Agarwal

# 📸 Professional Headshot Generator API (Flux)

## Overview
The Professional Headshot Generator API (Flux) by flux-kontext-apps is designed to transform any single image into a high-quality professional headshot. Ideal for business, communication, and image-centric applications, this API utilizes advanced AI to produce stunning results in mere seconds.

## Features
- Generate professional headshots from any input image
- Customizable attributes: gender, background, aspect ratio, and output format
- High-quality results suitable for business profiles, CVs, and professional networking
- Fast, efficient processing with asynchronous API calls

## Use Cases
- **Professional Networking**: Enhance LinkedIn profiles or professional networking sites with high-quality headshots.
- **Corporate Websites**: Update employee photos on company webpages to maintain a consistent and polished look.
- **CV and Resume Building**: Create cleaner and more professional images for CVs and resumes.
- **HR Applications**: Streamline the process of employee profile creation for internal databases.
- **Online Portfolios**: Upgrade personal online portfolios with professional-grade images.

## Visual Examples

Below are examples demonstrating the capabilities of the Professional Headshot Generator API:

### Input
![Original image](https://blog.api.market/wp-content/uploads/2025/12/professional-headshot-api-market.webp)

### Output
![Generated professional headshot](https://blog.api.market/wp-content/uploads/2025/12/professional-headshot-output-api-market.png)

## Pricing
- **Pay As You Go (PAYG)**: Only pay for the images processed.
- **1 API unit** equals 1 image processed.
- **GET requests** to check prediction status are free and do not count toward API unit usage.
- **No monthly subscription fees** or usage limits - simple per-call pricing.

## API Documentation

### Base URL
All API requests should be made to:
```plaintext
https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot
```

### Authentication
Authentication is done via API key. Include your API key in the request header:
```plaintext
x-api-market-key: YOUR_API_MARKET_KEY
```

### Asynchronous Processing
**IMPORTANT**: This API uses asynchronous processing for predictions. The typical flow 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

Implement the following:
- Poll with a 1-second interval
- Set a maximum timeout of 600 seconds (10 minutes)
- Handle different statuses and process results accordingly

### Endpoints

#### Create a Prediction
```plaintext
POST /api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions
```

**Request:**
```json
{
  "version": "383e326b60ec0bd451af148f204579fc9dcc13c030df51ff2af628b2d2cdb21e",
  "input": {
    "seed": 1,
    "gender": "female",
    "background": "neutral",
    "input_image": "https://blog.api.market/wp-content/uploads/2025/12/professional-headshot-api-market.webp",
    "aspect_ratio": "1:1",
    "output_format": "png"
  }
}
```

**Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "383e326b60ec0bd451af148f204579fc9dcc13c030df51ff2af628b2d2cdb21e",
  "status": "starting",
  "created_at": "2025-12-05T07:51:38.024Z"
}
```

**Example cURL:**
```bash
curl -X POST "https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "383e326b60ec0bd451af148f204579fc9dcc13c030df51ff2af628b2d2cdb21e",
    "input": {
      "input_image": "https://blog.api.market/wp-content/uploads/2025/12/professional-headshot-api-market.webp",
      "gender": "female",
      "background": "neutral",
      "aspect_ratio": "1:1",
      "output_format": "png"
    }
  }'
```

#### Check Prediction Status
```plaintext
GET /api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions/{id}
```

**Response:**
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": "https://blog.api.market/wp-content/uploads/2025/12/professional-headshot-output-api-market.png",
  "created_at": "2023-01-01T12:00:00.000Z",
  "started_at": "2023-01-01T12:00:05.000Z",
  "completed_at": "2023-01-01T12:01:00.000Z"
}
```

**Example cURL:**
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

## 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
- Details on rate limits:
  - Requests are rate-limited to ensure fair use.
  - Specific rate limits are not disclosed; monitor your call rates to avoid hitting limits.
- Exceeding rate limits will result in a **429 Too Many Requests** response. Implement appropriate retry logic.

## Error Handling
- Interpret error responses to understand issues:
  - **400 Bad Request** indicates validation issues.
  - **401 Unauthorized** suggests invalid API key.
  - **404 Not Found** means the prediction ID does not exist.
- Common errors and solutions:
  - Missing required fields: Ensure all necessary input parameters are provided.
  - Invalid API token: Check and update your API key.
- Recommended retry strategies:
  - Back-off strategy: Increase retry interval on each attempt.
  - Max retry limit: Limit retries to 3-5 attempts to avoid infinite loops.

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

## Implementation Guide

### JavaScript Example
```javascript
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot";

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({ 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; 
  const POLL_INTERVAL = 1000; 
  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
```python
import requests
import time

API_KEY = "YOUR_API_MARKET_KEY"
BASE_URL = "https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot"

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={"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/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
      "input": {
        "input_image": "https://example.com/image.jpg"
      }
    }'

# Check prediction status (replace with actual ID)
curl -X GET "https://prod.api.market/api/v1/magicapi/professional-headshot-generator-flux-kontext-apps-professional-headshot/predictions/abcd1234" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Optimize API usage to reduce costs:
  - Combine multiple image requests when possible
  - Utilize batch processing
- Follow best practices for asynchronous calls to avoid unnecessary delays.

## FAQ
Q: How do I get started with the Professional Headshot Generator API?
A: Visit API.market, sign up, and obtain your API key to begin making requests.

Q: What is the average processing time for a prediction?
A: Processing times vary depending on the input image and settings, ranging from a few seconds to several minutes.

Q: Can I customize the generated headshot's background and aspect ratio?
A: Yes, you can adjust the background and aspect ratio using the respective parameters in the request.

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

Generate professional AI headshots from any single image. Customize gender, background, and aspect ratio. From $0.08/call. Try it free on API.market.