DEV Community: Lee

MiniMax H3 VRAM requirements and real render times, consolidated from 20 threads

Lee — Tue, 25 Aug 2026 05:21:14 +0000

Every H3 thread has the same two questions in the comments: will it run on my card, and how long does it take. The answers are scattered across twenty threads and they contradict each other, so I pulled the numbers into one place.

The short version: the spread on a single card model is bigger than the spread between card models. Someone reported 22 minutes on a 5090 and got four replies saying they get the same work done in 3 to 5 minutes. Both are true. The difference is optimisation, not hardware.

Reported render times

Hardware	Reported	Settings noted
5090	~22 min, 362 frames	768×1024, 8 steps, Turbo sampler
5090	10:16	896×1120, no turbo, 20 steps
5090	"under 5 min"	not specified
5090	134 s for 15 s clip	no turbo
5090	~11 min for a 1:30 video	12GB-optimised workflow, duration 30
3090	~3 min	6-step turbo LoRA + attention optimisation
5070 Ti + 64 GB	118 s cold, 93 s warm	608×352, default workflow
5070 Ti + 64 GB	230 s	0.4 MP (480×864)
4070 + 64 GB	167 s	608×352, default workflow
3080 12 GB + 32 GB	works, Ref2VID	not timed
12 GB VRAM	~14 min for 30 s output	purpose-built low-VRAM workflow
5060 Ti 16 GB + 128 GB	OOM	default t2v template, fresh install

Sources are the comment threads on the 5090/362-frame post, the 12 GB 30-second workflow post, and the "12gb vram + 64ram" post. All within the last 30 days.

What explains a 4× spread on the same GPU

Reading through the replies, the same four things come up:

Turbo LoRA with reduced steps. Multiple people running 4 to 6 steps instead of 20. This is the single largest factor.
SageAttention / attention backend. Named repeatedly as the fix when someone reports a slow time.
SLA speedup. One reply attributes the 22-minute figure directly to not using it.
Resolution and megapixels. 608×352 versus 896×1120 is a large difference in work, and people quote times without stating either.

If you are benchmarking, state resolution, frame count, step count, and whether Turbo LoRA is on. Half the numbers floating around are unusable because they omit these.

The VRAM floor is lower than people assume, with a caveat

12 GB runs it. There are working reports on a 3080 12 GB with 32 GB system RAM, and a 12 GB-targeted workflow that produces 30-second output in about 14 minutes.

The caveat is that system RAM matters as much as VRAM here. The working 12 GB reports pair with 32 to 64 GB of system RAM. And a 5060 Ti with 16 GB VRAM and 128 GB system RAM still hit OOM on the default t2v template, which tells you the default template is not tuned for mid-range cards regardless of how much memory you have. Use a low-VRAM workflow rather than the default one and the floor drops.

"30-second generation" is stitched

Worth knowing before you plan around it: the 30-second low-VRAM workflow uses comfyui-h3-multishot, which joins three 10-second clips. It works, and the seams are handled, but it is not a native 30-second single pass. If your use case needs one continuous take with no join, test it before committing.

On the "$0 API cost" framing

The 5090 post was titled with "$0 API cost" and the top reply was:

"0$ cost" after pressing Queue button. but before that, Hardware cost quite much

That is the honest framing. Local generation is free per clip and expensive up front. Which one wins depends entirely on volume, and the break-even is easy to compute for your own situation:

clips_to_break_even = hardware_cost / (seconds_per_clip × api_rate_per_second)

I did not want to guess at anyone's GPU price or electricity rate, so plug in your own. For the API side of that equation, published per-second rates for hosted H3 are $0.074/s at 768P and $0.119/s at 2K (model page — disclosure: I work on reAPI). A 10-second 768P clip is $0.74, so at that rate a $2,000 card pays for itself somewhere around 2,700 clips, before electricity and before your own waiting time.

That number moves a lot with resolution and clip length, which is why the formula is more useful than any single figure I could quote.

Where each one actually wins

Local wins on: high volume, iteration where you are regenerating constantly, anything involving custom LoRAs, no content restrictions, and not caring about a 3-to-20-minute wait per attempt.

Hosted wins on: low or bursty volume, needing output now rather than after a tuning session, not owning a card that clears the floor, and 2K where local memory pressure gets ugly.

Most people posting here are firmly in the first group, which is why the local workflows get the upvotes. But the threads asking "can my 3060 do this" are a different group, and for them the arithmetic often does not favour buying a card.

What would help

If you have timings, post them with resolution, frames, steps, and whether Turbo LoRA and SageAttention are on. Right now the useful data is spread across comment replies in threads whose titles are about something else, and half of it is missing the settings that would make it comparable.

Seedance 2.0 Is Now Uncensored"—What Changes in Seedance 2.5?

Lee — Wed, 19 Aug 2026 00:18:53 +0000

Two Reddit titles capture the question developers are actually asking: “Seedance 2.0 is Now Uncensored” and “Will Seedance 2.5 be uncensored on Venice?”. They are useful evidence of demand. They are not product specifications.

The accurate answer is more technical. A hosted Seedance request passes through several policy and routing layers, so two services can expose the same model and reject different prompts. reAPI gives direct API callers an explicit content_filter control for supported Seedance models, but that control selects a less-filtered execution channel. It does not suspend the model's limits, the provider's checks, or reAPI's Acceptable Use Policy.

“Seedance uncensored” usually describes a route, not a model

The word uncensored collapses four different questions into one:

Layer	What can vary	What a successful request does not prove
Consumer product	Upload rules, blocked terms, account restrictions	That another product has the same rules
API gateway	Pre-checks and route selection	That upstream checks are disabled
Model provider	Input and generation policy	That every lawful prompt will succeed
Output handling	Review after rendering	That passing the prompt guarantees delivery

This explains much of the disagreement in community threads. One user may be describing a consumer app with a conservative prompt filter. Another may be using a direct API whose gateway adds less moderation before submission. Neither observation establishes that Seedance itself accepts every prompt.

For an integration, “Which exact route handled this task?” is therefore a better question than “Is Seedance censored?” It produces an answer you can log and test.

Seedance 2.0 and 2.5 expose different production envelopes

The two reAPI models share one asynchronous API pattern, but their output limits differ:

Model	reAPI model ID	Duration	Resolution
Seedance 2.0	`doubao-seedance-2.0-face`	4–15 seconds	480p, 720p, 1080p, 4K
Seedance 2.5	`doubao-seedance-2.5-face`	4–30 seconds	480p, 720p, 1080p

Seedance 2.0 is useful when 4K delivery matters. Seedance 2.5 extends a single generation to 30 seconds and supports a broader reference workflow. The full request fields and constraints are documented in the Seedance 2.0 API reference and Seedance 2.5 API reference. Live access and current pricing sit on the Seedance 2.0 model page and Seedance 2.5 model page.

These are capability differences, not evidence that one version is “more uncensored.” Content handling depends on the execution route as well as the model version.

How `content_filter` works on the reAPI Seedance API

On supported public API models, content_filter defaults to true. Direct callers can set it to false to request reAPI's Flexible, less-filtered channel. The browser playground keeps filtering enabled, so this choice belongs in an API request rather than a playground toggle.

The distinction matters: content_filter is a reAPI routing control, not a magic instruction passed inside the prompt. With Seedance 2.5, the Flexible route is a single attempt without fallback. With Seedance 2.0, reAPI uses a compatible Flexible route when available; if none is compatible, the request can use the selected Standard channel instead. A failed generation is still possible in either case.

Here is a deliberately benign request that demonstrates the wire format:

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedance-2.5-face",
    "prompt": "A contemporary dancer rehearses on an empty theater stage, wide shot, warm work lights, natural fabric movement",
    "resolution": "720p",
    "size": "16:9",
    "duration": 6,
    "content_filter": false
  }'

The POST returns a task ID. Poll GET https://reapi.ai/api/v1/tasks/{id} until the task reaches completed or failed; a successful response places the video URL under output.video_urls.

For production code, keep content_filter explicit in configuration. Do not infer it from the prompt or silently switch it after a refusal. That makes route choice reviewable and prevents a policy-sensitive behavior change from hiding inside retry logic.

A less-filtered channel is useful for false positives, not policy bypass

There are legitimate reasons to want a less-filtered route. Fashion footage, theatrical performance, sportswear, medical education, or close-cropped skin tones can trigger broad classifiers even when the intended output is lawful and non-explicit. An explicit API setting lets a team test whether an optional gateway layer caused the rejection.

