Every endpoint, documented completely.

01Authentication

Every request needs an API key from Dashboard → API keys in the Authorization header:

Authorization: Bearer ank_your_key_here

• Keys are ank_ followed by 64 hex characters. We store only a SHA-256 hash, so a key is shown once when you create it.
• Revoke a key from the dashboard at any time; requests with it then return 401 immediately.
• Keep keys on the server. Anyone holding a key can spend your balance.

02POST /api/generate

Generate one image. The body is JSON:

Every field

curl https://animeapi.ai/api/generate \
  -H "Authorization: Bearer $ANIMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a girl with a red umbrella at a rainy bus stop",
    "model": "anime",
    "orientation": "landscape",
    "enhance": true,
    "allowNSFW": false
  }'

An ultra request

curl https://animeapi.ai/api/generate \
  -H "Authorization: Bearer $ANIMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "anime illustration, a cafe chalkboard that reads OPEN LATE", "model": "ultra", "orientation": "square"}'

In your language

curl https://animeapi.ai/api/generate \
  -H "Authorization: Bearer $ANIMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a girl with a red umbrella at a rainy bus stop", "model": "anime", "orientation": "portrait"}'

import os
import requests

res = requests.post(
    "https://animeapi.ai/api/generate",
    headers={"Authorization": f"Bearer {os.environ['ANIMEAPI_KEY']}"},
    json={"prompt": "a girl with a red umbrella at a rainy bus stop", "model": "anime", "orientation": "portrait"},
    timeout=120,
)
data = res.json()
if not res.ok:
    raise SystemExit(f"{res.status_code} {data.get('code', '')}: {data['error']}")

print(data["image_url"])
print(data["enhanced_prompt"])

// generate.mjs · Node 18+ · run: node generate.mjs
const res = await fetch("https://animeapi.ai/api/generate", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.ANIMEAPI_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    prompt: "a girl with a red umbrella at a rainy bus stop",
    model: "anime",
    orientation: "portrait",
  }),
});

const data = await res.json();
if (!res.ok) throw new Error(`${res.status} ${data.code ?? ""}: ${data.error}`);

console.log(data.image_url);
console.log(data.enhanced_prompt);

03Response

200 OK with:

{
  "image_url": "https://…/5e1c9a4f.webp",
  "enhanced_prompt": "masterpiece, best quality, absurdres, 1girl, solo, red_umbrella, holding_umbrella, bus_stop, rain, night, …",
  "balance_usd": 9.991,
  "generation_time_ms": 4121
}

04Models & pricing

Prices are per successful image (videos are priced per second, see below). Add $5–$1,000 at a time on Billing; the balance never expires.

• anime: best for characters. Understands tags; can’t render legible text; strongly prefers drawing a person.
• ultra: follows long, compositional sentences and renders text. An anime style is added to every prompt, so plain descriptions come out as anime.
• ultra-max: ultra with more care: finer detail, better hands and typography.

Latency measured end to end on 2026-09-24 over 16 anime, 5 ultra and 5 ultra-max calls. Not a guarantee.

05Prompt enhancement

The anime model was trained on booru tags, not sentences. With enhance: true (the default), a fast language model rewrites your prompt into Danbooru-style tags before generation, adding about a second. The tags come back in enhanced_prompt.

• To reuse a look exactly, send a previous enhanced_prompt back as the prompt with enhance: false.
• If you already write tags, turn enhancement off. It occasionally adds contradictory tags (for example 1girl next to no_humans).
• Ultra and ultra-max don’t use tags: they keep your sentence and append an anime style, shown in enhanced_prompt.

06POST /api/videos

Start one anime video: text-to-video, or animated from a first and/or last frame you supply. Rendering takes a while, so this returns 202 with a job id straight away; poll GET /api/videos/{id} until it finishes. The price is charged when the job starts and refunded automatically if it fails.

Send neither frame for text-to-video. Send one or both to animate from, toward, or between your own images, for example a character you generated with /api/generate.

Text to video

