Authorization: Bearer ae_live_your_key_here

# Step 1 — Submit the try-on job
curl -X POST https://www.artemotion.ai/api/v1/tryon \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "person_image_url": "https://example.com/model.jpg",
    "garment_image_url": "https://example.com/tshirt.jpg",
    "garment_type": "top"
  }'

# Response:
# {
#   "job_id": "a1b2c3d4...",
#   "model_id": "image-apps-v2/virtual-try-on",
#   "status": "queued",
#   "credits_used": 15,
#   "poll_url": "https://www.artemotion.ai/api/v1/jobs/a1b2c3d4...?model_id=..."
# }

# Step 2 — Poll until completed (use the poll_url from above)
curl "$POLL_URL" \
  -H "Authorization: Bearer $AE_API_KEY"

# Response when done:
# {
#   "job_id": "a1b2c3d4...",
#   "status": "completed",
#   "images": ["https://cdn.artemotion.ai/results/..."],
#   "elapsed_ms": 18400
# }

# Text-to-image
curl -X POST https://www.artemotion.ai/api/v1/generate \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "fal-ai/flux/dev",
    "prompt": "a lighthouse at dusk, photorealistic",
    "aspect_ratio": "16:9",
    "max_credits": 50
  }'

# Image-to-video
curl -X POST https://www.artemotion.ai/api/v1/generate \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "fal-ai/kling-video/v2.5-turbo/pro/image-to-video",
    "prompt": "slow cinematic dolly forward",
    "image_url": "https://example.com/still.jpg",
    "duration": 5
  }'

const res = await fetch("https://www.artemotion.ai/api/v1/generate", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.AE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model_id: "fal-ai/flux/dev",
    prompt: "a lighthouse at dusk, photorealistic",
    aspect_ratio: "16:9",
  }),
});

const { job_id, poll_url, credits_used } = await res.json();
console.log(`Job ${job_id} queued — used ${credits_used} credits`);
// Poll poll_url (see Polling Pattern) or register a webhook_url instead.

# Full catalog
curl "https://www.artemotion.ai/api/v1/models?catalog=full" \
  -H "Authorization: Bearer $AE_API_KEY"

# Include each model's complete LLM-ready input_schema
curl "https://www.artemotion.ai/api/v1/models?catalog=full&include_schema=true" \
  -H "Authorization: Bearer $AE_API_KEY"

# One model with its parameters and complete schema
curl "https://www.artemotion.ai/api/v1/models?id=fal-ai%2Fnano-banana-pro" \
  -H "Authorization: Bearer $AE_API_KEY"

# Filter by kind and sort by price
curl "https://www.artemotion.ai/api/v1/models?catalog=full&kind=video&sort=cheapest" \
  -H "Authorization: Bearer $AE_API_KEY"

curl -X POST https://www.artemotion.ai/api/v1/estimate \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "model_id": "fal-ai/kling-video/v2.5-turbo/pro/text-to-video", "duration": 10 }'

# {
#   "model_id": "fal-ai/kling-video/v2.5-turbo/pro/text-to-video",
#   "kind": "video",
#   "estimated_credits": 70,
#   "balance": 1200,
#   "sufficient": true,
#   "deficit": 0
# }

curl https://www.artemotion.ai/api/v1/credits \
  -H "Authorization: Bearer $AE_API_KEY"

# {
#   "credits": 1200,
#   "plan": { "id": "creator", "billing": "monthly", "status": "active", "current_period_end": 1751155200000 }
# }

curl -X POST https://www.artemotion.ai/api/v1/tryon \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "person_image_url": "https://example.com/person.jpg",
    "garment_image_url": "https://example.com/glasses.jpg",
    "garment_type": "glasses"
  }'

const res = await fetch("https://www.artemotion.ai/api/v1/tryon", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.AE_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    person_image_url: "https://example.com/person.jpg",
    garment_image_url: "https://example.com/glasses.jpg",
    garment_type: "glasses",
  }),
});

const { job_id, poll_url, credits_used } = await res.json();
console.log(`Job ${job_id} queued — used ${credits_used} credits`);

import os, requests

response = requests.post(
    "https://www.artemotion.ai/api/v1/tryon",
    headers={
        "Authorization": f"Bearer {os.environ['AE_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "person_image_url": "https://example.com/person.jpg",
        "garment_image_url": "https://example.com/glasses.jpg",
        "garment_type": "glasses",
    },
)
data = response.json()
print(f"Job {data['job_id']} queued — used {data['credits_used']} credits")