The route is still governed by service and provider rules. reAPI's Acceptable Use Policy prohibits sexually explicit content, sexual content involving minors, non-consensual intimate imagery, illegal material, and attempts to circumvent safety systems. Rights and consent also remain the caller's responsibility. An API accepting an image is not proof that the caller owns it or has permission from the person depicted.

A sensible implementation records:

the user and task ID;
the selected model and content_filter value;
the input asset identifiers and proof of consent where relevant;
the terminal status and structured error;
any moderation or human-review outcome in the calling product.

That record is more valuable than repeatedly changing prompt wording. If the upstream model or output review rejects a request, treat it as a terminal policy result rather than an invitation to obfuscate the prompt.

When reAPI is the practical choice

reAPI is a useful fit when a team needs Seedance 2.0 and 2.5 behind one stable task workflow, with the filtering route selected in code. Both use POST /api/v1/videos/generations, both return an asynchronous task, and both are checked through GET /api/v1/tasks/{id}. Moving between versions is mostly a model ID and parameter decision rather than a second integration.

Choose the 2.0 route when 4K output or its 15-second production envelope matches the job. Choose 2.5 when a shot may run up to 30 seconds or needs its newer reference workflow. In both cases, use the Flexible channel only for material that remains permitted under the service policy and any upstream terms.

FAQ

Is Seedance 2.0 actually uncensored?

Not literally. reAPI can route supported API requests through a less-filtered Flexible channel, but provider, model, output, legal, and service-policy limits still apply.

Will Seedance 2.5 be uncensored through an API?

On reAPI, Seedance 2.5 already exposes content_filter: false for a Flexible execution channel. That is a routing option, not a guarantee that every request will be accepted or returned.

Does `content_filter: false` allow sexually explicit content?

No. The reAPI Acceptable Use Policy expressly prohibits sexually explicit content, as well as non-consensual, minor-related, illegal, and safety-circumvention uses. The setting does not override those rules.

Why can the same Seedance prompt work on one platform and fail on another?

Platforms can add different pre-filters and use different provider routes. The model version alone does not identify the entire moderation path.

Conclusion

The Reddit phrase “Seedance 2.0 is now uncensored” points to a real developer need, but the precise feature is route control. reAPI exposes that control through a documented content_filter field while keeping one async API across Seedance 2.0 and 2.5. For teams investigating lawful false positives, that is useful and testable; it is not a promise of unrestricted generation.

MiniMax H3 Is Shockingly Uncensored, Wow"—What That Proves

Lee — Wed, 19 Aug 2026 00:17:37 +0000

“MiniMax H3 is shockingly uncensored, wow” is an excellent Reddit headline. It is also too broad to use as an API requirement.

MiniMax H3 exists in at least three operational contexts: published model weights, MiniMax's hosted system, and third-party APIs. Each context has different infrastructure and controls. A result seen in one of them says little about the other two unless the route, checkpoint, preprocessing, and license are identified.

For developers, the useful question is not whether H3 is “uncensored.” It is whether a deployment offers explicit moderation behavior, documented limits, and a legal route for the intended workload.

A claim check for the widely discussed MiniMax H3 headline

The community discussion is real. Alongside the widely discussed Stable Diffusion post, the Hugging Face release reached r/LocalLLaMA, where local deployment naturally became part of the conversation. But “open,” “locally runnable,” and “unrestricted” are separate claims.

Claim	What the evidence supports	What it does not establish
H3 weights are available	MiniMax published H3 checkpoints under its community license	That the license permits every location or use
A local run accepted a prompt	That particular stack produced that output	That hosted APIs behave the same way
A hosted route is less filtered	One moderation layer or execution route differs	That the service has no policy or upstream checks
A text encoder is replaced	One component in the pipeline changed	That the model or its license became unrestricted

That last distinction prompted a specific technical warning. The creator of Heretic advised users not to use “Heretic” models as H3 text encoders. Whatever a component swap changes, it should not be treated as proof that the full video system has been safely or correctly “uncensored.”

MiniMax H3 is open-weight, but the license still governs deployment

MiniMax's official open-source announcement confirms the core H3 envelope: text, image, video, and audio context; 4–15 second output; up to 2K resolution; and native stereo audio. It also explains an architectural detail that matters when comparing local and hosted results: the released H3 Base is only part of the full system. Hosted context processing and the H3 Regenerate 2K stage are separate pieces, and the latter was not included in the initial weight release.

So a self-hosted checkpoint and a hosted 2K API are not automatically equivalent, even before moderation enters the picture.

The MiniMax H3 Community License adds another boundary. As published on August 2, 2026, it defines an applicable territory that excludes the EU, UK, South Korea, and United States unless separate authorization is obtained. It also incorporates use restrictions, requires safeguards for hosted services built on H3, and prohibits bypassing MiniMax safety guardrails.

This is why “open source” should not be used as shorthand for “no conditions.” If self-hosting is the plan, license review belongs before GPU planning.

Hosted MiniMax H3 APIs have their own execution contract

reAPI exposes H3 under the model ID minimax-h3. The service supports text-to-video, image-to-video, and reference-to-video through one asynchronous endpoint. Outputs run from 4 to 15 seconds at 768P or 2K, with native stereo audio.

The MiniMax H3 API documentation defines content_filter as a boolean that defaults to true. Direct API callers may set it to false, which routes the task to an unmoderated execution channel. The reAPI playground pins filtering on. Current access details and rates are on the MiniMax H3 model page.

“Unmoderated channel” is the execution label, not permission to ignore service rules. reAPI's Acceptable Use Policy remains binding and prohibits sexually explicit content, non-consensual intimate imagery, any sexual content involving minors, illegal material, and attempts to circumvent safety systems. Upstream limits and output failures can still apply as well.

Call MiniMax H3 through reAPI with an explicit route choice

The request below uses a safe product shot. Setting content_filter to false demonstrates the API contract without turning the example into a policy-evasion recipe.

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer $REAPI_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "minimax-h3",
    "prompt": "A handmade ceramic cup on a studio workbench, slow orbiting camera, soft morning window light, subtle room ambience and the quiet sound of a brush on clay",
    "aspect_ratio": "16:9",
    "duration": 6,
    "resolution": "768P",
    "content_filter": false
  }'

The POST to https://reapi.ai/api/v1/videos/generations returns a task ID rather than waiting for the render. Poll GET https://reapi.ai/api/v1/tasks/{id} until the state becomes completed or failed. On success, read the generated URL from output.video_urls.

For a moderated request, omit content_filter or set it to true. Do not write fallback code that changes the flag after a rejection without recording that decision. Route selection is part of your product's safety configuration and should be visible in logs and review tooling.

When reAPI is a better fit than self-hosting H3

Self-hosting offers infrastructure control, but H3 is not a small single-file model. Teams must account for the checkpoints, compatible inference stack, capacity planning, media storage, task orchestration, and the license obligations attached to any downstream service.

reAPI is the practical option when the goal is to ship H3 generation rather than operate the model. It provides one authenticated task flow for T2V, I2V, and R2V, including the hosted 2K route and native audio. It also makes the moderation route an explicit request field instead of leaving developers to infer behavior from a consumer interface.

That recommendation is conditional. Choose self-hosting when you have the licensing position, GPUs, and engineering staff to own the complete deployment. Choose reAPI when a documented API, predictable task lifecycle, and explicit route control are more valuable than owning the inference layer.

A safer way to evaluate “uncensored” model claims

Before choosing any H3 provider, write down five facts:

The exact model or checkpoint serving the request.
Whether context preprocessing and 2K regeneration are included.
Which moderation field or route is documented, and its default.
Which acceptable-use and model-license terms govern the workload.
How rejected tasks, logs, output retention, and user reports are handled.

This turns a community claim into an integration decision. It also prevents a local screenshot from being mistaken for a hosted-service guarantee.

FAQ

Is MiniMax H3 unrestricted?

No. Local checkpoints, MiniMax's hosted workflow, and third-party APIs have different stacks, while licenses and acceptable-use restrictions still apply.

Does reAPI support a less-filtered MiniMax H3 route?

Yes. Direct API requests can set content_filter: false to select reAPI's unmoderated execution channel. The playground keeps the filter enabled, and the Acceptable Use Policy applies to both routes.

Does open weight availability mean I can deploy H3 anywhere?

No. The current MiniMax H3 Community License contains territorial and use restrictions. Review the license and obtain appropriate advice or authorization before deploying.

What does the reAPI MiniMax H3 endpoint support?

It supports text-to-video, image-to-video, and reference-to-video under minimax-h3, with 4–15 second output, 768P or 2K resolution, and native stereo audio.

Conclusion

