Blog

Comparison

How to Choose Vidu Q3 Reference-to-Video: Capabilities, Pricing, and Cross-Model Comparison

Nov 13, 2026
On a warm sand background, wide horizontal stepped bands of ochre red and brown tan descend step by step from left to right, forming a clean blog cover image.
On this page

What Problem Does Reference-to-Video Solve

Reference-to-video is not about "generating a video from scratch"; it is about "making the generated result conform to the materials I have already provided." You usually already have a character's appearance, a product's look, a scene style, or a few keyframes, and you want the model to carry this visual information forward along the timeline instead of rolling the dice anew for every clip.

There are three typical scenarios:

  • Character continuity: the same character or mascot keeps a consistent appearance across multiple short clips, so each clip does not look like a different person.
  • Products and still life: extend product images into display clips with camera movement, with the focus on details not drifting and materials not blurring.
  • Style consistency: use reference images to lock in color tone, lighting, and compositional language, and produce style-aligned assets in batches.

To judge whether you are a target user, ask one simple question: Is your bottleneck "no material" or "inconsistency between materials"? The former is better suited to text-to-video; the latter is where reference-to-video shines.

This also determines the difference in evaluation criteria. The success of reference-to-video is not about whether a single frame is stunning enough, but about whether the constraints of the reference materials are upheld: whether the subject deforms, whether there are jumps between frames, and whether camera movement destroys the original structure. In other words, this is a consistency task, not an imagination task. If you compare it like creative dice-rolling during selection, the conclusion will inevitably be distorted.

Reference images flow through stepped bands into a generated sequence: outputs remain consistent, while the broken side branch indicates a loss of consistency.

Breaking Down the Key Facts About Vidu Q3

Separate out the verifiable information to avoid being led astray by marketing descriptions. The current facts about this model are only the following:

  • The model identifier is vidu-q3-ad/reference-to-video, and the provider is Vidu.
  • The output type is video.
  • The capability is positioned as reference-to-video, i.e., generating video conditioned on reference materials.
  • Billing is based on output seconds, with a public price of $0.18 per second.

The implications of these facts for model selection are more direct than a parameter table:

First, it is billed "per second," not "per request." This is common for video models because cost grows linearly with output duration. This means the independent variable in your budget model is seconds, not the number of calls—for the same amount of money, a 5-second clip can be run far more times than a 10-second one.

Second, the capability is reference-to-video, not an alias for image-to-video. Reference materials can be multiple images and can carry style and identity information. When evaluating, design test cases around "constraint adherence" rather than feeding only a single first-frame image.

Third, it is exposed through a unified interface. On HiAPI.ai, model names, input parameters, and billing rules all converge under the same calling pattern, which makes "switch to another model and run it again" a configuration-level action rather than a rewrite of business code. This will be expanded in the migration section later.

One reminder: this article does not make the "does it look good" judgment for you. Details such as the maximum resolution, available duration range, and concurrency limits are subject to the model's capability panel on the site; do not replace actual testing with secondhand information.

Which Dimensions to Compare Across Similar Models

Comparisons of reference-to-video easily slide into parameter stacking: who has longer duration, who has higher resolution. A more useful approach is to first fix a set of dimensions strongly relevant to the business, then score each one. It is recommended to cover at least the following:

1. Reference Consistency

The most important and hardest to quantify. Break it into three observable items: whether subject identity is stable, whether there are jumps across frames, and whether the structure still holds after camera movement. Run multiple clips with the same set of reference images and count the proportion with "no obvious deformation."

2. Duration and Segmentation Capability

The duration range available per generation determines whether you can make "one complete shot" or must stitch clips together. If the business requires long videos, you also need to check whether the transitions between segmented generations are controllable.

3. Resolution and Aspect Ratio

Whether the output resolution meets placement requirements, and whether vertical/horizontal/square formats are supported. The cost of cropping and padding when the target aspect ratio is not met must be included.

4. Latency and Time-to-Clip

The end-to-end time from submission to obtaining a usable finished clip. In batch production, this directly determines your queue design and whether asynchronous task orchestration is needed.

5. Cost per Second

Note the unified basis: when billing by output seconds, compare the "unit price per second," not the "price per call." Also include failed retries in the cost.

6. Interface Ergonomics

Whether parameters are intuitive, error messages are readable, and asynchronous callbacks and batch submission are supported. This does not show up in the visuals, but it determines integration effort.

When making comparisons, list these six items in a scoring table and assign a weight to each. Weights come from your constraints, not industry conventions: for a team making e-commerce short videos, the consistency weight should be far higher than latency; for a team building interactive products, latency may conversely outweigh visual quality.

Abstract the comparison dimensions into a set of radar axes and two capability polygons: establish the criteria first so that parameters do not degenerate into scattered stacking.

What $0.18/sec Pricing Means

The most common budgeting mistake with per-second pricing is "estimating cost by number of requests." The correct mental model is a multiplication chain:

Cost per finished clip ≈ output seconds × price per second
Actual spend ≈ cost per finished clip × number of candidates × (1 + retry rate)

Each of the three variables amplifies cost:

Output seconds. This is the most intuitive item. Making 5 seconds versus 10 seconds is not "a little more expensive"; it doubles linearly. If the business only needs short shots, do not default to longer durations just to "leave headroom."

Number of candidates. Video generation is inherently probabilistic, and running multiple candidates to get one satisfactory result is normal. Choosing 3 candidates triples the cost of a single one. This should be made explicit at the product design stage: how many results to give users is a cost decision, not just an experience decision.

