Generate MiniMax H3 video through Moca Router

curl --get https://staging.mocarouter.com/api/proxy/v1/model-capabilities \
  -H "Authorization: Bearer $MOCA_ROUTER_API_KEY" \
  --data-urlencode "model=MiniMax-H3"

# Restore unfinished jobs after an app restart or page refresh.
curl --get https://staging.mocarouter.com/api/proxy/v1/videos \
  -H "Authorization: Bearer $MOCA_ROUTER_API_KEY" \
  --data-urlencode "status=active" \
  --data-urlencode "limit=20"

# Request the next page using next_cursor from the previous response.
curl --get https://staging.mocarouter.com/api/proxy/v1/videos \
  -H "Authorization: Bearer $MOCA_ROUTER_API_KEY" \
  --data-urlencode "status=active" \
  --data-urlencode "limit=20" \
  --data-urlencode "after=eyJ...opaque..."

{
  "object": "list",
  "data": [
    {
      "id": "vid_7782d2a77f2c4d3094d2a51d0daf39b7",
      "object": "video",
      "model": "MiniMax-H3",
      "status": "in_progress",
      "cancellable": false,
      "downloadable": false,
      "progress": 42,
      "duration_seconds": 6,
      "resolution": "768P",
      "aspect_ratio": "16:9",
      "created_at": 1789552800
    }
  ],
  "has_more": true,
  "next_cursor": "eyJ...opaque..."
}

const API_KEY = process.env.MOCA_ROUTER_API_KEY;
const VIDEOS_URL = "https://staging.mocarouter.com/api/proxy/v1/videos";
const headers = { Authorization: `Bearer ${API_KEY}` };

async function listVideoJobs({ status = "active", after } = {}) {
  const url = new URL(VIDEOS_URL);
  url.searchParams.set("status", status);
  url.searchParams.set("limit", "20");
  if (after) url.searchParams.set("after", after);

  const response = await fetch(url, { headers });
  const page = await response.json();
  if (!response.ok) {
    throw new Error(page.error?.message ?? `HTTP ${response.status}`);
  }
  return page;
}

// Call this when your server starts or the user refreshes the jobs screen.
const firstPage = await listVideoJobs();
for (const job of firstPage.data) {
  console.log(job.id, job.status);
}

if (firstPage.has_more) {
  const secondPage = await listVideoJobs({ after: firstPage.next_cursor });
  console.log(secondPage.data);
}

import os
import requests

videos_url = "https://staging.mocarouter.com/api/proxy/v1/videos"
auth = {"Authorization": f"Bearer {os.environ['MOCA_ROUTER_API_KEY']}"}

def list_video_jobs(status="active"):
    params = {"status": status, "limit": 20}
    while True:
        response = requests.get(videos_url, headers=auth, params=params, timeout=30)
        response.raise_for_status()
        page = response.json()
        yield from page["data"]
        if not page["has_more"]:
            break
        params["after"] = page["next_cursor"]

for job in list_video_jobs():
    print(job["id"], job["status"])

import { randomUUID } from "node:crypto";
import { createWriteStream } from "node:fs";
import { Readable } from "node:stream";
import { pipeline } from "node:stream/promises";

const API_KEY = process.env.MOCA_ROUTER_API_KEY;
const VIDEOS_URL = "https://staging.mocarouter.com/api/proxy/v1/videos";
const headers = { Authorization: `Bearer ${API_KEY}` };

const createResponse = await fetch(VIDEOS_URL, {
  method: "POST",
  headers: {
    ...headers,
    "Content-Type": "application/json",
    "Idempotency-Key": randomUUID(),
  },
  body: JSON.stringify({
    model: "MiniMax-H3",
    prompt: "A cinematic tracking shot through a quiet Tokyo alley at night",
    duration: 6,
    resolution: "768P",
    ratio: "16:9",
  }),
});

let job = await createResponse.json();
if (!createResponse.ok) {
  throw new Error(job.error?.message ?? `HTTP ${createResponse.status}`);
}

const terminal = new Set([
  "completed", "failed", "cancelled", "needs_review", "expired",
]);
while (!terminal.has(job.status)) {
  await new Promise((resolve) => setTimeout(resolve, 10_000));
  const statusResponse = await fetch(`${VIDEOS_URL}/${job.id}`, { headers });
  job = await statusResponse.json();
  if (!statusResponse.ok) {
    throw new Error(job.error?.message ?? `HTTP ${statusResponse.status}`);
  }
}

if (job.status !== "completed") {
  throw new Error(`Video job ended with status: ${job.status}`);
}

const contentUrl = new URL(job.content_url, new URL(VIDEOS_URL).origin);
const contentResponse = await fetch(contentUrl, { headers });
if (!contentResponse.ok) throw new Error(`Download failed: HTTP ${contentResponse.status}`);
if (!contentResponse.body) throw new Error("Download response has no body");
await pipeline(
  Readable.fromWeb(contentResponse.body),
  createWriteStream("result.mp4"),
);

import os
import time
import uuid
from urllib.parse import urljoin, urlparse

import requests

videos_url = "https://staging.mocarouter.com/api/proxy/v1/videos"
api_key = os.environ["MOCA_ROUTER_API_KEY"]
auth = {"Authorization": f"Bearer {api_key}"}

response = requests.post(
    videos_url,
    headers={
        **auth,
        "Content-Type": "application/json",
        "Idempotency-Key": str(uuid.uuid4()),
    },
    json={
        "model": "MiniMax-H3",
        "prompt": "A cinematic tracking shot through a quiet Tokyo alley at night",
        "duration": 6,
        "resolution": "768P",
        "ratio": "16:9",
    },
    timeout=30,
)
response.raise_for_status()
job = response.json()

terminal = {"completed", "failed", "cancelled", "needs_review", "expired"}
while job["status"] not in terminal:
    time.sleep(10)
    response = requests.get(f"{videos_url}/{job['id']}", headers=auth, timeout=30)
    response.raise_for_status()
    job = response.json()

if job["status"] != "completed":
    raise RuntimeError(f"Video job ended with status: {job['status']}")

origin = f"{urlparse(videos_url).scheme}://{urlparse(videos_url).netloc}"
content_url = urljoin(origin, job["content_url"])
with requests.get(content_url, headers=auth, stream=True, timeout=300) as content:
    content.raise_for_status()
    with open("result.mp4", "wb") as output:
        for chunk in content.iter_content(chunk_size=1024 * 1024):
            if chunk:
                output.write(chunk)

{
  "id": "vid_7782d2a77f2c4d3094d2a51d0daf39b7",
  "object": "video",
  "model": "MiniMax-H3",
  "status": "queued",
  "cancellable": true,
  "downloadable": false,
  "progress": null,
  "duration_seconds": 6,
  "resolution": "768P",
  "aspect_ratio": "16:9",
  "created_at": 1789552800
}

{
  "id": "vid_7782d2a77f2c4d3094d2a51d0daf39b7",
  "object": "video",
  "model": "MiniMax-H3",
  "status": "completed",
  "cancellable": false,
  "downloadable": true,
  "progress": 100,
  "duration_seconds": 6,
  "resolution": "768P",
  "aspect_ratio": "16:9",
  "created_at": 1789552800,
  "usage": { "output_seconds": 6 },
  "content_url": "/api/proxy/v1/videos/vid_7782d2a77f2c4d3094d2a51d0daf39b7/content"
}

{
  "error": {
    "message": "duration must be an integer between 4 and 15 seconds",
    "type": "invalid_request_error",
    "param": "duration",
    "code": "unsupported_duration"
  }
}