Name: Platmoji API: AI Emoji Image Generator (FLUX)
Brand: magicapi
SKU: api-magicapi-emoji-generator-appmeloncreator-platmoji-beta
Availability: InStock
Author: API Market

Shashank Agarwal

# 😀 Emoji Image Generator API (appmeloncreator Platmoji Beta)

## Overview
Platmoji Beta is an emoji image generator published by appmeloncreator. Its developer describes it as an emoji generator fine-tuned with FLUX.

Send a text `prompt` describing the emoji you want. You can also pass an `image` for image-to-image generation, or an `image` plus a `mask` for inpainting. Each request returns a list of 1 to 4 image URLs (`num_outputs`).

## Features
- **Text-to-image emoji generation**: describe the emoji in `prompt`.
- **Image-to-image and inpainting**: pass `image` (and optionally `mask`); `prompt_strength` sets how much of the input image is replaced.
- **Two base models**: `dev` (default, best with around 28 steps) or `schnell` (needs only 4 steps).
- **Up to 4 images per request** with `num_outputs`.
- **Aspect ratios**: `1:1` (default), `16:9`, `21:9`, `3:2`, `2:3`, `4:5`, `5:4`, `3:4`, `4:3`, `9:16`, `9:21`, or `custom` with `width` and `height` from 256 to 1440.
- **Output formats**: `webp` (default), `jpg` or `png`, with `output_quality` from 0 to 100.
- **Extra LoRA**: load additional LoRA weights with `extra_lora` and set their strength with `extra_lora_scale`.
- **Seed**: set `seed` to reproduce a result.

## Use Cases
1. **Custom emoji sets**: generate emoji for chat apps, community servers and stickers.
2. **Brand and product emoji**: emoji of mascots, products or characters described in the prompt.
3. **Variations**: request up to 4 candidates at once with `num_outputs` and keep the best one.
4. **Emoji from an existing picture**: send a picture as `image` and describe the emoji version in `prompt`.

## Visual Examples
### Example Input
Prompt: "An emoji of king cat. with a white background the head has to face the camera but the rest can stay. It has to be as high quality as possible. Every emoji you make has to be in the style of emojis. No grey human bodys, if you make people they have to have clothes eyes and hair and a shirt."

Other settings: `model` `dev`, `num_outputs` 3, `num_inference_steps` 50, `guidance_scale` 4.16, `lora_scale` 0.5, `extra_lora_scale` 1, `prompt_strength` 1, `megapixels` `1`, `aspect_ratio` `1:1`, `output_format` `png`, `output_quality` 100, `go_fast` `false`. The request also sent `width` and `height` of 512; they only apply when `aspect_ratio` is `custom`, so this request used `1:1` at about 1 megapixel.

### Example Output
![Platmoji Beta output 1: king cat emoji on a white background](https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-1-2v7vtmr1-api-market.png)

![Platmoji Beta output 2: king cat emoji on a white background](https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-2-2v7vtmr1-api-market.png)

![Platmoji Beta output 3: king cat emoji on a white background](https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-3-2v7vtmr1-api-market.png)

