ElevenLabs Flows templates API vs a Sume Format run with a webhook

Sume Formats cover the same three steps as the new ElevenLabs Flows template endpoints: find a template, read what it takes, and start a run that reports back to a webhook. The ElevenLabs changelog entry for September 28, 2026 (read 2026-10-05) lists endpoints to list published templates, retrieve template details, and start template runs with optional webhook delivery. On Sume the same shape is GET /v1/formats, GET /v1/formats/{handle}/{slug} and POST /v1/formats/{handle}/{slug}/runs.

The products make different things. Flows is part of the ElevenLabs product; a Sume Format is a saved recipe that an agent applies to a run and that produces images, video, audio or text. This post only compares the call pattern, so a developer who already integrated one can see the other quickly.

Step by step on Sume

First, list. GET /v1/formats returns the Formats you can see. Each has an io profile, with input_kind (url, text, image or product) and output_kind (video, image or text), so you can pick one without a test call. Formats saved before registration existed return null for it, which means "not declared", not "takes no input".

Second, details. The first-party catalog answers at the reserved sume handle, for example GET /v1/formats/sume/sume-product-commercial. Read it before you call it. Any other slug at sume/ answers 404 format_not_found.

Third, run. POST /v1/formats/sume/{slug}/runs needs at least one of instruction, input, previous_run_id or attachments. An empty body is a 400. You may send communication.webhook_url, and Sume posts one signed format.run.terminal event when the run completes or fails.

A run that reports to a webhook

The request below starts a catalog Format. It sends an Idempotency-Key, which Sume expects on every create, so a retried request does not start a second run.

import os, requests

url = "https://api.sume.com/v1/formats/sume/sume-product-commercial/runs"
headers = {
    "Authorization": f"Bearer {os.environ['SUME_API_KEY']}",
    "Idempotency-Key": "product-reel-2026-10-05-001",
}
body = {
    "instruction": "A 9:16 product clip with a slow push-in.",
    "input": {"product_name": "Linen throw"},
    "communication": {"webhook_url": "https://example.com/sume-hook"},
}
r = requests.post(url, json=body, headers=headers, timeout=30)
print(r.status_code)
print(r.json())

What to do differently when you move across

Verify the signature. Each Sume delivery carries x-sume-webhook-timestamp and x-sume-webhook-signature (HMAC-SHA256 over the timestamp, a dot and the raw body), and you should reject timestamps outside five minutes. Dedupe on run_id, which stays the same across retries. Keep polling as the backup: the receipt at GET /v1/format-runs/{run_id} is byte-identical to the webhook payload, so one handler serves both.

Plan for time. A Format run takes minutes, and the receipt gives an expires_at ceiling after which Sume force-finalizes a stuck run as failed. Use it as your own timeout.

Two more differences are worth knowing before you port code. A Sume run belongs to the key that made the call: the shared catalog Format stays unowned, and the run, its media and its spend are yours. And the run is metered against a generation spend cap. A request can name its own ceiling with generation_spend_cap_usd (up to $500), and the receipt reports the actual spend as usage.billable_amount_usd_micros, so your own billing code can read the cost of each run without a separate lookup.

If you only need one of the three steps, you can skip the rest. A team that already knows the slug can call the run endpoint directly, and a team that wants to browse can stop after the list. The io profile is the only declared contract between a Format's author and its callers, because input is a free-form JSON object of at most 64 top-level keys and 2 MiB. Read the Format's description and its page for the keys that it recognizes.