curl https://animeapi.ai/api/videos \
  -H "Authorization: Bearer $ANIMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in",
    "resolution": "480p",
    "duration": 5,
    "orientation": "landscape"
  }'

From a first frame

curl https://animeapi.ai/api/videos \
  -H "Authorization: Bearer $ANIMEAPI_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "she rides down the hill toward the sea, hair and ribbon blowing in the wind",
    "first_frame": "https://animeapi.ai/gen/wall-bike-sea.webp",
    "resolution": "480p",
    "duration": 5
  }'

202 Accepted

{
  "id": "j57c2x9k…",
  "status": "processing",
  "poll_url": "https://animeapi.ai/api/videos/j57c2x9k…",
  "enhanced_prompt": "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in, anime style, …",
  "resolution": "480p",
  "duration": 5,
  "orientation": "landscape",
  "cost_usd": 0.08,
  "balance_usd": 9.92
}

Pricing

Per requested second, charged up front, refunded if the video fails.

Sizes are nominal. With a first frame, the image sets the canvas.

07GET /api/videos/{id}

Poll with the same key, about every 5 seconds, until status is succeeded or failed. Only the account that created a video can read it.

curl https://animeapi.ai/api/videos/$VIDEO_ID \
  -H "Authorization: Bearer $ANIMEAPI_KEY"

{
  "id": "j57c2x9k…",
  "status": "processing",
  "video_url": null,
  "prompt": "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in",
  "enhanced_prompt": "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in, anime style, …",
  "resolution": "480p",
  "duration": 5,
  "orientation": "landscape",
  "first_frame": false,
  "last_frame": false,
  "cost_usd": 0.08,
  "refunded": false,
  "generation_time_ms": null,
  "error": null,
  "created_at": "2026-09-29T09:14:03.512Z"
}

• Videos are MP4, 24 fps, with generated sound.
• A failed job has refunded: true; start a new one if you want to retry. Don’t start duplicates while one is still processing: each start is charged.

Start and wait, in your language

// video.mjs · Node 18+ · run: node video.mjs
const API = "https://animeapi.ai/api/videos";
const headers = {
  Authorization: `Bearer ${process.env.ANIMEAPI_KEY}`,
  "Content-Type": "application/json",
};

// 1. Start the job. The price is charged now and refunded if it fails.
const res = await fetch(API, {
  method: "POST",
  headers,
  body: JSON.stringify({
    prompt: "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in",
    resolution: "480p",
    duration: 5,
    orientation: "landscape",
  }),
});
let video = await res.json();
if (!res.ok) throw new Error(`${res.status} ${video.code ?? ""}: ${video.error}`);
console.log(`started ${video.id}, charged ${video.cost_usd} USD`);

// 2. Poll every 5 seconds until it finishes.
while (video.status === "processing") {
  await new Promise((resolve) => setTimeout(resolve, 5000));
  const poll = await fetch(`${API}/${video.id}`, { headers });
  video = await poll.json();
  if (!poll.ok) throw new Error(`${poll.status} ${video.code ?? ""}: ${video.error}`);
}

if (video.status === "failed") throw new Error(`Failed and refunded: ${video.error}`);
console.log(video.video_url);

# video.py · run: python video.py [first-frame.png]
import base64
import mimetypes
import os
import sys
import time

import requests

API = "https://animeapi.ai/api/videos"
HEADERS = {"Authorization": f"Bearer {os.environ['ANIMEAPI_KEY']}"}


def data_uri(path: str) -> str:
    mime = mimetypes.guess_type(path)[0] or "image/png"
    with open(path, "rb") as f:
        return f"data:{mime};base64,{base64.b64encode(f.read()).decode()}"


body = {
    "prompt": "a girl with a red umbrella waits at a rainy bus stop, then looks up as the bus pulls in",
    "resolution": "480p",
    "duration": 5,
    "orientation": "landscape",
}
# Optional: start the clip on a local image. The image sets the video's shape.
if len(sys.argv) > 1:
    body["first_frame"] = data_uri(sys.argv[1])