## Input Parameters
| Field | Type | Required | Default | Allowed values | Description |
| --- | --- | --- | --- | --- | --- |
| `prompt` | string | Yes |  |  | Prompt for the generated image |
| `image` | string (URL) | No | none |  | Input image for image-to-image or inpainting mode. If provided, `aspect_ratio`, `width` and `height` are ignored |
| `mask` | string (URL) | No | none |  | Image mask for inpainting mode. If provided, `aspect_ratio`, `width` and `height` are ignored |
| `aspect_ratio` | string | No | `1:1` | `1:1`, `16:9`, `21:9`, `3:2`, `2:3`, `4:5`, `5:4`, `3:4`, `4:3`, `9:16`, `9:21`, `custom` | Aspect ratio of the generated image. `custom` uses `width` and `height` and runs in bf16 mode |
| `height` | integer | No | none | 256 to 1440 | Height of the generated image. Only used when `aspect_ratio` is `custom`. Rounded to the nearest multiple of 16. Not compatible with `go_fast` |
| `width` | integer | No | none | 256 to 1440 | Width of the generated image. Only used when `aspect_ratio` is `custom`. Rounded to the nearest multiple of 16. Not compatible with `go_fast` |
| `prompt_strength` | number | No | `0.8` | 0 to 1 | Prompt strength when using image-to-image. 1.0 fully replaces the information in the input image |
| `model` | string | No | `dev` | `dev`, `schnell` | Model to run. `dev` performs best with around 28 inference steps; `schnell` needs only 4 |
| `num_outputs` | integer | No | `1` | 1 to 4 | Number of images to generate |
| `num_inference_steps` | integer | No | `28` | 1 to 50 | Number of denoising steps. More steps can give more detailed images but take longer |
| `guidance_scale` | number | No | `3` | 0 to 10 | Guidance scale for the diffusion process. Lower values can give more realistic images. Good values to try are 2, 2.5, 3 and 3.5 |
| `seed` | integer | No | none |  | Random seed. Set for reproducible generation |
| `output_format` | string | No | `webp` | `webp`, `jpg`, `png` | Format of the output images |
| `output_quality` | integer | No | `80` | 0 to 100 | Quality when saving the output images. 100 is best, 0 is lowest. Not used for `png` |
| `disable_safety_checker` | boolean | No | `false` |  | Disable the safety checker for generated images |
| `go_fast` | boolean | No | `false` |  | Run with a model optimized for speed (currently fp8 quantized); disable to run in the original bf16 |
| `megapixels` | string | No | `1` | `1`, `0.25` | Approximate number of megapixels of the generated image |
| `lora_scale` | number | No | `1` | -1 to 3 | How strongly the main LoRA is applied. Values between 0 and 1 work well for base inference; with `go_fast` a 1.5x multiplier is applied to this value |
| `extra_lora` | string | No | none |  | Extra LoRA weights to load: a Hugging Face model (`huggingface.co/<owner>/<model-name>`), a CivitAI model (`civitai.com/models/<id>[/<model-name>]`) or a direct `.safetensors` file URL |
| `extra_lora_scale` | number | No | `1` | -1 to 3 | How strongly the extra LoRA is applied. Values between 0 and 1 work well for base inference; with `go_fast` a 1.5x multiplier is applied to this value |

## Pricing
- **Pay As You Go (PAYG) pricing**: you only pay for what you use.
- **Price**: $0.018 per API unit.
- **1 API unit = 1 request with up to 10 seconds of processing.** A request that runs longer bills one more unit for each started 10-second block (for example, 25 seconds of processing is 3 units, $0.054).
- Processing time grows with `num_outputs`, `num_inference_steps` and image size, so larger requests use more units.
- **Example cost**: the example request below (3 images, 50 steps) took 39.2 seconds of processing, which is 4 units: $0.072.
- **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/emoji-generator-appmeloncreator-platmoji-beta`

### 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/emoji-generator-appmeloncreator-platmoji-beta/predictions" \
  -H "Content-Type: application/json" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY" \
  -d '{
    "version": "f5faa5eed754c2a06970417b4224f6ba1374c61723033a09dd2a829725cdf557",
    "input": {
      "model": "dev",
      "width": 512,
      "height": 512,
      "prompt": "An emoji of king cat. with a white background the head has to face the camera but the rest can stay. It has to be as high quality as possible. Every emoji you make has to be in the style of emojis. No grey human bodys, if you make people they have to have clothes eyes and hair and a shirt.",
      "go_fast": false,
      "lora_scale": 0.5,
      "megapixels": "1",
      "num_outputs": 3,
      "aspect_ratio": "1:1",
      "output_format": "png",
      "guidance_scale": 4.16,
      "output_quality": 100,
      "prompt_strength": 1,
      "extra_lora_scale": 1,
      "num_inference_steps": 50
    }
  }'
```