async function pollJob(pollUrl, apiKey) {
  while (true) {
    const res = await fetch(pollUrl, {
      headers: { "Authorization": `Bearer ${apiKey}` },
    });
    const data = await res.json();

    if (data.status === "completed") {
      return data.images;          // string[] of image URLs
    }
    if (data.status === "failed") {
      throw new Error("Try-on failed: " + (data.logs?.[0] ?? "unknown"));
    }

    // Still queued or processing — wait and retry
    await new Promise(r => setTimeout(r, 3000));
  }
}

const images = await pollJob(poll_url, process.env.AE_API_KEY);
console.log("Result:", images[0]);

curl https://www.artemotion.ai/api/v1/models

# Captioning — no prompt needed
curl -X POST https://www.artemotion.ai/api/v1/vision \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "moondream3-preview/caption",
    "image_url": "https://example.com/photo.jpg"
  }'

# Response (202):
# {
#   "job_id": "a1b2c3d4...",
#   "status": "queued",
#   "credits_used": 2,
#   "credits_left": 48,
#   "poll_url": "https://www.artemotion.ai/api/v1/jobs/a1b2c3d4...?model_id=moondream3-preview%2Fcaption"
# }

# Visual Q&A
curl -X POST https://www.artemotion.ai/api/v1/vision \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "moondream3-preview/query",
    "image_url": "https://example.com/photo.jpg",
    "prompt": "What objects are on the table?"
  }'

# Object detection
curl -X POST https://www.artemotion.ai/api/v1/vision \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "florence-2-large/object-detection",
    "image_url": "https://example.com/street.jpg"
  }'

# NSFW moderation
curl -X POST https://www.artemotion.ai/api/v1/vision \
  -H "Authorization: Bearer $AE_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model_id": "imageutils/nsfw",
    "image_url": "https://example.com/photo.jpg"
  }'

async function submitVision({ imageUrl, modelId, prompt }) {
  const res = await fetch("https://www.artemotion.ai/api/v1/vision", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${process.env.AE_API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ model_id: modelId, image_url: imageUrl, prompt }),
  });

  if (!res.ok) {
    const err = await res.json();
    throw new Error(`[${err.code}] ${err.error}`);
  }

  return res.json(); // { job_id, poll_url, credits_used, credits_left }
}

// Caption an image
const job = await submitVision({
  modelId:  "moondream3-preview/caption",
  imageUrl: "https://example.com/photo.jpg",
});
console.log(`Queued: ${job.job_id} (${job.credits_used} credits)`);

import os, requests

def submit_vision(image_url, model_id="moondream2", prompt=None):
    payload = {"model_id": model_id, "image_url": image_url}
    if prompt:
        payload["prompt"] = prompt
    r = requests.post(
        "https://www.artemotion.ai/api/v1/vision",
        headers={"Authorization": f"Bearer {os.environ['AE_API_KEY']}"},
        json=payload,
    )
    r.raise_for_status()
    return r.json()

# VQA example
job = submit_vision(
    image_url="https://example.com/photo.jpg",
    model_id="llava-next",
    prompt="Describe this image in detail.",
)
print(f"Queued {job['job_id']} — {job['credits_used']} credits")

// Caption / VQA model (e.g. moondream2, llava-next, moondream3-preview/caption)
{
  "job_id": "abc123",
  "model_id": "moondream3-preview/caption",
  "status": "completed",
  "result": {
    "text": "A golden retriever sitting on hardwood floors, looking up at the camera.",
    "objects": null,
    "annotated_image": null,
    "is_nsfw": null,
    "nsfw_probability": null
  },
  "elapsed_ms": 1240
}

// Object detection model (e.g. moondream3-preview/detect)
{
  "job_id": "def456",
  "model_id": "moondream3-preview/detect",
  "status": "completed",
  "result": {
    "text": null,
    "objects": [
      { "label": "stop sign", "x_min": 0.42, "y_min": 0.11, "x_max": 0.58, "y_max": 0.34 }
    ],
    "annotated_image": "https://cdn.artemotion.ai/results/annotated_abc.jpg",
    "is_nsfw": null,
    "nsfw_probability": null
  },
  "elapsed_ms": 980
}