“MiniMax H3 is shockingly uncensored” is a strong description of one community reaction, not a complete technical finding. The model is available as published weights, the full hosted workflow contains additional services, and API providers define their own routing contract. reAPI is worth considering because that contract is explicit: one H3 endpoint, documented content_filter behavior, and a clear policy boundary around every route.

AI video generators, reviewed by what their APIs reject

Lee — Wed, 12 Aug 2026 05:35:58 +0000

Most AI video generator reviews score the output: how the faces hold up, whether the physics look right, which one nails a dolly zoom. That is useful for picking a tool to open in a browser. It is close to useless if you are going to call one from code, because output quality changes with every checkpoint, while the parameter contract is what your integration has to live with for the next year.

So here is the other review. Six video models, judged on what their APIs refuse to accept, where the refusal is silent, and how much of your client survives swapping one model for another. Everything below comes from a request surface I maintain.

One framing note. I am not affiliated with any of these labs. I reach these models through third-party channels, so channel-level caps can differ from whatever a first-party API exposes, and none of this is official documentation.

The same parameter can have three contracts inside one model

MiniMax H3 takes an aspect_ratio. What that field means depends entirely on which mode you are in.

Mode	`aspect_ratio`
Text to video	Required, and `adaptive` is rejected
Image to video	Forbidden. Orientation comes from the source image
Reference to video	Optional, defaults to `adaptive`

The middle row is the interesting one. The field is not ignored there, and it is not optional. Sending a valid enum value, one this same model accepts in another mode, fails the request. A generic client that always sets aspect_ratio from user config works in two modes out of three, and the failure surfaces as a validation error about a field the docs told you to send.

Seedance 2.5 has the same shape with different edges. It accepts seven ratios plus adaptive, but first-plus-last-frame requests have to leave the size at adaptive, because upstream rejects any other value at submit time. Same model, same field, and whether it is settable depends on which image mode you chose two fields earlier.

Mode is not a filter over one schema. It is several schemas that happen to share field names.

Documented as optional, enforced as required

Seedance 2.5 requires a prompt on every request, minimum three characters, image-to-video included. The documentation for the channel describes the prompt as optional when reference material is supplied. The endpoint disagrees and returns an error.

The version history makes this worse for anyone upgrading. The 2.0 family let you submit an image with no prompt and take whatever motion the model inferred. Point the same client at 2.5 and every bare image-to-video call starts failing. Nothing in the model name signals that the required fields changed.

"Optional" in a vendor doc is a hypothesis, not a fact. The cheap test is to fire one deliberately minimal request per mode during integration and record what comes back. It takes ten minutes, and the result is the only version of the schema you can trust.

The channel decides the parameter surface, not the model

Veo 3.1 is one model. Reached through three different resale channels, it is three different APIs.

	Channel A	Channel B	Channel C
Duration	Fixed 8s	Fixed 8s	Selectable
Resolution control	No	Yes	Yes
Negative prompt	No	No	Yes
Seed	Yes	No	Yes

Nothing here is a quality difference. It is the same weights. But an integration written against the third column, using seed for near-reproducible re-rolls and a negative prompt to suppress a recurring artifact, loses both the moment someone flips a routing env var to the second column. The requests still succeed. The outputs just stop respecting parameters you are still sending.

The adapter layer you write to paper over those differences tends to widen the silence rather than close it. Mine did. Normalizing per-channel enums looks harmless:

aspect_ratio = request.get("aspect_ratio", "16:9")
if aspect_ratio not in VALID_ASPECT_RATIOS:
    aspect_ratio = "16:9"

That clamp stops the channel erroring, and it means a user who asks for 21:9 where only two ratios exist gets a successful 16:9 render, billed normally, with nothing anywhere saying they were overruled. Parameters a channel never implemented are not read at all, so they vanish a layer earlier. Decide deliberately whether an unsupported value should clamp or fail, and tell the caller which one happened.

The same config carried a fourth channel that was mapped, wired, and non-functional: the routing layer rejects it for this model with an invalid-tier error on every call. A provider being present in your config is not evidence that it is reachable.

So model_name is not a sufficient key for capability. (model_name, channel) is.

Some models have no mode parameter at all

HappyHorse 1.0 exposes a single model id and infers the mode from which media fields you populated, in priority order: a video URL wins, then a first-frame image, then a list of reference images, then prompt-only.

This is elegant until you leave a field set. A client that keeps video_url from the previous request while the user is now trying a text-to-video generation does not get an error. It gets a video edit. The request is well formed, the mode is just not the one anyone intended, and the bill lands in the edit tier.

Anywhere the API derives intent from field presence rather than an explicit mode enum, clear your media fields on mode switch. Explicitly, not by trusting your form state.

Constraints that no schema can express

Three real ones, all of which have to live in application code because a flat parameter list cannot hold them:

MiniMax H3 accepts audio references, but not alone. At least one image or video reference has to accompany them. That is a cross-field rule, not a field rule.
The same model's wire format allows a last-frame-only image-to-video request. Expressing "either frame, at least one" in a schema of independent fields is not possible, so the form requires a first frame and quietly gives up some capability.
Grok Imagine Video 1.5 is image-to-video only, and its audio is generated in the same pass with no toggle. There is no audio parameter to expose, so "does this model support audio" and "does this model have an audio parameter" have different answers.

Each of these is a place where a schema-driven form or a generated client rejects valid requests, or accepts invalid ones.

Billing is part of the contract

No numbers here, since rates move and differ per channel. The shapes are the part a per-second price will not tell you:

Attaching a reference video can make the bill count input seconds on top of output seconds, with a floor and a ceiling. A ten-second reference clip is not free context. Trim references to the segment that demonstrates the thing you want.
Auto-duration, where the model chooses the length, reserves at the maximum and settles afterward. If your app quotes the user before generating, auto-duration and upfront quoting are in conflict, and the model tends to pick short.
Reference images past a free allowance can bill individually, so "up to 9 images" and "9 images at no extra cost" are different sentences.

What I check before integrating

The review criteria, in the order that has saved me the most time:

Fire one minimal request per mode and record what comes back. That is the real schema.
Diff the required fields across modes, not just across models.
Ask which fields are forbidden, not just which are required. Forbidden fields are the ones docs skip.
Confirm which channel you are on and pin it. Capability follows the channel.
Check whether mode is explicit or inferred from field presence.
Find the cross-field rules, since those are the errors your form will not catch.
Read the billing shape for reference media before you design an upload UI around it.

None of that tells you which model makes the prettiest video. That is deliberate. I have no benchmark worth publishing, and a quality verdict written today expires at the next checkpoint, while a contract quirk tends to outlive several.

If you want to poke at these surfaces before writing any client code, clipdance.ai puts the reference-to-video parameters of several of these models behind form controls, which surfaces the per-mode field sets and the upload ceilings faster than reading error strings does. The models belong to their respective labs; this is third-party access.

This space is still shipping capability faster than it ships stable contracts, and a review scored on output quality cannot see that at all. If you have hit a rejection I did not list, especially a silent one, I would like to read it in the comments.

Seedance 2.5 vs Wan 3.0: separating what ships from what's promised

Lee — Sat, 08 Aug 2026 05:15:50 +0000

The 30-second club just got its second member. ByteDance's Seedance 2.5 has been generating half-minute takes with synced audio for a while now. On August 6, Alibaba opened the public beta for Wan 3.0 and claimed the same headline number. Launch coverage points to a formal event on August 10 in Hangzhou, so by the time you read this there may be more official material than I had.

That timing gap shapes everything below. One of these models I can poke at through a third-party channel and describe from its actual parameter surface. The other is days old, lives behind Alibaba's own platforms, and has no public API documentation yet. I am not going to pretend those are symmetrical sources, so this comparison is explicit about where each fact comes from.

What each side can prove today

	Seedance 2.5	Wan 3.0
Length	4 to 30 s, you pick the exact second	"Native 30s Duration" with what Alibaba calls intelligent duration control
Audio	on by default, dialogue via double quotes, can be switched off	"sound design" and "immersive audiovisual" per the official site; no documented control surface yet
References	30 images + 10 videos + 10 audio files	"up to 20 reference assets, including complex document and webpage parsing"
Resolution	480p / 720p on available channels	not officially pinned; beta listings show a 480p tier and coverage reports 1080p
Editing	generation only; chaining via a returned last frame	instruction-based and reference-based editing, presented as a core feature
Access	third-party web platforms and API aggregators, now	Alibaba's own platforms, public beta; API "opening soon"
Open weights	no	no; the Wan-Video GitHub org still stops at Wan 2.2

Sources for the right column: the wan.video homepage copy, the Wan-Video GitHub organization, and the fact that Alibaba Cloud's Model Studio documentation index still tops out at Wan 2.7 API references as I write this. Everything on the left comes from using Seedance 2.5 and reading its request schema.

