Name: Fofr – AI Cartoon Avatars | $0.05/call | API.market
Brand: magicapi
SKU: api-magicapi-face-to-sticker-generator
Availability: InStock
Author: API Market

Shashank Agarwal

# 🪄 Face to Sticker Generator API (fofr) – Instant Cartoon Avatars

## Overview
The Face to Sticker Generator API (fofr) quickly transforms any face into a vibrant, cartoon-style sticker. It’s ideal for creating eye-catching profile images, chat stickers, custom emojis, or fun social media icons. By simply providing an image, you’ll receive colorful sticker outputs in seconds.

This API uses powerful AI-driven image processing to detect facial features and produce high-quality stickers with customizable settings for prompt strength, image width/height, seed, and other parameters.

## Features
- Quickly convert any facial image into a lively cartoon avatar or sticker  
- Flexible options to control prompt strength, resolution, and styling  
- Optional 2× upscaling to achieve high-resolution outputs  
- Asynchronous processing ensures minimal downtime and fast turnaround times  
- Easily retrieve status and results with a simple polling mechanism  

## Use Cases
1. Profile Pictures: Generate fun, distinctive cartoon avatars for social media, forums, or gaming platforms.  
2. Marketing & Branding: Create memorable brand mascots or unique celebrity-themed stickers for promotional campaigns.  
3. Custom Emojis & Chat Stickers: Enhance messaging platforms or group chats using AI-driven sticker packs.  
4. Community Building: Engage online communities by offering members personalized sticker versions of themselves.  
5. Merchandising & Printing: Turn cartoon stickers into physical merchandise like decals or t-shirt prints.

## Visual Examples

Below is an example input image, along with the resulting sticker outputs. These demonstrate how a real face can be transformed into vibrant, cartoon-like stickers.