Response (201 Created):
```json
{
  "id": "2v7vtmr115rmt0d1cchtn45tyc",
  "version": "f5faa5eed754c2a06970417b4224f6ba1374c61723033a09dd2a829725cdf557",
  "status": "starting",
  "created_at": "2026-10-22T10:23:20.978Z"
}
```

#### Check Prediction Status
```bash
curl -X GET "https://prod.api.market/api/v1/magicapi/emoji-generator-appmeloncreator-platmoji-beta/predictions/{id}" \
  -H "x-api-market-key: YOUR_API_MARKET_KEY"
```

Response when the prediction has finished (200 OK):
```json
{
  "id": "2v7vtmr115rmt0d1cchtn45tyc",
  "status": "succeeded",
  "output": [
    "https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-1-2v7vtmr1-api-market.png",
    "https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-2-2v7vtmr1-api-market.png",
    "https://blog.api.market/wp-content/uploads/2026/10/platmoji-beta-output-3-2v7vtmr1-api-market.png"
  ],
  "error": null,
  "created_at": "2026-10-22T10:23:20.978Z",
  "started_at": "2026-10-22T10:23:21.245Z",
  "completed_at": "2026-10-22T10:24:00.452Z"
}
```

`output` is a list of image URLs, one per generated image (`num_outputs` long).

### 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 `num_outputs` above 4.
- **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/emoji-generator-appmeloncreator-platmoji-beta";

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: "f5faa5eed754c2a06970417b4224f6ba1374c61723033a09dd2a829725cdf557", 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({
  model: "dev",
  width: 512,
  height: 512,
  prompt: "An emoji of king cat. with a white background the head has to face the camera but the rest can stay. It has to be as high quality as possible. Every emoji you make has to be in the style of emojis. No grey human bodys, if you make people they have to have clothes eyes and hair and a shirt.",
  go_fast: false,
  lora_scale: 0.5,
  megapixels: "1",
  num_outputs: 3,
  aspect_ratio: "1:1",
  output_format: "png",
  guidance_scale: 4.16,
  output_quality: 100,
  prompt_strength: 1,
  extra_lora_scale: 1,
  num_inference_steps: 50
}).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/emoji-generator-appmeloncreator-platmoji-beta"


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": "f5faa5eed754c2a06970417b4224f6ba1374c61723033a09dd2a829725cdf557", "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")


print(create_and_wait_for_prediction({
    "model": "dev",
    "width": 512,
    "height": 512,
    "prompt": "An emoji of king cat. with a white background the head has to face the camera but the rest can stay. It has to be as high quality as possible. Every emoji you make has to be in the style of emojis. No grey human bodys, if you make people they have to have clothes eyes and hair and a shirt.",
    "go_fast": False,
    "lora_scale": 0.5,
    "megapixels": "1",
    "num_outputs": 3,
    "aspect_ratio": "1:1",
    "output_format": "png",
    "guidance_scale": 4.16,
    "output_quality": 100,
    "prompt_strength": 1,
    "extra_lora_scale": 1,
    "num_inference_steps": 50,
}))
```

## FAQ
- **How many emoji does one request return?**
  - Between 1 and 4, set by `num_outputs` (default 1). The output is always a list of URLs.
- **Why are my `width` and `height` ignored?**
  - They only apply when `aspect_ratio` is `custom`, and they are not compatible with `go_fast`. With any other ratio, `megapixels` sets the approximate size.
- **Which model should I pick, `dev` or `schnell`?**
  - `dev` (default) performs best with around 28 inference steps. `schnell` needs only 4 steps, so it finishes sooner and uses fewer API units.
- **How do I keep the cost per request low?**
  - Billing is by processing time in 10-second blocks. Fewer `num_outputs`, fewer `num_inference_steps` or `schnell` keep a request inside fewer blocks.
- **Is the 201 response from POST an error?**
  - No. 201 Created means the prediction was accepted. Use the returned `id` to poll GET `/predictions/{id}` until `status` is `succeeded`, `failed` or `canceled`.
- **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.


Generate emoji images from text with Platmoji Beta, a FLUX fine-tune: up to 4 images per request, image-to-image and inpainting. Pay as you go, no monthly fee.