The reference systems solve different problems

This is the comparison that actually matters, and it is not about the numbers 50 and 20.

Seedance 2.5 references are media: you feed it images, clips, and audio tracks, and they answer the question "make it look and sound like this." A character sheet keeps a face stable across takes. An audio track sets the mood the video gets generated to fit. It is a consistency machine.

Wan 3.0's headline reference feature is document and webpage parsing. Feed it a deck, a spreadsheet, a page, and it builds a video of that content. That answers a different question entirely: "make a video about this." If the demos hold up, that is closer to an explainer-video pipeline than to a cinematic generator.

Those are both legitimate directions. They are just not the same product decision, and which one you need depends on whether your input is a mood board or a quarterly report. I have seen nothing yet on how well Wan 3.0 handles the media-consistency job, and Seedance has no answer at all to the document job.

Editing is Wan's bet

Seedance 2.5, at least through the channels I can reach, generates. If you want to change a finished clip you regenerate, or you chain a new segment off the returned last frame. There is no edit mode.

Wan 3.0 puts "Precision Video Editing" on its front page, with both instruction-driven and reference-driven variants. Editing inside the generation model, rather than in a separate tool, would collapse a real step out of the workflow. Whether it works well enough to rely on is exactly the kind of thing a homepage cannot tell you, and I flag it here as the feature I most want to test rather than one I can vouch for.

The openness twist

Wan built its reputation on open weights. Wan 2.1 and 2.2 are sitting on GitHub and a lot of self-hosted pipelines run them. So it is worth saying plainly: Wan 3.0 has no downloadable weights, no checkpoint, no repo. As of this week it is a hosted, closed model, same as Seedance 2.5. If you were waiting for 3.0 to upgrade a self-hosted stack, nothing has shipped for you yet, and nobody official has said whether it will.

What I cannot compare and will not fake

Output quality, because I have not generated with Wan 3.0 and a launch-week verdict based on cherry-picked demo reels would be worthless anyway. Pricing, because Seedance costs vary by channel and Wan's beta pricing is fragmentary. And the fine print that decides real integrations, like Wan's prompt limits, rate behavior, or how those 20 reference slots are actually typed, because the API docs that would answer this do not exist publicly yet.

That last gap cuts one way for now. If you need a 30-second audio-native model inside a pipeline this week, Seedance 2.5 is the one with a schema you can script against today; the parameter surface is all exposed in the browser at seedance 2.5 if you want to see it without writing code. Wan 3.0 deserves a real evaluation in about a month, once the documentation lands and the launch-week fog clears. I plan to write that follow-up, and I honestly do not know yet which way it will go.

Seedance 2.5 vs MiniMax H3 (Hailuo 03): a spec-level comparison for builders

Lee — Sat, 08 Aug 2026 05:06:52 +0000

Two of the most interesting audio-native video models right now sit in adjacent slots: ByteDance's Seedance 2.5 and MiniMax's H3, also known as Hailuo 03. Both generate speech, sound effects, and music in the same pass as the picture. Both take text, images, and reference media as input. The marketing copy makes them sound interchangeable. The parameter surfaces say otherwise, and the differences are the kind that decide pipelines, not preferences.

I use both through the same third-party platform, which makes the comparison unusually clean: same harness, same uploaders, same meter, two different sets of constraints. The usual caveat applies: these are the models as exposed on the channels available today, not official documentation, and channel-level caps can differ from whatever first-party APIs eventually expose.

The one-table version

	Seedance 2.5	MiniMax H3 (Hailuo 03)
Clip length	4 to 30 s (default 5)	4 to 15 s (default 6)
Output	480p / 720p, MP4 or MOV	fixed 2K
Audio	on by default, can be switched off	always on, stereo, no toggle
Prompt	required, minimum 3 characters	required, 1 to 7,000 characters
Aspect ratio	adaptive by default in every mode	must be chosen for text-to-video; derived from the image for image-to-video
Reference budget	30 images + 10 videos + 10 audio	9 images + 3 videos + 3 audio
Reference video cap	30 s combined	15 s combined
Audio-only reference	accepted	rejected, needs an image or video alongside

Every row below gets unpacked where it changes a decision.

Length and resolution pull in opposite directions

The counterintuitive part first. The newer Seedance tops out at 720p on the channels you can use today, while H3 ships fixed 2K with no resolution field at all. Meanwhile Seedance doubles the length ceiling: 30-second single takes against H3's 15.

So the first question is not "which model is better." It is "is your deliverable long or sharp." A 30-second continuous take with synced dialogue is something only one of these produces. A crisp 2K clip that goes straight into an edit without an upscale step is the other one. If you need both properties, you are choosing which post-production step you tolerate: upscaling Seedance output, or cutting and chaining H3 clips.

On chaining: Seedance 2.5 has a return_last_frame flag that hands you the closing frame as a still, which you can feed back as the first frame of the next request. H3 has no equivalent on this channel, so extending past 15 seconds means prompt continuity rather than pixel continuity.

Audio: both native, different philosophies

Seedance treats audio as a parameter. It is on by default, you can switch it off, and dialogue follows a documented convention: wrap spoken lines in double quotes and they become speech, while unquoted text stays scene direction.

H3 treats audio as part of the output. Stereo, always on, no toggle exposed. If your pipeline needs silent clips because licensed music gets added later, that difference is a checkbox on one model and a strip-the-track post step on the other.

Aspect ratio: one model trusts you, the other decides

This is my favorite structural difference because neither choice is wrong. Seedance 2.5 defaults to adaptive in every mode and lets the model pick a ratio when you do not care. H3 refuses adaptive for text-to-video, forcing an explicit choice, and forbids the field entirely for image-to-video, where orientation comes from your source image.

If your output feeds a fixed slot, a 9:16 shorts feed or a 21:9 banner loop, H3's forced choice is a feature: there is no way to forget it. If you are exploring and want the model to compose freely, Seedance's adaptive default saves a decision. Both cover the same range from 21:9 to 9:16.

Reference systems: differently sized, differently shaped

Seedance 2.5 gives you 30 images, 10 videos, and 10 audio tracks, with reference videos capped at 30 seconds combined. Audio alone is a valid input, which flips the order of operations for music-first work: finish the track, generate the video to fit it. Real-person reference images are explicitly accepted on the channel I use, with the obvious consent and disclosure obligations attached.

H3 gives you 9 images, 3 videos, and 3 audio tracks, videos capped at 15 seconds combined, and audio can never be the only reference. The budget is smaller but not small: nine images is still enough for a character sheet plus a location set.

The advice that holds for both: spend the budget on roles, not volume. One character reference, one environment, one camera-movement clip beats twenty near-duplicates on either model.

Billing shape, without the numbers

I will not quote prices since they vary by channel, but two structural things are worth knowing before you script against either model.

Both bill reference-video input seconds on top of the seconds you generate, so a long style-reference clip quietly multiplies cost on both. Trim references to the segment that matters.

The asymmetries: H3 meters reference images past the fifth, so image count is a cost dial there, while Seedance image references add nothing. Seedance applies a minimum floor to the bill when reference videos are attached. Check the pricing page of whatever channel you use and read the reference-media rows specifically; per-second rates are the least surprising part of either bill.

Which one, when

Long continuous takes, chained scenes, dialogue-led story beats: Seedance 2.5. The 30-second ceiling plus last-frame chaining is the whole game.
Sharp deliverables with no upscale step: H3. Fixed 2K out of the box.
Music-first workflows: Seedance 2.5, since a lone audio track is a legal input.
Fixed-format feeds where a forgotten ratio ruins a batch: H3's mandatory choice protects you from yourself.
Reference-heavy character consistency work: Seedance 2.5's 50-file budget.
Quick social drafts under 15 seconds: genuinely either. This is where the two overlap almost completely.

On output quality I am deliberately silent. Quality is prompt-dependent, content-dependent, and moves with every silent model update; I have no benchmark rigorous enough to publish and would not trust one that fit in a blog post. The specs above are the part you can actually plan against.

Both models run in the browser on the platform I use for all of this: the H3 side lives at minimax-h3, and Seedance 2.5 has its own page on the same site. Underneath it is ByteDance's model and MiniMax's model respectively, reached through a third-party channel. Try the same prompt on both at 15 seconds, watch where each one spends your attention in review, and the right default for your pipeline usually announces itself within an afternoon.

Seedance 2.5 field notes: 30-second takes, native audio, and the limits that will shape your build

Lee — Sat, 08 Aug 2026 04:59:45 +0000

