Blog

Comparison

Muse Video 1.0 Compared: How to Choose a Video Model and Migrate

A developer-focused decision and migration guide for Muse Video 1.0 text-to-video and image-to-video routes

Nov 16, 2026 13 min read
Engraved hatching fields in midnight blue and copper forming two converging abstract masses — cover art for a video model comparison guide.
On this page
Hero still: a Muse Video 1.0 comparison walkthrough, generated with muse-video-1.0.

What Muse Video 1.0 actually offers

Muse Video 1.0 is a video generation model family exposed through two distinct routes on HiAPI.ai. Before you compare it against anything else, it helps to understand that these are not two different models — they are two entry points into the same generation capability, differentiated entirely by input modality.

The text-to-video route takes a single required prompt and produces a video from scratch. The image-to-video route additionally requires image_urls, an array of reference images that guide the output. Both routes converge on exactly the same output shape: every generation is a 10-second clip at 720p with built-in sound.

That fixed output shape is the single most important thing to internalize. There is no duration parameter to tune, no resolution tier to select, no audio toggle to flip. The model gives you a ten-second, 720p, sound-included video every time. Your creative control lives in the prompt, the aspect ratio, and (on the image route) the reference images.

The family slug is muse-video-1.0, and the two route entity slugs are muse-video-1.0-text-to-video and muse-video-1.0-image-to-video. If you are sketching an architecture diagram, picture one model box splitting into two input paths — text, and text-plus-images — then merging back into a single identical output node.

Because both routes share the same output contract, a lot of your downstream code can be written once: the response handling, the storage layer, the playback sizing for a 720p ten-second asset. Only the request construction differs.

Text-to-video vs image-to-video: which route fits your use case

The decision rule is short, and you can apply it before you write a single line of integration code.

Start with one question: do you have reference images?

If your pipeline already produces or stores images that should anchor the video — a product photo, a storyboard frame, a user-uploaded picture, a character reference — use image-to-video. If the video must be generated purely from a written description, use text-to-video. That is the primary fork.

There is a second, subtler fork: aspect ratio behavior. The image route defaults aspect_ratio to auto, which follows the reference images. The text route defaults to 16:9 and has no images to follow. So if your product needs the output frame to match an input image's proportions without you computing them yourself, image-to-video with auto saves you the math. If you need a hard guarantee — always square for a feed, always vertical for a story — either route accepts an explicit fixed ratio from the shared enum.

Where text-to-video wins

  • Fully synthetic concepts with no existing visual asset.
  • High-volume generation where sourcing reference images would add latency or cost to your pipeline.
  • Simple, deterministic framing: set aspect_ratio once and move on.

Where image-to-video wins

  • Brand or product consistency: the same reference images keep the subject recognizable across generations.
  • Image-first workflows, where the still already exists and the video is an extension of it.
  • Variable-format outputs, where auto lets the reference images dictate framing.

One caveat worth designing around: reference images are not guaranteed to become a pixel-exact first frame. They guide the result. If your use case demands frame-zero fidelity — say, a seamless continuation of a specific image — validate this behavior with a test call before committing to the route, and set expectations with stakeholders accordingly.

A practical default: build both routes behind one internal function that takes an optional image list, and select the route at call time. The shared output contract makes this cheap to maintain.

Reading the parameter surface: prompt, aspect ratio, and image URLs

The parameter surface is small, which is good news for validation code — but each field has constraints that will shape your request layer.

prompt (both routes, required)

A string with minLength=1 and maxLength=5000. On the text route, describe the subject, the action, camera movement, and the sound you want. On the image route, describe how the subject in the reference images moves, how the camera moves, and the sound you want.

Two things follow from this. First, 5,000 characters is your hard ceiling — if users author prompts in your UI, enforce the limit client-side and reject or truncate server-side rather than letting the API call fail. Second, the prompt is where audio is specified, because sound is built into every output and has no separate parameter. Treat sound description as part of prompt engineering, not as a knob.

aspect_ratio (both routes, optional)