### Example Input Image
![Example Input Face](https://replicate.delivery/pbxt/KU1AG0cit5nc3xIG1BBZ6DKkhunvvGsZXmEZzuW9HPYVkj8o/MTk4MTczMTkzNzI1Mjg5NjYy.webp)

### Example Output Images
![Example Sticker Output 1](https://replicate.delivery/xezq/GYZ115u3skagJdL7xC3PjthXhR4yNGHrSPO8YOyJtGtxEY9E/ComfyUI_00001_.png)
![Example Sticker Output 2](https://replicate.delivery/xezq/vvHSs2p5vPJtPRNW7ffCYt54fwP43r8I3kG4LPfoCCMaMBWPB/ComfyUI_00002_.png)

## Pricing
• 1 API unit equals 1 image processed (i.e., one POST request to generate a new sticker).  
• GET requests to check prediction status (GET /api/v1/magicapi/face-to-sticker-generator/predictions/{id}) do not consume any API units.  
• Various pricing tiers are available depending on your monthly volume of requests. Check your API.market account for specific tiers and volume discounts.

## API Documentation

### Base URL
All requests should be made to:  
```
https://prod.api.market/api/v1/magicapi/face-to-sticker-generator
```

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

### Asynchronous Processing
This API processes images asynchronously. When you submit a prediction request (POST), you receive a prediction ID. You then poll the GET endpoint with that ID to check the status until completion.

Flow summary:
1. POST /predictions → returns a prediction ID  
2. GET /predictions/{id} → check status (repeat until “succeeded” or “failed”)  
3. If status is “succeeded,” use the output array of sticker URLs  

Implement a polling interval of 1 second and a maximum timeout of 10 minutes (600 seconds).

### Endpoints

#### 1) Create a Prediction
• Endpoint: POST /api/v1/magicapi/face-to-sticker-generator/predictions  
• Description: Creates a new sticker conversion request  
• Required fields:  
  - "input" object with at least the "image" parameter  
• Optional fields include height, width, prompt, negative_prompt, steps, seed, etc.

Example request:
```bash
# Example for creating a prediction
curl -X POST "https://prod.api.market/api/v1/magicapi/face-to-sticker-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
    "input": {
      "image": "https://example.com/image.jpg",
      "prompt": "arnold",
      "width": 1024,
      "height": 1024,
      "steps": 20,
      "prompt_strength": 4.5,
      "ip_adapter_noise": 0.5,
      "ip_adapter_weight": 0.2,
      "instant_id_strength": 0.7,
      "upscale": false,
      "upscale_steps": 10
    }
}'
```

Example response (HTTP 201 Created):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "version": "764d4827ea159608a07cdde8ddf1c6000019627515eb02b6b449695fd547e5ef",
  "status": "starting",
  "created_at": "2025-04-23T20:02:12.684Z"
}
```

#### 2) Retrieve Prediction Status & Results
• Endpoint: GET /api/v1/magicapi/face-to-sticker-generator/predictions/{id}  
• Description: Retrieves the status and output of an existing sticker conversion request using the prediction ID.

Example request:
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/face-to-sticker-generator/predictions/ufawqhfynnddngldkgtslldrkq" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

Example success response (HTTP 200 OK):
```json
{
  "id": "ufawqhfynnddngldkgtslldrkq",
  "status": "succeeded",
  "output": [
    "https://example-output.com/sticker1.png",
    "https://example-output.com/sticker2.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"
}
```

## Status Codes
- 200 OK: Request succeeded. For GET requests, this includes resources or prediction information.  
- 201 Created: Resource successfully created (e.g., POSTing a new prediction request).  
- 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: Requested resource (e.g., prediction ID) does not exist.  
- 429 Too Many Requests: Rate limit exceeded.  
- 500 Internal Server Error: An error occurred on the server.  
- 503 Service Unavailable: Service temporarily down or overloaded.

If you encounter errors:  
• 400 typically indicates missing parameters or incorrect input fields.  
• 401 means your API key is either invalid or missing.  
• 429 means you have exceeded your usage rate limit, and you should either implement a retry strategy or upgrade your plan.

## Rate Limits
The API enforces rate limits to ensure stability. If you exceed your rate limit, you’ll receive a 429 Too Many Requests error. To avoid this, reduce the frequency of requests, implement backoff strategies, or upgrade your plan through your API.market account.

## Error Handling
When an error occurs, the API returns a descriptive JSON response. Example:
```json
{
  "error": {
    "code": "invalid_parameter",
    "message": "The parameter 'image' is required",
    "status": 400
  }
}
```
Recommendation:
- Check the "code" or "message" for details on how to correct the request.  
- Consider implementing retries for transient errors such as 503 Service Unavailable.

## Implementation Guide

### Example Code

Below are examples in JavaScript, Python, and cURL demonstrating how to authenticate, create predictions, poll for results, and handle timeouts.

#### JavaScript (Node.js)
```javascript
// JavaScript example with proper polling and timeout
const apiKey = "YOUR_API_MARKET_KEY";
const baseUrl = "https://prod.api.market/api/v1/magicapi/face-to-sticker-generator";

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) {
    // Check prediction status
    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();

    // 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"}`);
    }

    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/face-to-sticker-generator"

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:
        # 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}")

        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/face-to-sticker-generator/predictions" \
  -H "Content-Type: application/json" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY" \
  -d '{
      "input": {
        "image": "https://example.com/image.jpg"
      }
    }'

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

# Step 2: Check prediction status by polling until "succeeded"
curl -X GET "https://prod.api.market/api/v1/magicapi/face-to-sticker-generator/predictions/abcd1234" \
  -H "x-magicapi-key: YOUR_API_MARKET_KEY"
```

### Performance Optimization
- Minimize repeated or unnecessary requests.  
- Use the polling mechanism only once per second to reduce load.  
- Adjust “prompt_strength” and other parameters appropriately for your image to avoid excessive processing.  

## FAQ
• Q: How long must I wait for a prediction?  
  A: Processing typically completes within seconds to a couple of minutes, depending on image complexity and server load.  
• Q: Can I generate multiple stickers simultaneously?  
  A: Yes, you can send multiple POST requests in parallel, subject to your usage plan and rate limits.  
• Q: What if the output doesn’t look right?  
  A: Experiment with parameters like “prompt_strength,” “ip_adapter_weight,” or try different seeds until you achieve the desired style or appearance.

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

Turn any face into a vibrant cartoon sticker in seconds. Optional 2x upscaling. From $0.05/call. Try it free on API.market.