Build with the mazi API

Authorization: Bearer mz_live_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

curl https://api.joinmazi.ai/v1/models \
  -H "Authorization: Bearer $MAZI_API_KEY"

const res = await fetch("https://api.joinmazi.ai/v1/models", {
  headers: { Authorization: `Bearer ${process.env.MAZI_API_KEY}` },
});
const { data: models } = await res.json();
console.log(models.map((m) => m.id));

import os, requests

res = requests.get(
    "https://api.joinmazi.ai/v1/models",
    headers={"Authorization": f"Bearer {os.environ['MAZI_API_KEY']}"},
)
print([m["id"] for m in res.json()["data"]])

curl https://api.joinmazi.ai/v1/jobs \
  -H "Authorization: Bearer $MAZI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "gpt-image-2.5-flare",
    "input": {
      "mode": "text",
      "prompt": "Product photo of a ceramic coffee cup on a sunlit kitchen counter, soft shadows",
      "aspectRatio": "2:3",
      "resolution": "1K"
    },
    "wait_seconds": 60
  }'

import { randomUUID } from "node:crypto";

const res = await fetch("https://api.joinmazi.ai/v1/jobs", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.MAZI_API_KEY}`,
    "Content-Type": "application/json",
    "Idempotency-Key": randomUUID(),
  },
  body: JSON.stringify({
    model: "gpt-image-2.5-flare",
    input: {
      mode: "text",
      prompt: "Product photo of a ceramic coffee cup on a sunlit kitchen counter, soft shadows",
      aspectRatio: "2:3",
      resolution: "1K",
    },
    wait_seconds: 60,
  }),
});
const job = await res.json();
if (!res.ok) throw new Error(`${job.error.code}: ${job.error.message}`);
console.log(job.status, job.credits, job.outputs[0]?.url);

import os, uuid, requests

res = requests.post(
    "https://api.joinmazi.ai/v1/jobs",
    headers={
        "Authorization": f"Bearer {os.environ['MAZI_API_KEY']}",
        "Idempotency-Key": str(uuid.uuid4()),
    },
    json={
        "model": "gpt-image-2.5-flare",
        "input": {
            "mode": "text",
            "prompt": "Product photo of a ceramic coffee cup on a sunlit kitchen counter, soft shadows",
            "aspectRatio": "2:3",
            "resolution": "1K",
        },
        "wait_seconds": 60,
    },
    timeout=90,
)
job = res.json()
res.raise_for_status()
print(job["status"], job["credits"], job["outputs"][0]["url"])

{
  "id": "7d0c6f0e-3b0a-4f53-9a43-1f6a2c3b4d5e",
  "object": "job",
  "model": "gpt-image-2.5-flare",
  "status": "succeeded",
  "progress": 100,
  "credits": 10,
  "input": { "mode": "text", "prompt": "Product photo of …", "aspectRatio": "2:3", "resolution": "1K" },
  "error": null,
  "outputs": [{
    "id": "b2a7c1d0-1e2f-4a3b-8c4d-5e6f7a8b9c0d",
    "type": "image",
    "mime": "image/png",
    "url": "https://…",
    "download_url": "https://…",
    "width": 1024,
    "height": 1536,
    "preview_url": "https://…"
  }],
  "urls_expire_at": "2026-11-01T10:00:12.000Z",
  "outputs_expire_at": "2027-01-29T10:00:00.000Z",
  "created_at": "2026-10-31T10:00:00.000Z",
  "finished_at": "2026-10-31T10:00:12.000Z"
}

curl -L -o result.png "$DOWNLOAD_URL"

import { writeFile } from "node:fs/promises";

const file = await fetch(job.outputs[0].download_url);
await writeFile("result.png", Buffer.from(await file.arrayBuffer()));

file = requests.get(job["outputs"][0]["download_url"], timeout=60)
with open("result.png", "wb") as f:
    f.write(file.content)

# 1) Upload the image for the firstFrame field
curl https://api.joinmazi.ai/v1/media \
  -H "Authorization: Bearer $MAZI_API_KEY" \
  -F model=seedance-2.5 \
  -F field=firstFrame \
  -F file=@frame.png
# → { "id": "5b8e…", "object": "media", "mime": "image/png", … }

# 2) Start the video and get a webhook when it finishes
curl https://api.joinmazi.ai/v1/jobs \
  -H "Authorization: Bearer $MAZI_API_KEY" \
  -H "Content-Type: application/json" \
  -H "Idempotency-Key: $(uuidgen)" \
  -d '{
    "model": "seedance-2.5",
    "input": {
      "mode": "first-frame",
      "firstFrame": "MEDIA_ID",
      "prompt": "The camera slowly pushes in while steam rises from the cup",
      "resolution": "720p",
      "duration": 5
    },
    "webhook_url": "https://example.com/webhooks/mazi"
  }'

import { readFile } from "node:fs/promises";
import { randomUUID } from "node:crypto";

const auth = { Authorization: `Bearer ${process.env.MAZI_API_KEY}` };

// 1) Upload the image for the firstFrame field
const form = new FormData();
form.set("model", "seedance-2.5");
form.set("field", "firstFrame");
form.set("file", new Blob([await readFile("frame.png")], { type: "image/png" }), "frame.png");
const media = await (await fetch("https://api.joinmazi.ai/v1/media", { method: "POST", headers: auth, body: form })).json();

// 2) Start the video and get a webhook when it finishes
const res = await fetch("https://api.joinmazi.ai/v1/jobs", {
  method: "POST",
  headers: { ...auth, "Content-Type": "application/json", "Idempotency-Key": randomUUID() },
  body: JSON.stringify({
    model: "seedance-2.5",
    input: {
      mode: "first-frame",
      firstFrame: media.id,
      prompt: "The camera slowly pushes in while steam rises from the cup",
      resolution: "720p",
      duration: 5,
    },
    webhook_url: "https://example.com/webhooks/mazi",
  }),
});
const job = await res.json(); // status: "queued"

import os, uuid, requests

auth = {"Authorization": f"Bearer {os.environ['MAZI_API_KEY']}"}

# 1) Upload the image for the firstFrame field
with open("frame.png", "rb") as f:
    media = requests.post(
        "https://api.joinmazi.ai/v1/media",
        headers=auth,
        data={"model": "seedance-2.5", "field": "firstFrame"},
        files={"file": ("frame.png", f, "image/png")},
    ).json()

# 2) Start the video and get a webhook when it finishes
job = requests.post(
    "https://api.joinmazi.ai/v1/jobs",
    headers={**auth, "Idempotency-Key": str(uuid.uuid4())},
    json={
        "model": "seedance-2.5",
        "input": {
            "mode": "first-frame",
            "firstFrame": media["id"],
            "prompt": "The camera slowly pushes in while steam rises from the cup",
            "resolution": "720p",
            "duration": 5,
        },
        "webhook_url": "https://example.com/webhooks/mazi",
    },
).json()  # status: "queued"

{
  "id": "0f3a7c2e-6d1b-4b8e-9a51-2c7d4e9f1a3b",
  "object": "event",
  "type": "job.succeeded",
  "created_at": "2026-10-31T10:02:41.000Z",
  "api_version": "v1",
  "data": {
    "job": { "id": "7d0c6f0e-…", "object": "job", "status": "succeeded", "outputs": [ … ], … }
  }
}

import crypto from "node:crypto";
import express from "express";

function verifyMaziSignature(rawBody, header, secret, toleranceSeconds = 300) {
  const parts = Object.fromEntries((header ?? "").split(",").map((p) => p.split("=")));
  const t = Number(parts.t);
  if (!t || Math.abs(Date.now() / 1000 - t) > toleranceSeconds) return false;
  const expected = crypto.createHmac("sha256", secret).update(`${t}.${rawBody}`).digest("hex");
  const a = Buffer.from(expected);
  const b = Buffer.from(parts.v1 ?? "");
  return a.length === b.length && crypto.timingSafeEqual(a, b);
}

const app = express();
app.post("/webhooks/mazi", express.raw({ type: "application/json" }), (req, res) => {
  const raw = req.body.toString("utf8");
  if (!verifyMaziSignature(raw, req.get("Mazi-Signature"), process.env.MAZI_WEBHOOK_SECRET)) {
    return res.sendStatus(400);
  }
  const event = JSON.parse(raw);
  // Store event.id and skip events you've already handled; then queue the work.
  res.sendStatus(200);
});

import hashlib, hmac, json, os, time
from flask import Flask, request

def verify_mazi_signature(raw_body: bytes, header: str, secret: str, tolerance: int = 300) -> bool:
    parts = dict(p.split("=", 1) for p in (header or "").split(",") if "=" in p)
    t = int(parts.get("t", "0"))
    if not t or abs(time.time() - t) > tolerance:
        return False
    expected = hmac.new(secret.encode(), f"{t}.".encode() + raw_body, hashlib.sha256).hexdigest()
    return hmac.compare_digest(expected, parts.get("v1", ""))

app = Flask(__name__)

@app.post("/webhooks/mazi")
def mazi_webhook():
    raw = request.get_data()
    if not verify_mazi_signature(raw, request.headers.get("Mazi-Signature"), os.environ["MAZI_WEBHOOK_SECRET"]):
        return "", 400
    event = json.loads(raw)
    # Store event["id"] and skip events you've already handled; then queue the work.
    return "", 200

{
  "error": {
    "code": "invalid_input",
    "message": "The input does not match the model. See details and GET /v1/models/{model_id}.",
    "details": [{ "field": "prompt", "problem": "required" }]
  }
}