// NSFW moderation model (imageutils/nsfw)
{
  "job_id": "ghi789",
  "model_id": "imageutils/nsfw",
  "status": "completed",
  "result": {
    "text": null,
    "objects": null,
    "annotated_image": null,
    "is_nsfw": false,
    "nsfw_probability": 0.02
  },
  "elapsed_ms": 310
}

// 401 — missing or invalid API key
{ "error": "Missing Authorization header", "code": "UNAUTHORIZED" }

// 400 — unknown model
{ "error": "Unknown model_id \"bad-model\". GET /api/v1/vision for the model list.", "code": "INVALID_MODEL" }

// 400 — required field missing
{ "error": "model_id \"llava-next\" requires a \"prompt\" field (e.g. \"Describe this image in detail.\").", "code": "MISSING_FIELD" }

// 402 — not enough credits
{ "error": "Insufficient credits. Required: 4, available: 2.", "code": "INSUFFICIENT_CREDITS" }

// 429 — rate limited
{ "error": "Rate limit exceeded. Max 20 requests per minute.", "code": "RATE_LIMIT_EXCEEDED" }

// 502 — backend failure
{ "error": "Failed to submit job: upstream timeout", "code": "SUBMISSION_ERROR" }

async function pollVisionJob(pollUrl, apiKey) {
  while (true) {
    const res = await fetch(pollUrl, {
      headers: { "Authorization": `Bearer ${apiKey}` },
    });
    const data = await res.json();

    if (data.status === "completed") {
      return data.result; // { text, objects, annotated_image, is_nsfw, nsfw_probability } — all fields always present
    }
    if (data.status === "failed") {
      throw new Error("Vision job failed: " + (data.error ?? "unknown"));
    }

    // queued or processing — wait and retry
    await new Promise(r => setTimeout(r, 2000));
  }
}

// Full example
const job = await fetch("https://www.artemotion.ai/api/v1/vision", {
  method: "POST",
  headers: { "Authorization": `Bearer ${process.env.AE_API_KEY}`, "Content-Type": "application/json" },
  body: JSON.stringify({ model_id: "moondream3-preview/caption", image_url: "https://example.com/photo.jpg" }),
}).then(r => r.json());

const result = await pollVisionJob(job.poll_url, process.env.AE_API_KEY);
console.log("Caption:", result.text);

import os, time, requests

AE_API_KEY = os.environ["AE_API_KEY"]
BASE_URL   = "https://www.artemotion.ai/api/v1"

def run_vision(image_url, model_id="moondream2", **kwargs):
    # Submit
    r = requests.post(
        f"{BASE_URL}/vision",
        headers={"Authorization": f"Bearer {AE_API_KEY}"},
        json={"model_id": model_id, "image_url": image_url, **kwargs},
    )
    r.raise_for_status()
    job = r.json()

    # Poll
    while True:
        time.sleep(2)
        poll = requests.get(
            job["poll_url"],
            headers={"Authorization": f"Bearer {AE_API_KEY}"},
        )
        poll.raise_for_status()
        data = poll.json()

        if data["status"] == "completed":
            return data["result"]
        if data["status"] == "failed":
            raise RuntimeError(f"Vision job failed: {data.get('error')}")

# Caption
result = run_vision("https://example.com/photo.jpg", "moondream3-preview/caption", length="long")
print("Caption:", result["text"])

# VQA
result = run_vision("https://example.com/photo.jpg", "llava-next", prompt="What is in this image?")
print("Answer:", result["text"])

# NSFW check
result = run_vision("https://example.com/photo.jpg", "imageutils/nsfw")
print(f"NSFW: {result['is_nsfw']} (probability: {result.get('nsfw_probability', 'n/a')})")

curl https://www.artemotion.ai/api/v1/vision

// Missing required prompt for a VQA model
// POST /vision with model_id "llava-next" and no prompt field
{
  "error": "model_id \"llava-next\" requires a \"prompt\" field (e.g. \"Describe this image in detail.\").",
  "code": "MISSING_FIELD"
}

// Unknown model ID
{
  "error": "Unknown model_id \"my-custom-model\". GET /api/v1/vision for the model list.",
  "code": "INVALID_MODEL"
}

// Image URL not publicly accessible
{
  "error": "Image error: Failed to fetch image: HTTP 403",
  "code": "IMAGE_ERROR"
}

// Image larger than 10 MB
{
  "error": "Image error: Image exceeds 10 MB",
  "code": "IMAGE_ERROR"
}

