← Back to blog

Video Model Catalog API: Price a Clip Before You Spend Credits

October 25, 2026 · Eric · 7 min read

Video generation is the one tool in an agent stack where a single bad call can burn real money. A 10-second clip on a premium model costs roughly fifteen times what the same clip costs on the budget model, and the difference has nothing to do with your prompt — it is entirely which model ID you passed.

Agent Media Tools exposes five text-to-video models behind one endpoint. The catalog that drives the UI is public, unauthenticated, and machine-readable: GET /api/video/models. This post shows how to read it, price a clip before you submit anything, then pass the model ID into POST /api/agent/generate-video and poll the job to completion.

The catalog endpoint

No API key, no auth header, no query parameters. One GET returns every model, its credit cost, and the exact limits that the generation endpoint will enforce.

curl -s https://agentmediatools.com/api/video/models | python3 -m json.tool

The response has two top-level keys: models (an object keyed by model ID) and default_model. Each model entry looks like this, trimmed to the fields that matter for cost and compatibility:

{
  "models": {
    "wan-25": {
      "name": "Wan 2.5",
      "label": "Wan 2.5 — Balanced",
      "description": "Best all-around value. Great quality for realistic scenes...",
      "tags": ["realistic", "general", "balanced", "value"],
      "creditsPerSec": 4,
      "creditsPerVideo": 0,
      "supportsDuration": [5, 10],
      "default": true
    }
  },
  "default_model": "wan-25"
}

Two fields do the heavy lifting. creditsPerSec is the per-second price. creditsPerVideo would be a flat per-clip price that overrides it, and it is absent on all five current models — so the server prices everything per second today. Check it anyway instead of hard-coding the assumption, because the pricing function on the server tests that field first.

What the five models cost

Prices below are credits, straight from the catalog at the time of writing. The dollar figures apply the same multiplier the API uses when it returns estimated_cost_usd — five cents per credit.

Model IDLabelCredits/sec5s10s
pixverse-v6Budget210 (~$0.50)20 (~$1.00)
wan-25 (default)Balanced420 (~$1.00)40 (~$2.00)
kling-turboCinematic525 (~$1.25)50 (~$2.50)
seedancePremium20100 (~$5.00)200 (~$10.00)
veoUltra Premium30150 (~$7.50)300 (~$15.00)

The practical takeaway: use the cheap model to explore a prompt, then re-run the winning prompt on the expensive model once. Iterating on veo at ten seconds a try is how prototype budgets disappear.

Price a batch in Python before you send it

The catalog is data, so an agent can plan spend the same way it would plan any other resource. This script pulls the catalog, computes the cost of a 10-second clip on every model, and sorts by price:

import requests

catalog = requests.get("https://agentmediatools.com/api/video/models", timeout=20).json()
seconds = 10

rows = []
for model_id, m in catalog["models"].items():
    flat = m.get("creditsPerVideo") or 0
    per_sec = m.get("creditsPerSec") or 0
    cost = flat if flat else seconds * per_sec
    if seconds not in (m.get("supportsDuration") or []):
        continue  # model cannot produce this length
    rows.append((cost, model_id, per_sec))

for cost, model_id, per_sec in sorted(rows):
    print(f"{model_id:14} {per_sec:>2} cr/s  {cost:>3} credits  ~${cost * 0.05:.2f}")

Run it and you get the same ordering as the table: pixverse-v6, wan-25, kling-turbo, seedance, veo. The supportsDuration filter matters. Duration is not a free-form number — the server snaps whatever you send to the nearest supported value on the default model, which currently means 5 or 10 seconds. Ask for 7 and you get a 5-second clip.

Submit the job with an explicit model

Generation needs an agent key in the Authorization header. The body accepts model alongside the prompt, duration, aspect ratio, and resolution:

curl -X POST https://agentmediatools.com/api/agent/generate-video \
  -H "Authorization: Bearer $AMT_AGENT_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kling-turbo",
    "prompt": "Slow dolly shot through a rain-soaked alley, neon signs reflecting in puddles",
    "duration_seconds": 10,
    "aspect_ratio": "9:16",
    "resolution": "1080p"
  }'

Without wait: true the call returns 202 Accepted immediately with a job ID and a cost breakdown that was already charged:

{
  "success": true,
  "job_id": "6f1c...",
  "status": "queued",
  "polling_url": "/api/agent/generate-video/6f1c...",
  "billing": {
    "model": "Kling 2.5 Turbo Pro",
    "model_id": "kling-turbo",
    "duration_seconds": 10,
    "credit_cost_per_second": 5,
    "credits_required": 50,
    "credits_charged": 50,
    "estimated_cost_usd": "~$2.50"
  },
  "credits_remaining": 150,
  "estimated_wait_seconds": 200
}

That billing block is the cheapest possible sanity check on your own code. Echo it into your logs on every call. If billing.model_id is not the model you asked for, something upstream in your pipeline rewrote it.

Poll until the file exists

Rendering takes one to three minutes. Poll the job every few seconds rather than holding a connection open:

import os, time, requests

KEY = {"Authorization": f"Bearer {os.environ['AMT_AGENT_KEY']}"}
job = requests.post(
    "https://agentmediatools.com/api/agent/generate-video",
    headers=KEY,
    json={"model": "wan-25", "prompt": "A paper boat drifting down a rainy street", "duration_seconds": 5},
    timeout=60,
).json()

url = "https://agentmediatools.com" + job["polling_url"]
for _ in range(60):
    state = requests.get(url, headers=KEY, timeout=30).json()
    if state["status"] in ("completed", "failed"):
        break
    print(state["status"], state.get("progress"), state.get("progress_label"))
    time.sleep(5)

if state["status"] == "completed":
    print(state["result"]["download_url"])

The job object carries status, progress, progress_label (useful to stream to a UI), params with the resolved settings, and result once finished. Completed videos also get a proxied download_url under /api/download/<id>, which is what you should hand to a user or copy into storage.

Generated videos are temporary, and the submit response says so in auto_delete_message: copy the file out of download_url as soon as the job completes. The message quotes one hour, but the server's temporary-storage sweeper deletes files older than twenty minutes on a five-minute cycle, so treat one hour as a ceiling rather than a promise.

Gotchas worth hard-coding around

Fallback

An unrecognized model ID does not error. It resolves to the default model, and billing still reflects the default model's price. Typos like "kling_turbo" quietly generate on wan-25. Validate IDs against the catalog before submitting.

Clamping

Resolution and aspect ratio are validated per model, but the catalog response only exposes durations — not the allowed aspect ratios or resolutions. If you send a value the chosen model does not list, the server substitutes its default (16:9, 1080p) instead of failing, which can quietly downgrade a 9:16 vertical clip to landscape. 9:16 at 720p is inside every model's supported set, so that is the safe pair when you have not checked the tool page.

Prompts

Prompts are capped at 2,000 characters and screened before any credit is deducted. A blocked prompt returns 422 with credits_charged: 0, so retries with a rewritten prompt cost nothing.

Balance

Insufficient credits returns 402 with code: "INSUFFICIENT_CREDITS" and the full pricing preview attached — enough to decide whether to downshift to a cheaper model instead of topping up.

Webhooks instead of polling

If your agent would rather be notified, register an outbound webhook and subscribe it to job.completed and job.failed. Video jobs fire those events with the job ID, status, and result payload. That turns a three-minute blocking loop into an event handler, which is usually the right shape for anything running on a queue.

What about MCP?

The generate_video MCP tool covers prompt, duration, aspect ratio, resolution, seed, and a wait flag — but it does not expose a model selector. If your agent needs a specific model, call the REST endpoint directly and keep the tool for the default-model path. That is a real boundary, not a marketing gap: the catalog exists so a client can price and choose, and the MCP surface is intentionally narrower.

A workflow that stays cheap

  1. Read /api/video/models once per session and cache it. Prices are static enough that a hourly refresh is plenty.
  2. During development, generate on pixverse-v6 at 5 seconds. Twenty attempts cost 200 credits — about one 5-second veo clip (150 credits).
  3. Store the prompt and seed that worked, then re-submit the same prompt on the premium model for the final asset.
  4. Log the billing block from every response. It is the only per-call record of what you actually paid.
  5. Copy the video out of download_url immediately — temporary media is swept on a timer, and "one hour" is the marketing number, not the guarantee.

None of this needs an SDK. The catalog is one unauthenticated GET, generation is one authenticated POST, and the cost of a mistake is a 402 or a 10-credit draft instead of a $15 surprise.

Try it in the Toolbox

Generate a clip in the browser, or read the model catalog and call the API from your agent with an agent key.

Open the video generator