A REST API for AI video. One call, one clip, no watermark.

POST a prompt, poll for the file. The same clip the page renders, on the same terms, from any HTTP client or from an agent over MCP. Agents pay per call and never open an account.

A short prompt is one 5 s clip at $1. A timeline is a story, $1 per 5 s, priced before you pay.

$1 a clipNo watermarkCredits never expireCredits returned if it fails

curl -X POST https://sisif.ai/api/videos/generate/ \
  -H "Authorization: Bearer sk_live_..." \
  -H "Content-Type: application/json" \
  -d '{"prompt": "A lighthouse at dusk, waves breaking in slow motion", "duration": 5, "resolution": "540x960"}'

# 201 {"id": 4821, "status": "PENDING", "credits_used": 12, "estimated_completion": "..."}

Four endpoints

One creates a clip, three read it back. Authenticate with Authorization: Bearer sk_live_... or X-API-Key. Rendering is asynchronous: the POST answers at once with an id, and the file URL appears on the status endpoint when the clip is READY.

POST/api/videos/generate/Start a render. Body: prompt, duration in whole seconds, resolution (540x960 or 720x1280), optional negative_prompt, seed, webhook_url.
GET/api/videos/{id}/status/PENDING, PROCESSING, READY or ERROR, with the file URL once READY.
GET/api/videos/{id}/The full record: prompt, duration, resolution, credits spent, timestamps.
GET/api/videos/Your clips, newest first. Filter with ?status=READY.

Start a render, then poll it

The same two calls in Python and JavaScript. Any language that speaks HTTP works the same way.

import requests

API_KEY = "sk_live_your_api_key_here"
BASE_URL = "https://sisif.ai"
headers = {"Authorization": f"Bearer {API_KEY}"}

started = requests.post(
    f"{BASE_URL}/api/videos/generate/",
    headers=headers,
    json={
        "prompt": "A lighthouse at dusk, waves breaking in slow motion",
        "duration": 5,
        "resolution": "540x960",
    },
).json()

status = requests.get(
    f"{BASE_URL}/api/videos/{started['id']}/status/",
    headers=headers,
).json()
print(status["status"])
const API_KEY = "sk_live_your_api_key_here";
const BASE_URL = "https://sisif.ai";
const headers = {
  Authorization: `Bearer ${API_KEY}`,
  "Content-Type": "application/json",
};

const started = await fetch(`${BASE_URL}/api/videos/generate/`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    prompt: "A lighthouse at dusk, waves breaking in slow motion",
    duration: 5,
    resolution: "540x960",
  }),
}).then((r) => r.json());

const status = await fetch(
  `${BASE_URL}/api/videos/${started.id}/status/`,
  { headers },
).then((r) => r.json());
console.log(status.status);

Agents

An agent pays for one clip, in the call that orders it, and never opens an account. The price is the same $1 a person pays on this page.

The 402 is the offer

POST to /api/videos/generate/ with no API key and the answer is 402 Payment Required. The body states the price in credits and dollars. The WWW-Authenticate: Payment header carries a Machine Payments Protocol challenge, Stripe's protocol for machine payments; the body is where an x402 offer rides when that rail is switched on.

Pay, then retry the same request

Settle the challenge by card through Stripe and send the same POST again with the credential in Payment-Authorization. The 201 carries a Payment-Receipt header with the Stripe PaymentIntent id, and, for a caller with no account, an api_key field: the account this payment created. It is shown once, and it is how the agent polls the clip and keeps the credits if the render fails.

MCP server

Add https://sisif.ai/mcp to Claude, Cursor or your own agent. Streamable HTTP, plain JSON answers, three tools: generate_video, get_video_status, list_videos. The server card is at /mcp/server-card.

The same payment, inside the tool result

MCP clients never see an HTTP 402, so generate_video returns the challenge inside its result as payment_required. The agent pays it and calls the tool again with the credential in the payment_credential argument. A paid call from a caller with no account returns the minted API key alongside the video id.

POST /api/videos/generate/
Content-Type: application/json

{"prompt": "A lighthouse at dusk, waves breaking in slow motion", "duration": 5}

HTTP/1.1 402 Payment Required
WWW-Authenticate: Payment realm="api.sisif.ai", ...
{"error": "payment_required", "details": {"required_credits": 12, "usd_amount": "1.00"}}

POST /api/videos/generate/
Payment-Authorization: Payment ...
Content-Type: application/json

{"prompt": "A lighthouse at dusk, waves breaking in slow motion", "duration": 5}

HTTP/1.1 201 Created
Payment-Receipt: Payment ...
{"id": 4821, "status": "PENDING", "credits_used": 12, "api_key": "sk_live_..."}
{
  "mcpServers": {
    "sisif": { "url": "https://sisif.ai/mcp" }
  }
}

Pricing

Credits, spent by duration and tier. Same terms as the page: no watermark, nothing expires, a failed render returns the credits. Agents pay the same $1 per call.

See plans

One clip$112 credits: 5 s at 540x960, paid once
clips a clip, credits never expire
Alpha Tester$10/month100 credits a month, same API
Starter Pack$50/month1000 credits a month, same API
Pro Creator$200/month5000 credits a month, same API
High tier2.5 credits / s540x960 portrait
Ultra tier6 credits / s720x1280 portrait
Rate limitsper key10 a minute, 100 an hour, 1,000 a day by default; ask for more
Failed rendercredits returnedCredits return to the account automatically

Questions

How do I get started with the Sisif AI Video API?

Create an account, generate an API key, and POST a prompt to /api/videos/generate/. Every clip costs $1, or buy credits as a pack or on a monthly plan. An agent can skip the account and pay per clip on the 402 challenge.

What video resolutions are supported by the API?

Two tiers, named by the resolution field values 540x960 (high) and 720x1280 (ultra). Each tier costs a different number of credits per second of video.

How long does video generation take?

Most clips are ready in 2-5 minutes. Poll the status endpoint, or set a webhook and be told when the file is ready.

Can an agent use the API without an account?

Yes. A request with no API key gets a 402 whose WWW-Authenticate header carries a Machine Payments Protocol challenge. Pay it by card through Stripe, retry with the credential in Payment-Authorization, and the response carries the clip plus the API key of the account that payment created. The same flow runs inside the MCP server at https://sisif.ai/mcp.

Are there rate limits for API usage?

Yes. Each API key defaults to 10 requests per minute, 100 per hour and 1,000 per day. Contact us if a production application needs more.

How is API usage billed?

In credits, by duration and tier. The high tier costs 2.5 credits per second and the ultra tier 6 credits per second; a 5-second 540x960 clip is 12 credits, which is what $1 buys. A failed render returns the credits automatically.

Render the first one

Type a prompt, pay $1, download a clip with no watermark. Then hand the same call to your code.