Shared enum values: 16:9, 9:16, 1:1, 4:3, 3:4, 3:2, 2:3. The defaults differ, and the image route adds one extra value:

  • Text-to-video: default 16:9.
  • Image-to-video: default auto, plus the full enum above. auto follows the reference images.

Your enum validator must therefore differ per route. A shared validator that accepts auto everywhere will produce confusing failures on the text route; one that rejects auto everywhere will break the image route's default behavior.

image_urls (image route only, required)

An array with minItems=1 and maxItems=9. Each entry must be an http or https URL. Validate three things before calling: the array is non-empty, it has no more than nine entries, and every string parses as an HTTP(S) URL. Also decide what your system does with unreachable URLs — the schema constrains shape, not reachability, so a pre-flight fetch or a signed-URL generation step in your own pipeline is your responsibility.

What is deliberately absent

No duration, resolution, or audio toggle exists, because every output is 10 seconds at 720p with sound. Resist the urge to add these as pass-through parameters; they will be silently ignored or rejected. If a reviewer asks for a fifteen-second video, the honest answer is that this model produces ten-second clips and longer pieces require composition on your side.

Per-video pricing and what it means for your budget model

Billing on Muse Video 1.0 is per video, at the same rate on both routes, in a single tier. The official rate is $0.0336 per clip on both routes, for a fixed 10-second 720p video with built-in sound. Confirm the live price panel if you need to re-check; the unit and this official figure are what you should integrate against.

Per-video billing is a different mental model from per-second or per-resolution billing, and it changes how you estimate and control spend.

Cost is flat per request, so duration assumptions stop mattering

Under duration-based billing, a longer clip costs more, and you optimize by trimming seconds. Here, a generation costs the same whether you use one second of the ten available or all of them. That means:

  • Plan in requests, not seconds. Your budget forecast is simply the number of generations you expect. If you need 600 seconds of finished video, that is sixty generations, not a duration line item.
  • Retries are real money. Every failed or rejected generation you re-issue is another billed request. Invest in pre-call validation (prompt length, enum conformance, URL shape) because it directly reduces spend.
  • Sampling costs are predictable. Letting a user generate three variants to pick one triples the cost of that interaction; this is easy to reason about and easy to gate with a per-user quota expressed in generations.

Resolution and audio are not cost levers

Because 720p and built-in sound are fixed and included, you cannot trade quality for price. Any quality-cost tradeoff has to happen at the prompt level or by choosing a different model entirely, not by toggling parameters.

Track the unit, not just the total

Instrument your application to log one billing event per successful generation, tagged with the route slug. Because both routes share the same per-video unit, a single cost-attribution table works for both — but tagging the route still tells you which input modality is driving spend, which is exactly what you need when deciding whether a future feature should ship as text-to-video or image-to-video.

How to compare Muse Video 1.0 with other video models

Model comparisons go wrong when they collapse into a single quality score. For video, the decision is usually driven by hard constraints, so compare on dimensions that are actually specified. Six dimensions cover most of it.

1. Output length

Muse Video 1.0 produces fixed 10-second clips. Many competing video models offer variable durations or shorter defaults. If your product needs sub-second loops or minute-long scenes, that is a structural mismatch — not something prompt tuning fixes. Long-form work becomes a composition problem (stitch multiple generations) rather than a parameter change.

2. Resolution

Muse Video 1.0 delivers 720p. Compare against whatever tiers the alternative actually documents — and avoid assuming a higher tier exists on a model unless its parameter schema lists it.

3. Audio

Sound is built in on every Muse Video 1.0 generation, described through the prompt. Some video models produce silent output and require a separate audio pipeline. If your workflow already has a voiceover or music stage, built-in sound is either a convenience or a complication — decide which before you migrate.

4. Input modality

Muse Video 1.0 covers both text-to-video and image-to-video, with up to nine reference images on the image route. When comparing, check whether the alternative supports image conditioning at all, and if so, how many references it accepts and whether it guarantees first-frame fidelity. Many models offer only one modality.

5. Aspect-ratio control

Muse Video 1.0 offers a seven-value fixed enum on both routes plus auto on the image route. Weaker aspect-ratio control shows up as a single output ratio or no enum documentation at all. If your product renders into multiple surfaces (feed, story, square tile), this dimension alone can disqualify a model.