// Private/internal URL blocked
{
  "error": "Image error: Private URLs not allowed",
  "code": "IMAGE_ERROR"
}

// moondream-next with task_type=query but no prompt
{
  "error": "model_id \"moondream-next\" with task_type \"query\" requires a \"prompt\" field with the question to ask.",
  "code": "MISSING_FIELD"
}

// Not enough credits
{
  "error": "Insufficient credits. Required: 4, available: 1.",
  "code": "INSUFFICIENT_CREDITS"
}

// Rate limit hit (20 req/min for vision)
{
  "error": "Rate limit exceeded. Max 20 requests per minute.",
  "code": "RATE_LIMIT_EXCEEDED"
}

{
  "error": "Insufficient credits. Required: 15, available: 3.",
  "code": "INSUFFICIENT_CREDITS"
}

{
  "model_id":       "flux-pro",
  "prompt":         "Cinematic portrait, golden hour",
  "webhook_url":    "https://your-app.com/api/webhooks/artemotion",
  "webhook_secret": "whsec_pick_any_random_string"
}

{
  "request_id": "abc123-def456",
  "model_id":   "flux-pro",
  "kind":       "image",
  "status":     "completed",
  "timestamp":  1716000000,
  "result":     { "images": ["https://cdn.artemotion.ai/...png"] }
}

import crypto from "node:crypto";

export function verifyWebhook(rawBody, headers, secret) {
  const sig = headers["x-artemotion-signature"];
  const ts  = headers["x-artemotion-timestamp"];
  if (!sig?.startsWith("v1=") || !ts) return false;

  const expected = crypto
    .createHmac("sha256", secret)
    .update(`${ts}.${rawBody}`)
    .digest("hex");
  const provided = sig.slice(3);

  if (provided.length !== expected.length) return false;
  if (!crypto.timingSafeEqual(Buffer.from(provided), Buffer.from(expected))) return false;

  // 5-minute replay window
  if (Math.abs(Date.now() / 1000 - Number(ts)) > 300) return false;
  return true;
}

async function runTryon({ personUrl, garmentUrl, garmentType, apiKey }) {
  // 1. Submit
  const submit = await fetch("https://www.artemotion.ai/api/v1/tryon", {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${apiKey}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      person_image_url: personUrl,
      garment_image_url: garmentUrl,
      garment_type: garmentType ?? "clothing",
    }),
  });

  const submitted = await submit.json().catch(() => ({}));
  if (!submit.ok) {
    throw new Error(`Submit failed [${submitted.code ?? submit.status}]: ${submitted.error ?? submit.statusText}`);
  }

  const { poll_url, credits_used } = submitted;
  console.log(`Queued — ${credits_used} credits used`);

  // 2. Poll with a 15-minute client-side deadline
  const deadline = Date.now() + 15 * 60_000;
  let delay = 3000;
  while (Date.now() < deadline) {
    await new Promise(r => setTimeout(r, delay));

    let poll;
    try {
      poll = await fetch(poll_url, {
        headers: { "Authorization": `Bearer ${apiKey}` },
      });
    } catch {
      delay = Math.min(Math.round(delay * 1.5), 10_000);
      continue; // transient network failure
    }

    if (poll.status === 429) {
      const retryAfter = Number(poll.headers.get("Retry-After"));
      delay = Number.isFinite(retryAfter) && retryAfter > 0
        ? retryAfter * 1000
        : Math.min(Math.round(delay * 1.5), 10_000);
      continue;
    }

    const data = await poll.json().catch(() => ({}));
    if (!poll.ok) {
      if (poll.status >= 500) {
        delay = Math.min(Math.round(delay * 1.5), 10_000);
        continue; // retry transient provider/status errors
      }
      throw new Error(`Poll failed [${data.code ?? poll.status}]: ${data.error ?? poll.statusText}`);
    }

    if (data.status === "completed") return data.images;
    if (data.status === "failed") {
      throw new Error("Generation failed: " + (data.error ?? "unknown provider error"));
    }

    delay = Math.min(Math.round(delay * 1.2), 10_000);
  }

  throw new Error("Polling timed out after 15 minutes");
}

// Usage
const images = await runTryon({
  personUrl:   "https://example.com/model.jpg",
  garmentUrl:  "https://example.com/tshirt.jpg",
  garmentType: "top",
  apiKey:      process.env.AE_API_KEY,
});
console.log("Result image:", images[0]);