Twelve sequential images then animate: Wan 3.0 storyboard cost

Wan 3.0's sequential-image feature, up to 12 images with cohesive styling, is a vendor capability; Sume documents wan-3.0 only for video. To get a twelve-panel storyboard and then animate it on Sume, make the stills with an Image Router model and send each as the first frame of a 2 second wan-3.0 clip, which costs $0.125 per clip at 480p.

The vendor feature and the Sume row

The Wan 3.0 repository says the model "generates up to 12 sequential images with cohesive styling" (read 2026-10-05). It frames this as one of five pipelines, alongside text-to-video, image-to-video, reference-to-video and video editing. The Sume catalog lists wan-3.0 as a video row: t2v, i2v with an optional end image, and r2v, 480p to 1080p, 2 to 30 seconds.

Make the stills on Sume

Sume's image models are documented on the Images page. One example there is Ideogram 4.5 as ideogram/ideogram-v4.5, with fal list prices of $0.03, $0.06 or $0.22 per image by quality. Twelve stills at medium quality are 12 x $0.06 = $0.72 at that list price; check the live catalog for the billed price, since the docs give list figures.

Keep the twelve consistent

Keep a style sentence the same in all twelve prompts, name the character the same way, and vary only the scene. That is the manual version of what the vendor means by cohesive styling. If a frame drifts, regenerate that frame only.

Animate each panel

Each still goes in as image_url on a Wan request. Add end_image_url if you have the next panel and want the clip to land on it. A clip per panel makes twelve clips; the 480p price is $0.0625 per second.

import asyncio, json, os, urllib.request

PANELS = ["https://example.com/p1.png", "https://example.com/p2.png"]

def submit(i, first, last):
    body = {"model": "wan-3.0", "resolution": "480p", "duration": 4,
            "prompt": "Slow push-in, same style",
            "frame_images": [
              {"type": "image_url", "image_url": {"url": first}, "frame_type": "first_frame"},
              {"type": "image_url", "image_url": {"url": last}, "frame_type": "last_frame"}]}
    req = urllib.request.Request("https://api.sume.com/v1/videos",
        data=json.dumps(body).encode(), method="POST",
        headers={"Authorization": "Bearer " + os.environ["SUME_API_KEY"],
                 "Content-Type": "application/json",
                 "Idempotency-Key": f"board-{i}-001"})
    return json.load(urllib.request.urlopen(req))["id"]

async def main():
    pairs = list(zip(PANELS, PANELS[1:]))
    print(await asyncio.gather(*(asyncio.to_thread(submit, i, a, b) for i, (a, b) in enumerate(pairs))))

asyncio.run(main())

What the whole board costs

Twelve panels make eleven transitions when each clip runs from one panel to the next, or twelve clips if each starts from its own panel. The table counts twelve clips.

Board versus one long clip

Add the stills ($0.72 at fal list, medium quality) to any row. A 4 second, 480p version of the whole board is then about $3.72 at list prices for the stills. Compare that with one 30 second 480p Wan clip at $1.875: the board costs more, but you can swap one panel without redoing the rest.

Spend where the risk is

Order your work by risk. Stills are the cheap step, so lock the look there. A panel that fails at the still stage costs cents; the same failure discovered after a 30 second clip costs dollars. Approve all twelve stills before you submit any video.

Resolution is the second lever. Run the first pass of every clip at 480p ($0.0625 a second) and re-render only the panels you plan to keep at 720p ($0.125) or 1080p ($0.25). A mixed plan of twelve 4 second clips at 480p is 48 s x $0.0625 = $3.00; re-rendering four of them at 1080p adds 16 s x $0.25 = $4.00, so $7.00 in total.

Submit one first

A final check before you submit twelve jobs: submit one, wait for it, download it and look at it. A first clip that is wrong in the same way as the other eleven would waste the batch. Use a different idempotency key per panel, and keep a ledger mapping panel number to job id so a crashed script can resume without paying twice.

Joining the clips

Join the clips in a timeline or editor. Sume documents timeline tools elsewhere in its docs, but this post does not depend on them; any editor that takes MP4 files works. Match frame rate and aspect ratio across clips so joins do not stutter. All twelve requests should use the same aspect_ratio.

Which to choose

Use the board when a client has to approve each scene. Use one 30 second clip when a single continuous take is the goal and the approval step is the whole video.