6. Billing unit

This is the dimension teams under-weight. Per-video, per-second, per-resolution, and per-credit billing produce very different cost curves as volume scales and as clip length varies. Normalize every candidate to a common denominator — cost per finished ten-second 720p clip, for instance — before comparing, and remember that a model billed per second can be cheap for short clips and expensive for long ones.

Applying the framework

Score candidates on these six axes against your actual requirements, not against a general notion of quality. In practice, two or three axes will be hard constraints and the rest will be preferences. Muse Video 1.0 is a strong fit when you need both input modalities, tight aspect-ratio control, sound-included fixed-length output, and predictable per-request budgeting.

Migrating an existing video integration to Muse Video 1.0

Migration risk here is concentrated rather than diffuse. The output contract is simple; the friction lives in request construction. Four areas deserve a deliberate pass.

1. Prompt mapping and length limits

If your existing provider allowed longer prompts, or split creative direction across multiple fields, you now have one prompt string capped at 5,000 characters on both routes. Concatenate your old fields in a defined order, then measure. When content overflows, truncate at a sentence boundary rather than mid-clause, and log the truncation so quality regressions are traceable to the migration rather than to the model.

Also fold any separate audio or music description into the prompt, since there is no dedicated audio field — sound is part of the prompt by design.

2. aspect_ratio enum handling, including auto

This is the most common source of breakage. The two routes share seven fixed values but differ on defaults and on auto:

  • Text-to-video: default 16:9; auto is not a valid value.
  • Image-to-video: default auto; auto is valid and follows the reference images.

Action items: replace any free-form ratio string in your code with a validated enum; map legacy values (for example a provider that used landscape/portrait labels) onto the seven canonical values explicitly; and make your validator route-aware so auto is accepted only on the image route. If your old code passed a ratio through untouched, add validation now.

3. image_urls array validation

The image route requires one to nine http/https URLs. Old integrations often passed a single image string, or an array of arbitrary length. Normalize to an array, enforce the 1–9 bounds, reject non-HTTP schemes, and decide how to handle inaccessible URLs before the call rather than debugging empty results after. Remember the semantic shift too: reference images guide the video but are not guaranteed to become a pixel-exact first frame, so remove any code or UI copy that promises frame-zero fidelity.

4. Route selection and response handling

Collapse duplicated call sites into one function that chooses text-to-video or image-to-video based on whether images are present, then handles the shared 10-second 720p output. Add a regression test per route that asserts request validation and response parsing independently — this catches enum and array mistakes before they reach production. The route pages for text-to-video and image-to-video document the exact schemas to test against.

A pre-launch checklist for your first Muse Video 1.0 call

Run this list against a staging environment before you ship. Each item maps to a constraint covered above.

Request shape

  • prompt is present, non-empty, and at most 5,000 characters on both routes.
  • On the image route, image_urls is an array of 1 to 9 http/https URLs, each reachable by your pipeline.
  • aspect_ratio, if sent, is one of 16:9, 9:16, 1:1, 4:3, 3:4, 3:2, 2:3 — plus auto on the image route only.
  • No duration, resolution, or audio parameters are being passed through from legacy code.

Behavior

  • A text-to-video call with only prompt succeeds and returns a ten-second, 720p video with sound.
  • An image-to-video call with aspect_ratio omitted follows the reference images.
  • Sound is described inside the prompt and is audible in the output.
  • A reference-image call produces a result that guides, but does not necessarily replicate, the first frame — and your UI copy says so.

Operations

  • Prompt-length validation runs client-side before submission to avoid billed retries.
  • A per-user quota is expressed in generations, since billing is per video.
  • One billing event is logged per successful generation, tagged with the route slug.
  • Both routes are covered by regression tests for enum handling and array bounds.

With that list green, the integration is ready. Start with the text-to-video route for pure-prompt work, and add image-to-video when your pipeline has reference images to anchor the result.

Related articles

View all articles →

Start building with persistent AI artifacts

Get your API key and call image, video and audio models through one task-based API.

Read the API docs