Seedance 2.5 changes the two numbers that made AI video awkward to build around: clip length (15 seconds becomes 30) and audio (none becomes dialogue, sound effects, and music generated in the same pass). The headline features are easy to find. The constraints are not, and the constraints are what decide whether the model fits your pipeline. These notes cover the parameter surface as it exists on the channels you can actually use today, gotchas first.

One framing note before the details: Seedance is ByteDance's model family. I work with it through third-party channels, so nothing here is official documentation, and channel-level caps can differ from whatever a first-party API eventually exposes.

The numbers that changed

	Seedance 2.0 family	Seedance 2.5
Clip length	4 to 15 s	4 to 30 s
Audio	none, add it in post	generated with the video: speech, SFX, background music
Image-to-video prompt	optional	required, minimum 3 characters
Reference budget	9 images + 3 videos + 3 audio	30 images + 10 videos + 10 audio
Audio-only reference	rejected (needs an image or video)	accepted
Resolution	up to 4K on some tiers	480p / 720p

Two rows deserve a second look. The reference budget: 30 + 10 + 10 is 50, which is exactly the "50 multimodal reference files" figure from the launch messaging. That number turns out to be a real upload limit, not marketing rounding. And the resolution row goes down, not up. More on that at the end.

The prompt is required now, even for image-to-video

The 2.0 family let you submit an image with no prompt and take whatever motion the model guessed. Seedance 2.5 rejects any request without a prompt, image-to-video included, with a floor of three characters.

This reads like a regression and behaves like a feature. An image-to-video prompt should describe what changes, not what exists; the model already sees the frame. Being forced to write "she turns toward the window, curtain moves in the wind" instead of submitting a bare image is the difference between specifying motion and gambling on it. My re-roll rate dropped once the habit formed.

Dialogue goes in double quotes

Audio generation defaults to on and covers three layers at once: spoken lines, sound effects, and background music. The convention that makes it usable: wrap anything that should be spoken in double quotes. Text outside quotes is treated as scene direction.

Rainy night outside a convenience store. A woman in her twenties
closes her umbrella and pushes the door open. The bell above the
door rings. The clerk looks up and says "Late shift again?"
She smiles: "Yeah. Overtime."
Camera: slow zoom-in from outside, through the glass.
Warm fluorescent tones.

Two practical notes. Only the quoted lines are candidates for speech, so keep dialogue and direction visually separate, screenplay style. And props that make noise are doing double duty: the rain and the bell in that prompt are also sound-effect directives. A prompt made of abstract mood words gives the audio layer nothing to attach to.

The Seedance 2.5 reference budget and its fine print

Type	Count	Per file	Combined cap
Images	up to 30	JPEG / PNG / WEBP and friends	none
Videos	up to 10	2 to 30 s, up to 200 MB, MP4 / MOV	30 s total
Audio	up to 10	2 to 30 s, up to 15 MB, WAV / MP3	30 s total

The combined 30-second caps are the ones that bite. Uploading a whole take as a style reference will hit the ceiling fast; trim reference clips to the segment that actually demonstrates what you want.

Audio-only reference is new. The 2.0 channel required an image or a video somewhere in the mix; 2.5 accepts a lone audio track. If your workflow starts from a finished song, the order of operations flips: track first, video generated to fit it.

Real-person reference images are accepted on this channel. The obvious rules apply: faces you own or have permission to use, and check the synthetic-media disclosure settings on whatever platform you publish to.

The budget is also better spent on roles than on volume: a character sheet, a background set, a camera-movement clip. Thirty near-duplicate images of the same face buy you very little.

Chaining past 30 seconds

There is a return_last_frame flag. Set it and the response includes the closing frame as a still image alongside the video. Feed that still back as the first frame of the next request (first-plus-last-frame mode) and you have a manual scene-chaining loop: 30-second segments that start from pixel continuity instead of prompt continuity. Not guaranteed seamless, but a far better starting point than describing the previous shot from memory.

Cost scales the way you expect, plus one quirk

Generation cost is per second and tiered by resolution, so a 30 s / 720p take costs several multiples of a 5 s / 480p draft. The workflow that follows is obvious once stated: iterate composition at 5 s / 480p, commit to full length once the prompt is settled. Doing it in the other order is expensive.

The quirk: on the channel I use, attaching a reference video makes billing count input seconds as well as output seconds, with a minimum floor. Image and audio references add no billable time. So trimming reference clips saves money on top of staying under the combined cap. Check your channel's pricing page for the exact mechanics before you script anything against it.

The ceilings, stated plainly

480p and 720p only, on the channels available right now. If the deliverable is 4K, budget an upscale step. Whether 2.5 gets a higher ceiling later is unannounced as far as I can find.
No seed parameter, so no reproducibility. Two identical requests are two different videos.
MOV output exists for color-sensitive post work, but some players will not open it. Stay on MP4 unless you know why you need MOV.
Seven aspect ratios from 21:9 to 9:16, plus an adaptive default. First-plus-last-frame requests keep the input image's ratio regardless.

Trying it without writing code

If you want to poke at the parameter surface before committing to an integration, seedance 2.0 runs Seedance 2.5 in the browser with everything above exposed as form controls, which is how I mapped most of this. It is ByteDance's model underneath, reached through a third-party channel.

The shift since 2.0 is easy to summarize: that generation produced clips you edited into scenes; Seedance 2.5 produces scenes. Thirty seconds with synced sound covers a full beat of story, an entire product demo, most of a short. If you have built against it and hit constraints I missed, I would genuinely like to hear them in the comments.

Seedance 2.5 is priced 53% above 2.0 per token, and its 480p frame shrank

Lee — Wed, 05 Aug 2026 03:55:51 +0000

Seedance 2.5's API opens on August 7. ByteDance published the pricing ahead of it, and there is a detail in there that will quietly break your cost model if you carry it over from 2.0.

Video is quoted per second and metered per token:

tokens = (input_video_seconds + output_seconds) × width × height × fps / 1024

fps is fixed at 24. Multiply by the per-million-token rate and that is the bill.

The published rates

USD per million tokens:

Model	No video input	With video input
Seedance 2.5 (480p, 720p)	10.70	6.40
Seedance 2.0 (480p, 720p)	7.00	4.30
Seedance 2.0 (1080p)	7.70	4.70
Seedance 2.0 (4K)	4.00	2.40

2.5 costs 52.9% more per token without video input and 48.8% more with it. Only 480p and 720p are published for 2.5. No 1080p, no 4K, and offline inference reads "not supported yet".

Look at the 4K row before you move on. It is the cheapest tier per token, 43% below 480p, and it is also the most expensive output on the board, because a 3840×2160 frame carries 19.4 times the pixels of what 480p actually renders. The rate drops 43% while the token count climbs 1940%. Comparing providers by scanning the rate column gets you the wrong answer by roughly a factor of eleven.

The 480p frame changed and nobody said so

This is not in any release note. It falls out of dividing ByteDance's own worked examples by their own token rates.

Their published five-second, 16:9, no-reference examples:

Model	480p	720p
Seedance 2.5	$0.514 ($0.103/s)	$1.156 ($0.231/s)
Seedance 2.0	$0.352 ($0.070/s)	$0.756 ($0.151/s)

Divide price by token rate to recover the token count, then by 24/1024 to recover pixels:

const tokens = pricePerVideo / (ratePerMillion / 1e6);
const pixels = (tokens / outputSeconds) * (1024 / 24);

// Seedance 2.5, 480p:  0.514 / (10.70/1e6) / 5  =  9,607 tokens/sec
//                      9,607 * 1024/24          =  409,899 px  ->  ~854 x 480
// Seedance 2.0, 480p:  0.352 / (7.00/1e6)  / 5  = 10,057 tokens/sec
//                      10,057 * 1024/24         =  429,105 px  ->  ~873 x 491

720p resolves to 21,600 tokens per second on both versions, which is exactly 1280 × 720. That the same arithmetic lands on a clean, verifiable number at 720p is what makes the 480p result trustworthy instead of a rounding artifact.

So 2.5 renders 480p at a true 16:9 854 × 480 while 2.0 uses a slightly taller frame. That 4.5% pixel reduction explains a discrepancy that otherwise looks like a pricing error: 480p rises 46% per second while the token rate rises 53%. At 720p, where the frame is unchanged, the two match exactly.

If you quote customers per second, your 2.0 conversion factor is wrong on 2.5 by about five percent at 480p.

Your input clip bills like generated video

input_video_seconds sits inside the same parenthesis as the output. A reference-to-video job pays for the source clip at the same rate as the frames the model invented.

Providers surface this as a discounted per-second rate for reference mode, which reads like a deal until you total it. Seedance 2.5's published range makes the point on its own: a five-second 720p generation costs $1.244 with a short reference and $4.838 with a 30-second one. Same output, 3.9× the bill.