# 1. Start the job. The price is charged now and refunded if it fails.
res = requests.post(API, headers=HEADERS, json=body, timeout=60)
video = res.json()
if res.status_code != 202:
    raise SystemExit(f"{res.status_code} {video.get('code', '')}: {video['error']}")
print(f"started {video['id']}, charged {video['cost_usd']} USD")

# 2. Poll every 5 seconds until it finishes.
while video["status"] == "processing":
    time.sleep(5)
    res = requests.get(f"{API}/{video['id']}", headers=HEADERS, timeout=30)
    video = res.json()
    if not res.ok:
        raise SystemExit(f"{res.status_code} {video.get('code', '')}: {video['error']}")

if video["status"] == "failed":
    raise SystemExit(f"Failed and refunded: {video['error']}")
print(video["video_url"])

08Errors

Errors are JSON with an error message and, for most, a machine-readable code. Validation errors happen before anything is charged. If generation fails after charging, the charge is refunded automatically.

{ "error": "Insufficient balance. Please add funds to your account.", "code": "INSUFFICIENT_BALANCE" }

POST /api/generate

POST /api/videos

GET /api/videos/{id}

Failed video jobs

A video that fails while rendering isn’t an HTTP error: GET /api/videos/{id} returns 200 with status: "failed", refunded: true and one of these in error. The charge is already back in your balance.

Retrying

Only a 500 (or a failed video job) is worth retrying automatically; you were refunded. 400, 401, 402 and 404 won’t change on retry.

import os
import time
import requests

def generate(prompt: str, model: str = "anime", attempts: int = 3) -> dict:
    for attempt in range(1, attempts + 1):
        res = requests.post(
            "https://animeapi.ai/api/generate",
            headers={"Authorization": f"Bearer {os.environ['ANIMEAPI_KEY']}"},
            json={"prompt": prompt, "model": model, "allowNSFW": False},
            timeout=180,
        )
        data = res.json()
        if res.ok:
            return data
        # 500 means the provider failed and you were refunded: safe to retry.
        if res.status_code == 500 and attempt < attempts:
            time.sleep(2 * attempt)
            continue
        # 400/401/402 won't fix themselves by retrying.
        raise RuntimeError(f"{res.status_code} {data.get('code', '')}: {data['error']}")
    raise RuntimeError("unreachable")

if __name__ == "__main__":
    print(generate("a girl with a red umbrella at a rainy bus stop")["image_url"])

09Limits

• No daily or per-minute cap. Generate as many images and videos as your balance covers.
• If you ever get a 429, back off and retry.
• Prompts up to 1,000 characters.
• One image per request. For batches, send requests in parallel from your server.
• One video per job, 5 to 15 seconds. Jobs run in parallel; frames up to 10 MB each.

10Image & video URLs

• Anime images are WebP files on our generation provider’s CDN. Download anything you want to keep; don’t treat the URL as permanent storage.
• Ultra and ultra-max images are PNG files in AnimeAPI’s storage.
• Videos are MP4 files in AnimeAPI’s storage.
• All are public URLs that anyone with the link can open.

11Demo endpoint

The homepage demo uses a public endpoint with no key: anime model, portrait, enhancement on, NSFW off, and 3 images per IP per day. It’s for trying things, not for production.

curl https://animeapi.ai/api/demo/generate \
  -H "Content-Type: application/json" \
  -d '{"prompt": "a knight cat drinking tea in a sunflower field"}'

• Body: prompt only, up to 500 characters.
• Response: image_url, enhanced_prompt, generation_time_ms and demo_remaining.
• Over the limit: 429 with code: "RATE_LIMITED". A failed generation still uses one of the three.

12CORS & browsers

Responses include Access-Control-Allow-Origin: *, and preflight allows Content-Type and Authorization. That makes local tools and prototypes easy, but don’t ship an API key in public browser code: call AnimeAPI from your server and pass the image or video URL to the client.