Cost per Reel from Format run receipts: sum billable_amount_usd_micros

To price a batch of Reels made by Sume Format runs, read usage.billable_amount_usd_micros from each finished receipt and divide by 1,000,000. A micro is one millionth of a dollar, so the documented example receipt value of 14,959,638 is $14.959638, about $14.96. Ten runs at that spend would be $149.59638, which is $149.60 when you round to the cent.

This matters when a team posts Reels every week. Instagram's Reels guide (read 2026-10-05) gives the creative range, 3 seconds to 3 minutes, but a Format run's cost depends on what the Format generates, not on the length bucket. The receipt is the only place that tells you the real number for each run.

Where the number lives

A finished Format run has a receipt at GET /v1/format-runs/{run_id}. The same receipt is the payload of the signed format.run.terminal webhook, byte for byte, so a webhook handler and a poller can share one function. The receipt's usage object carries currency, billable_amount_usd_micros and generation_spend_cap_usd_micros.

The docs example shows billable_amount_usd_micros: 14959638 against a cap of generation_spend_cap_usd_micros: 120000000, which is $120. So that run spent about 12.5 percent of its cap (14.959638 divided by 120 is 0.1247). The cap is a ceiling for one run, not a price, so never read it as the cost.

A loop that totals a batch

Keep the run ids that the create call returned. After the runs finish, read each receipt and add up the micros. The code treats a missing usage as zero, which is what you want for a run that was skipped or still in progress, but check status first if you need only finished runs.

import os, requests

H = {"Authorization": f"Bearer {os.environ['SUME_API_KEY']}"}
run_ids = ["arun_example_1", "arun_example_2"]  # from your create calls

total = 0
for rid in run_ids:
    r = requests.get(f"https://api.sume.com/v1/format-runs/{rid}",
                     headers=H, timeout=30)
    r.raise_for_status()
    data = r.json()["data"]
    micros = (data.get("usage") or {}).get("billable_amount_usd_micros", 0)
    print(rid, data["status"], micros / 1_000_000)
    total += micros
print("total USD", total / 1_000_000)

Using it for a weekly calendar

Divide the total by the number of Reels that the runs delivered, not by the number of runs, because a run can fail and still bill for media that it made. A failed run keeps its artifacts[] and its spend. Compare the result with the Format's own generation_spend_cap_usd_micros on GET /v1/formats/... to see whether your cap is too loose or too tight.

Round only at the end. Summing already-rounded dollar amounts adds rounding error, which is why the loop adds micros and divides once.

Two practical notes. First, a receipt for a run that is still queued or processing has no final spend yet, so poll until the status is terminal before you add it to a total. The status_url payload carries usage only when the run is terminal, which makes it a cheap way to check a large batch. Second, keep the totals per Format. A team that runs a product Format and a slideshow Format will see very different averages, and one blended number hides which Format is the expensive one.

If you use bulk runs, read the receipts of the child runs in the same way. The cost of a Reel is then the sum for its run divided by one, and the cost of a campaign is the sum of the batch, with no separate bookkeeping needed.