2.5 also doubled the input window, from 15 seconds on 2.0 to 30.

There is a floor too, and the number is unpublished. Their examples price two-second and four-second inputs identically, which implies a minimum around four seconds. The docs point at a spreadsheet calculator rather than stating it. If you resell this, customers sending two-second clips cost you more than your arithmetic predicts.

Converting any token rate to per-second

const TOKENS_PER_SEC = {
  '480p@2.5': 854 * 480 * 24 / 1024,   //   9,607
  '480p@2.0': 864 * 496 * 24 / 1024,   //  10,044
  '720p':    1280 * 720 * 24 / 1024,   //  21,600
  '1080p':  1920 * 1080 * 24 / 1024,   //  48,600
  '4k':     3840 * 2160 * 24 / 1024,   // 194,400
};

function costUsd({ tier, ratePerMillion, inputSec = 0, outputSec }) {
  const tokens = (inputSec + outputSec) * TOKENS_PER_SEC[tier];
  return (tokens * ratePerMillion) / 1e6;
}

// Sanity check against the vendor's own example:
costUsd({ tier: '720p', ratePerMillion: 7.0, outputSec: 5 }); // 0.756

That last line matches ByteDance's published figure exactly, so the formula is not an approximation.

One caveat for anyone metering downstream: token counts are estimates until the job finishes. The formula predicted 40,176 for a config where the API returned 40,594, about 1% high. Bill on the returned usage.completion_tokens, not on your estimate.

What I could not determine

Why 1080p and 4K have no published rate for 2.5. Either those tiers do not ship at launch or they arrive separately.

The exact minimum input duration. It exists and it is not a published number.

Whether the same formula holds outside the Seedance family. Pixels × duration × fps is a plausible general shape, but the constants and the input-billing rule are not something I would assume for Veo, Kling or Sora without checking. If you have run the same back-solve against those, I would genuinely like to know how it came out.

Full writeup with the Seedance 2.0 rate card in per-second and per-minute terms: reapi.ai/blog/seedance-2-5-pricing-per-token

Live parameter reference and a browser playground: reapi.ai/models/seedance-2-0

Video generation pricing, fully itemized: what a second of Seedance 2.0 actually costs

Lee — Wed, 05 Aug 2026 02:40:34 +0000

Most video-generation pricing pages give you a "from $X" and stop there. You find out what a job really costs after you have already run it.

This post is the opposite. Every rate we charge for video, itemized, plus the two billing rules that decide what lands on your invoice. We cut all of it by 15-21% this week, ahead of the Seedance 2.5 API launching on August 7.

What changed

Seedance 2.5 ships on the 7th and we will have it up the same day. Seedance 2.0 is not going anywhere and is not losing features, but with 2.5 arriving it belongs at a lower price. So we moved it now instead of waiting.

To be clear about what does not exist yet: 2.5 is unreleased. Nobody has API access to it today, us included.

The full video rate card

Priced per second of output, in USD. The second column applies when your request includes a reference video.

Model	Resolution	Text / image input	With reference video
Seedance 2.0	480p	$0.072	$0.044
	720p	$0.154	$0.094
	1080p	$0.383	$0.233
	4K	$0.780	$0.480
Seedance 2.0 Fast	480p	$0.059	$0.034
	720p	$0.124	$0.075
Seedance 2.0 Mini	480p	$0.036	$0.023
	720p	$0.077	$0.047

Mini moved the furthest. Its 480p reference tier is $0.023 per second, so a five-second clip runs about eleven cents.

The two rules that decide your bill

Billing is per second, not per clip. A four-second test costs four seconds. There is no five-second minimum quietly rounding your experiments up, which matters when you are burning through prompt variations to find one that works.

Reference mode bills your input clip plus your output. Send a ten-second reference and generate five seconds, and you are charged for fifteen. This is the same basis the model itself uses to meter the job, so the estimate you compute up front is the number you pay. It also means the cheaper per-second rate in that second column is not free money: a long reference clip can cost more in total than a short text-to-video job at the higher rate. Probe your source length before you quote a price to your own users.

Failed generations refund automatically. You do not pay for a job the model could not finish.

Calling it

Media generation is asynchronous. You POST a job, get an id back immediately, then poll.

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer rk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedance-2.0-face",
    "prompt": "A kitten yawning at the camera, cinematic warm tones",
    "resolution": "720p",
    "size": "16:9",
    "duration": 5
  }'

That returns { "id": "task_...", "status": "processing" }. Then poll until the status goes terminal:

async function waitForVideo(taskId, key) {
  while (true) {
    const res = await fetch(`https://reapi.ai/api/v1/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${key}` },
    });
    const task = await res.json();

    if (task.status === "completed") return task.output.video_urls;
    if (task.status === "failed") throw new Error(task.error.message);

    await new Promise((r) => setTimeout(r, 2000));
  }
}

Poll every one to two seconds. The account limit is five requests per second and polling counts against it, so a tight loop across many concurrent jobs will start collecting 429s.

The same shape covers images and audio: swap videos for images or audio in the path, poll the identical /tasks/{id} endpoint. One key works across all of them, LLM endpoints included.

Reference images and real faces

Seedance has a consumer build that rejects real human faces on sight. That is not the build behind this API. Reference images containing real people work, up to nine of them per request.

Safety checking is a parameter you control. nsfw_checker defaults to true, and direct API callers can send false, at any resolution up to 4K.

Relaxed is not unlimited, and it would be dishonest to imply otherwise. The model still refuses named real celebrities, third-party IP, and illegal content. That refusal lives in the model and applies to every host running it, including us. It is not a setting anyone can turn off.

Images and LLMs moved too

Per image, in USD:

Model	1K	2K	4K
Nano Banana 2 Lite	$0.015
Nano Banana 2	$0.028	$0.043	$0.064
Nano Banana Pro	$0.033	$0.033	$0.035
Seedream 5.0 Pro	$0.032	$0.063
GPT Image 2	$0.030	$0.050	$0.080

Nano Banana 2 Lite came down 25 percent, Seedream 5.0 Pro at 2K came down 30 percent.

Per million tokens, input and output:

Model	Input	Output
GPT-5.6 Luna	$0.80	$4.80
GPT-5.6 Terra	$2.00	$12.00
GPT-5.6 Sol	$4.00	$24.00
Claude Opus 5	$2.40	$12.00
Kimi K3	$2.50	$12.00
GLM-5.2	$0.90	$3.00
DeepSeek V4 Flash	$0.14	$0.28
DeepSeek V4 Pro	$1.74	$3.48

DeepSeek cache hits bill at $0.0028 for Flash and $0.0145 for Pro. Those decimal places are correct.

The GPT-5.6 tiers run 20 percent under the published rate on both input and output, so an existing cost model just multiplies by 0.8. Claude Opus 5 comes in under half.

What I would want to know before signing up

Signup credits are $0.10. That is around three 1K images and does not cover a single five-second 720p clip. It is enough to prove your integration works end to end and nowhere near enough to evaluate output quality. Evaluating quality costs money, and I would rather write that here than let you discover it after the free credits run out.

Fast and Mini cap at 720p. Only Seedance 2.0 itself reaches 4K. Individual clips run 4 to 15 seconds; chain them with return_last_frame when you need something longer.

Credits are $0.001 each, they do not expire, and there is no subscription or monthly minimum underneath any of this.

Full parameter reference:
reapi.ai/models/seedance-2-0
reapi.ai

I will post again on the 7th when 2.5 is live.

Video generation pricing, fully itemized: what a second of Seedance 2.0 actually costs

Lee — Wed, 05 Aug 2026 02:35:23 +0000

Most video-generation pricing pages give you a "from $X" and stop there. You find out what a job really costs after you have already run it.

What changed

To be clear about what does not exist yet: 2.5 is unreleased. Nobody has API access to it today, us included.

The full video rate card

Priced per second of output, in USD. The second column applies when your request includes a reference video.

Model	Resolution	Text / image input	With reference video
Seedance 2.0	480p	$0.072	$0.044
	720p	$0.154	$0.094
	1080p	$0.383	$0.233
	4K	$0.780	$0.480
Seedance 2.0 Fast	480p	$0.059	$0.034
	720p	$0.124	$0.075
Seedance 2.0 Mini	480p	$0.036	$0.023
	720p	$0.077	$0.047

Mini moved the furthest. Its 480p reference tier is $0.023 per second, so a five-second clip runs about eleven cents.

The two rules that decide your bill

Failed generations refund automatically. You do not pay for a job the model could not finish.

Calling it