Retry rate. The most overlooked but most damaging. Poor input material quality, prompts conflicting with reference images, and parameters outside the model's comfort zone can all turn a call into a dud. Duds are also billed by output seconds, so every percentage point increase in retry rate means paying for unusable results.

In practice, budget by "deliverable cost per clip" rather than "cost per call": first estimate how many calls on average it takes to produce one clip that is actually usable, then multiply by the per-second price and the number of seconds. This number is the magnitude to align with business stakeholders.

One more reminder: this article does not state specific amounts because unit prices change with models and policies. Before ordering, refer to the real-time basis on the site's pricing panel; the budget model remains unchanged.

The stepped bands illustrate how per-second pricing is amplified by the number of candidates and retry rate, converging into the cost of a single finished clip.

Validate Selection with a Small-Scale Trial Run

Neither leaderboards nor promotional videos can replace your own materials. A feasible validation method is a controlled small-scale trial run, with the principle of changing only the model, nothing else.

Fix the Input Set

Pick 5–10 sets of real materials covering your typical scenarios: single-subject, multi-subject, products with text, and complex backgrounds. Do not use carefully curated perfect images; use the images you actually encounter in production, including those that are a bit blurry or have ordinary composition.

Fix Prompts and Parameters

Feed the same batch of prompts to the candidate models, keeping duration, aspect ratio, and number of reference images consistent. If a model does not support a certain parameter, record it as a constraint difference rather than secretly changing parameters before comparing results.

Record Four Types of Metrics

  • Usability rate: out of N runs, how many can go directly into post-production. This is the core metric.
  • Consistency: whether the subject deforms and whether there are jumps across frames. Score on a 1–5 scale.
  • Time-to-clip: actual elapsed time from submission to result, including queuing.
  • Failure modes: whether failures are random noise or regularly concentrated on a certain type of material. The latter is more worth recording because it determines your material pre-check rules.

Control the Scale

The purpose of the trial run is not to produce a benchmark report but to rule out obviously unsuitable options. About 3 runs per material set per model is enough to form a preliminary judgment; save the budget for subsequent scale-up validation.

One last piece of advice: let the people who make the materials participate in scoring. Developers look at the interface, operations look at the visuals; only by combining both judgments can you approach the real usability rate.

Notes on Migration and Integration

The pace of video model iteration means the model you choose today will probably not be the one you use next year. The only reliable way to reduce the cost of switching models is to confine model differences to configuration.

Extract an Interface Abstraction Layer

Do not let business code directly assemble model names and parameters. Define a thin wrapper whose input is "reference materials + prompt + duration + aspect ratio" and whose output is "task handle + status + finished clip URL." Model names, parameter mappings, and billing rules all go into configuration, so switching means changing configuration rather than the caller.

Unify the Asynchronous Task Model

Video generation takes a long time and generally runs asynchronously. Abstract "submit—poll/callback—fetch result" into a unified workflow to avoid rewriting the state machine when switching models. Failure retries, timeouts, and rate limiting are all handled in this layer.

Write Billing Rules into Code Comments

For models billed by the second, cost changes with parameters rather than with the number of calls. Explicitly expose "expected output seconds for this call" in the wrapper layer so upper layers can enforce budget protection, e.g., requiring secondary confirmation for excessively long durations.

Keep Material Pre-Checks

Most reference-to-video failures come from the materials themselves. Doing basic validation before submission—resolution too low, subject cropped, conflicting styles among multiple reference images—can significantly reduce the retry rate and save more money than switching models.

Canary Release and Rollback

Run new models on a small traffic share first and compare them side by side with the old model. Keep a rollback switch and switch back once the usability rate falls below the threshold. Under HiAPI.ai's unified interface, this kind of switch is a matter of changing one model identifier; do not lock yourself in architecturally.

Turn the Selection Conclusion into a Decision Checklist

Compress the above into a reusable sequence of judgments to follow during internal reviews:

  1. First confirm the need belongs to reference-to-video. The bottleneck is "material inconsistency," not "no material"; otherwise, reassess the capability selection.
  2. Define constraints, then look at models. Rank the six items—reference consistency, duration range, resolution/aspect ratio, time-to-clip, cost per second, and interface ergonomics—by business weight; weights come before rankings.
  3. Verify hard facts. Model identifier, provider, output type, and billing rules are subject to the site panel; do not trust secondhand descriptions.
  4. Build the budget by the second. Estimate deliverable cost per clip using "seconds × number of candidates × retry rate," not by number of requests.
  5. Run a small-scale controlled trial. Fix materials, prompts, and parameters; record usability rate, consistency, time-to-clip, and failure modes.
  6. Write stop-loss conditions upfront. For example, if the usability rate falls below a threshold, or a core type of material consistently fails, exclude that candidate directly rather than tuning endlessly.
  7. Abstract on integration. Make model names and parameters configurable, unify asynchronous workflows, and reserve canary release and rollback switches.

If you can remember only one sentence: Selecting reference-to-video is a constraint-matching problem, not a leaderboard problem. Once constraints are clear, model comparison becomes meaningful; if constraints are unclear, any single stunning sample is noise.

To view the current capabilities and real-time billing rules of vidu-q3-ad/reference-to-video, you can check each of the above dimensions on the model page on HiAPI.ai before deciding whether to include it as a candidate.

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