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.
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.
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 ID | Label | Credits/sec | 5s | 10s |
|---|---|---|---|---|
pixverse-v6 | Budget | 2 | 10 (~$0.50) | 20 (~$1.00) |
wan-25 (default) | Balanced | 4 | 20 (~$1.00) | 40 (~$2.00) |
kling-turbo | Cinematic | 5 | 25 (~$1.25) | 50 (~$2.50) |
seedance | Premium | 20 | 100 (~$5.00) | 200 (~$10.00) |
veo | Ultra Premium | 30 | 150 (~$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.
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.
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.
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.
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.
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 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.
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.
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.
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.
/api/video/models once per session and cache it. Prices are static enough that a hourly refresh is plenty.pixverse-v6 at 5 seconds. Twenty attempts cost 200 credits — about one 5-second veo clip (150 credits).billing block from every response. It is the only per-call record of what you actually paid.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.
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