Media generation is asynchronous. You POST a job, get an id back immediately, then poll.

curl https://reapi.ai/api/v1/videos/generations \
  -H "Authorization: Bearer rk_live_xxx" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "doubao-seedance-2.0-face",
    "prompt": "A kitten yawning at the camera, cinematic warm tones",
    "resolution": "720p",
    "size": "16:9",
    "duration": 5
  }'

That returns { "id": "task_...", "status": "processing" }. Then poll until the status goes terminal:

async function waitForVideo(taskId, key) {
  while (true) {
    const res = await fetch(`https://reapi.ai/api/v1/tasks/${taskId}`, {
      headers: { Authorization: `Bearer ${key}` },
    });
    const task = await res.json();

    if (task.status === "completed") return task.output.video_urls;
    if (task.status === "failed") throw new Error(task.error.message);

    await new Promise((r) => setTimeout(r, 2000));
  }
}

Poll every one to two seconds. The account limit is five requests per second and polling counts against it, so a tight loop across many concurrent jobs will start collecting 429s.

The same shape covers images and audio: swap videos for images or audio in the path, poll the identical /tasks/{id} endpoint. One key works across all of them, LLM endpoints included.

Reference images and real faces

Seedance has a consumer build that rejects real human faces on sight. That is not the build behind this API. Reference images containing real people work, up to nine of them per request.

Safety checking is a parameter you control. nsfw_checker defaults to true, and direct API callers can send false, at any resolution up to 4K.

Images and LLMs moved too

Per image, in USD:

Model	1K	2K	4K
Nano Banana 2 Lite	$0.015
Nano Banana 2	$0.028	$0.043	$0.064
Nano Banana Pro	$0.033	$0.033	$0.035
Seedream 5.0 Pro	$0.032	$0.063
GPT Image 2	$0.030	$0.050	$0.080

Nano Banana 2 Lite came down 25 percent, Seedream 5.0 Pro at 2K came down 30 percent.

Per million tokens, input and output:

Model	Input	Output
GPT-5.6 Luna	$0.80	$4.80
GPT-5.6 Terra	$2.00	$12.00
GPT-5.6 Sol	$4.00	$24.00
Claude Opus 5	$2.40	$12.00
Kimi K3	$2.50	$12.00
GLM-5.2	$0.90	$3.00
DeepSeek V4 Flash	$0.14	$0.28
DeepSeek V4 Pro	$1.74	$3.48

DeepSeek cache hits bill at $0.0028 for Flash and $0.0145 for Pro. Those decimal places are correct.

The GPT-5.6 tiers run 20 percent under the published rate on both input and output, so an existing cost model just multiplies by 0.8. Claude Opus 5 comes in under half.

What I would want to know before signing up

Fast and Mini cap at 720p. Only Seedance 2.0 itself reaches 4K. Individual clips run 4 to 15 seconds; chain them with return_last_frame when you need something longer.

Credits are $0.001 each, they do not expire, and there is no subscription or monthly minimum underneath any of this.

Full parameter reference:
reapi.ai/models/seedance-2-0
reapi.ai

I will post again on the 7th when 2.5 is live.

Building an AI Video Generator with Proper Audio Sync: What I Learned

Lee — Mon, 15 Dec 2025 05:54:08 +0000

I've been working on Wan 2.6 - an AI video generator that creates 1080p videos from text and images. The thing that kept me up at night? Making the audio actually sync properly with the visuals.
Let me share the journey, the challenges, and what I learned building this.
Why I Built This
Here's what frustrated me about existing AI video tools:
The audio sync was awful. Generate a video of someone talking, and their lips move like a badly dubbed movie. It just looked... wrong.
Quality was all over the place. Your character would morph halfway through. One frame they're a young woman, next frame they're somehow a different person.
Limited control. You'd get what you get, no way to fine-tune or adjust.
I wanted to build something that actually worked well. Something I'd want to use myself.
What Wan 2.6 Does
Let me break down the core features:
Text-to-Video
Type a description, get a video.
Example: "A chef flipping a pancake in a sunny kitchen" → You get a 15-second video of exactly that in 1080p.
Image-to-Video
Got a static image? Bring it to life.
Upload a photo and describe what should happen. "Make her wave at the camera" or "zoom into the product" - that kind of thing.
Text-to-Image
Need custom visuals? Generate images to use in your videos or standalone.
Everything outputs at 1080p resolution, 24fps, with native audio synchronization.
The Audio Sync Nightmare
This was the hardest part by far.
When you generate video with AI, you're creating each frame. But when someone speaks, their mouth needs to match the sounds they're making. Not just roughly - it needs to be precise.
The Challenge
Think about it: when you say "P" or "B", your lips close. When you say "O", your mouth forms a circle. Every sound has a specific mouth shape, and it happens at exact milliseconds in the audio.
Getting an AI to:

Understand the audio timing
Generate the right mouth shapes
Keep the face consistent
Make it look natural

...is incredibly complex.
What Didn't Work
Attempt 1: Generate video first, add audio later.
Result: Looked like a ventriloquist dummy. Terrible.
Attempt 2: Generate audio first, then create video to match.
Result: Better, but timing was always slightly off. Still weird.
Attempt 3: Generate both simultaneously with shared information.
Result: Finally! This worked.
The breakthrough was realizing audio and video can't be separate processes. They need to be generated together, each informing the other in real-time.
Took months to get right, but now the lip sync actually looks believable.
Keeping Characters Consistent
Another major challenge: making sure your subject doesn't morph into a different person.
Early versions would do this thing where the character would slowly change. Ask for "a woman reading a book" and by the end, she's somehow a completely different person.
Not ideal for any kind of storytelling.
The Solution
The system now "remembers" what your subject looks like in the first frame and maintains those features throughout. It tracks key characteristics - facial features, clothing, style - and keeps them consistent.
It's not perfect (AI never is), but it's way better than the morphing mess we started with.
The 1080p Challenge
Here's the thing: generating high-quality video is computationally expensive.
1080p at 24fps means generating tons of pixels. And each frame needs to be:

High quality
Consistent with previous frames
Generated in reasonable time

We had to get creative:
Smart upscaling: Generate at a lower resolution first, then intelligently upscale. The trick is making the upscaling look natural, not artificial.
Frame interpolation: Generate key frames, then create smooth transitions between them. Cuts computational load in half while keeping motion smooth.
Optimization everywhere: Batch processing, smart caching, and tons of other tweaks to make it actually usable.
Currently, a 5-second video takes about 45 seconds to generate. Not instant, but way better than the 10+ minutes early versions took.
Making Static Images Move
One of my favorite features is image-to-video. Upload a static image, describe what should happen, and watch it animate.
The challenge? Making the motion look natural.
You can't just randomly move pixels around. The system needs to understand:

What objects are in the image
How those objects should move realistically
What motion makes sense for the prompt

A person waving should look like a natural wave. A car driving should follow physics. A product rotating should maintain its shape.
This took a lot of iteration, but when it works well, it's pretty magical.
Real-World Use Cases
I built this thinking about content creators and marketers. But people use it for all sorts of things:
Educators creating teaching materials and explainer videos
Small businesses making product demos without expensive video production
Authors creating book trailers on limited budgets
Social media managers generating quick content for posts and stories
Marketers testing video concepts before investing in full production
Hobbyists just making cool stuff for fun
The variety of use cases has been surprising and awesome.
What Works Well
Let me be honest about what Wan 2.6 does really well:
✅ Audio sync - This is our strong point. Lip movements actually match speech naturally.
✅ Quality - 1080p output looks professional, not AI-generated garbage.
✅ Consistency - Characters stay recognizable throughout the video.
✅ Ease of use - No complex settings or technical knowledge needed.
✅ Multiple workflows - Text-to-video, image-to-video, text-to-image all in one place.
Current Limitations (Being Real)
Nothing's perfect. Here's what we're still working on:
Video length: Currently capped at 15 seconds. Longer videos while maintaining quality is technically challenging.
Processing time: 45 seconds per 5-second video isn't bad, but faster would be better.
Fine control: Users want more precise control over specific elements. Working on it.
Edge cases: Weird or complex prompts sometimes produce unexpected results.
Hardware requirements: Quality generation needs decent computing power.
I'm not hiding these - they're just the reality of current AI video technology.
Lessons Learned
Solve The Hardest Problem First
I wasted time on UI before tackling audio sync. Should've solved the toughest technical challenge first, then built around it.
Quality > Speed (Usually)
I could've launched with 720p and saved on compute. But in video, quality is immediately noticeable. People care about how it looks.
Users Surprise You
I thought this would mostly be for marketing videos. The actual use cases are way more diverse and creative than I imagined.
Iteration Is Everything
The first version was terrible. The tenth version was better. The hundredth version actually worked. Keep iterating.
Listen To Feedback
Users find problems you'd never spot. They want features you'd never think of. Pay attention.
What's Next
We're actively working on:

Longer videos (30+ seconds)
More control over specific elements and scenes
Faster generation through better optimization
Better motion in image-to-video
More customization options

The roadmap is driven by what users actually need, not just what's technically cool.
Try It Out
Wan 2.6 is live at wan26.io.
Whether you're creating content for social media, making educational materials, or just experimenting with AI video - give it a shot and see what you can create.
The interface is straightforward: enter your prompt or upload an image, hit generate, and get your video. No complex setup, no technical knowledge required.

What would you create with AI video generation? Any specific use cases you'd love to see supported? Drop your thoughts in the comments - I'm genuinely curious what the dev community thinks! 💬

Chat Photo AI: Revolutionizing Image Editing Through Conversation

Lee — Fri, 06 Jun 2025 02:00:21 +0000

Chat Photo AI: Revolutionizing Image Editing Through Conversation

In today's digital landscape, visual content reigns supreme. Whether you're a professional photographer, marketing specialist, or social media enthusiast, the quality of your images can make or break your online presence. Enter Chat Photo AI, an innovative platform that's transforming how we approach image editing through the power of conversation.

The Dawn of Conversational Image Editing

Traditional image editing requires technical knowledge, complex software, and a steep learning curve. Chat Photo AI disrupts this paradigm by introducing a natural language interface to photo editing. Rather than navigating through menus and mastering tools, users can simply describe what they want—and watch as AI brings their vision to life.

"Transform my portrait to have a cinematic look" or "Make this landscape more vibrant" are all it takes to create professional-grade edits. This conversational approach democratizes photo editing, making it accessible to everyone regardless of technical expertise.

How Chat Photo AI Works

The magic behind Chat Photo begins when you upload an image. The platform's advanced machine learning algorithms analyze your photo's composition, lighting, and style elements. Then, through natural conversation, you direct the AI to make specific enhancements or transformations.

The system processes these requests in real-time, typically delivering results within seconds. This instant feedback loop creates an intuitive editing experience that feels more like collaborating with a professional photo editor than using software.

Key Features That Set Chat Photo Apart

Intuitive Conversational Interface

Unlike traditional editing tools with complex interfaces, Chat Photo uses natural language processing to understand exactly what you want. Simply describe your desired outcome, and the AI handles the technical aspects.

Real-Time Transformations

Watch as your images transform before your eyes. The platform processes edits in seconds, allowing for quick iterations and experimentation without the usual time investment.

Diverse AI Models

Chat Photo offers specialized AI models for different types of photography. Whether you're working with portraits, landscapes, product photos, or artistic images, there's a tailored solution to optimize your results.

Batch Processing Capabilities

For professionals handling large volumes of images, Chat Photo's batch processing feature is a game-changer. Maintain consistent style and quality across hundreds of photos simultaneously, saving countless hours of manual editing.

Professional-Grade Output

Despite its user-friendly approach, Chat Photo doesn't compromise on quality. The platform produces commercial-grade images suitable for professional applications, from marketing campaigns to portfolio work.

Who Benefits from Chat Photo AI?

Professional Photographers

For photographers like James Wilson, Chat Photo streamlines post-processing workflows. "The chat photo platform has transformed my photography business! I can enhance client photos instantly and create stunning variations," he shares.

Graphic Designers

Sarah Chen, a graphic designer, relies on Chat Photo for client projects. "The AI enhancement capabilities are remarkable, and I can process hundreds of images quickly. This platform has revolutionized my creative workflow completely."

Marketing Teams

Marketing professionals like Emma Thompson leverage Chat Photo to maintain brand consistency while creating unique variations for campaigns. The result? Elevated content quality and improved engagement rates.

E-commerce Specialists

Product photographers such as David Kim appreciate the platform's ability to understand context and deliver professional results consistently. This reliability is crucial for e-commerce businesses where image quality directly impacts sales.

The Future of Image Editing

Chat Photo represents the vanguard of a significant shift in creative tools. By combining advanced AI with natural language interfaces, it removes technical barriers that have traditionally limited creative expression.

As AI technology continues to evolve, we can expect even more sophisticated capabilities from platforms like Chat Photo. The gap between imagination and execution is narrowing, enabling creators to focus more on creative vision and less on technical execution.

Getting Started with Chat Photo

Beginning your journey with Chat Photo is straightforward:

Upload your image to the platform
Describe how you'd like to transform it
Review the AI-generated result
Refine with additional instructions if needed
Download your enhanced image

With pricing plans starting at $9.99, Chat Photo offers solutions for everyone from hobbyists to enterprise users. Each plan includes a set number of generation credits and access to various AI models based on your needs.

Conclusion

Chat Photo AI represents a paradigm shift in image editing—one that prioritizes creative intent over technical knowledge. By enabling users to edit photos through natural conversation, it opens up professional-quality image enhancement to a broader audience than ever before.

As visual content continues to dominate digital communication, tools like Chat Photo that combine accessibility with professional results will become increasingly valuable. Whether you're looking to enhance a single portrait or transform thousands of product images, conversational AI editing offers a compelling alternative to traditional methods.

The future of image editing isn't about mastering more complex tools—it's about having a conversation with AI that understands your creative vision and brings it to life.

DEV Community: Lee

MiniMax H3 VRAM requirements and real render times, consolidated from 20 threads

Reported render times

What explains a 4× spread on the same GPU

The VRAM floor is lower than people assume, with a caveat

"30-second generation" is stitched

On the "$0 API cost" framing

Where each one actually wins

What would help

Seedance 2.0 Is Now Uncensored"—What Changes in Seedance 2.5?

“Seedance uncensored” usually describes a route, not a model

Seedance 2.0 and 2.5 expose different production envelopes

How content_filter works on the reAPI Seedance API

A less-filtered channel is useful for false positives, not policy bypass

When reAPI is the practical choice

FAQ

Is Seedance 2.0 actually uncensored?

Will Seedance 2.5 be uncensored through an API?

Does content_filter: false allow sexually explicit content?

Why can the same Seedance prompt work on one platform and fail on another?

Conclusion

MiniMax H3 Is Shockingly Uncensored, Wow"—What That Proves

A claim check for the widely discussed MiniMax H3 headline

MiniMax H3 is open-weight, but the license still governs deployment

Hosted MiniMax H3 APIs have their own execution contract

Call MiniMax H3 through reAPI with an explicit route choice

When reAPI is a better fit than self-hosting H3

A safer way to evaluate “uncensored” model claims

FAQ

Is MiniMax H3 unrestricted?

Does reAPI support a less-filtered MiniMax H3 route?

Does open weight availability mean I can deploy H3 anywhere?

What does the reAPI MiniMax H3 endpoint support?

Conclusion

AI video generators, reviewed by what their APIs reject

The same parameter can have three contracts inside one model

Documented as optional, enforced as required

The channel decides the parameter surface, not the model

Some models have no mode parameter at all

Constraints that no schema can express

Billing is part of the contract

What I check before integrating

Seedance 2.5 vs Wan 3.0: separating what ships from what's promised

What each side can prove today

The reference systems solve different problems

Editing is Wan's bet

The openness twist

What I cannot compare and will not fake

Seedance 2.5 vs MiniMax H3 (Hailuo 03): a spec-level comparison for builders

The one-table version

Length and resolution pull in opposite directions

Audio: both native, different philosophies

Aspect ratio: one model trusts you, the other decides

Reference systems: differently sized, differently shaped

Billing shape, without the numbers

Which one, when

Seedance 2.5 field notes: 30-second takes, native audio, and the limits that will shape your build

The numbers that changed

The prompt is required now, even for image-to-video

Dialogue goes in double quotes

The Seedance 2.5 reference budget and its fine print

Chaining past 30 seconds

Cost scales the way you expect, plus one quirk

The ceilings, stated plainly

Trying it without writing code

Seedance 2.5 is priced 53% above 2.0 per token, and its 480p frame shrank

The published rates

The 480p frame changed and nobody said so

Your input clip bills like generated video

Converting any token rate to per-second

What I could not determine

Video generation pricing, fully itemized: what a second of Seedance 2.0 actually costs

What changed

The full video rate card

The two rules that decide your bill

Calling it

Reference images and real faces

Images and LLMs moved too

What I would want to know before signing up

Video generation pricing, fully itemized: what a second of Seedance 2.0 actually costs

How `content_filter` works on the reAPI Seedance API

Does `content_filter: false` allow sexually explicit content?