Is Seedance 2.5 Out Yet? Release Date and What We Actually Know (2026)

Quick answer: is Seedance 2.5 out yet?

No. As of late June 2026, ByteDance has not released Seedance 2.5 and has not published an official release date. The fact you can verify yourself: the Seed model page lists Seedance 2.0, Seedream, and the rest of the lineup, with no 2.5 entry.

What's circulating is leak-grade, not official. Industry watchers reposting from ByteDance-adjacent channels point to an early-July 2026 launch; some broader coverage frames it as a "mid-2026" window. I'd treat the early-July date as plausible but unconfirmed, and any specific day you see quoted as a rumor until ByteDance posts it.

If you came here to start generating video, you don't have to wait for 2.5. Seedance 2.0 is shipping now, and you can call it through an API today. More on that below.

Confirmed vs. rumored: a clean split

Here's the honest state of things. I've sorted every claim I could find into what's actually confirmed and what's still speculation. The speculation column is where most of the hype lives, so each prediction is anchored to the real 2.0 baseline it's extrapolating from.

My read: the predicted features are reasonable, because each one is a logical next step from something 2.0 already does. A jump from 15-second clips to roughly 30 seconds, a bigger reference budget, finer editing control. None of that would surprise me. But "reasonable" is not "announced," and I'm not going to write a spec table for a model nobody outside ByteDance has run yet.

Seedance 2.5 vs. Seedance 2.0

To make the gap concrete, here's the predicted 2.5 lined up against the 2.0 you can run today. The left column is sourced and shipping; every cell on the right is a forecast, marked so nothing reads as official.

The takeaway is the column split itself: only the left side is something you can build on today. Every 2.5 cell is a forecast, and if ByteDance ships different numbers, the right column is exactly what moves. Read it as a roadmap sketch, not a datasheet.

How 2.5 fits the Seedance lineage

To understand why those predictions point where they do, it helps to see the trajectory. Each Seedance version added one capability the previous one lacked, and that pattern is the best predictor we have.

Seedance 1.0 arrived in mid-2025 as a straight text-to-video model. Seedance 1.5 Pro was the one that mattered for audio: it became the first in the family to generate synchronized sound and video natively, in a single pass, instead of bolting audio on afterward. The 1.5 Pro technical report frames it as a native audio-visual joint generation model, which is the foundation everything after it builds on.

Seedance 2.0, released February 12, 2026, rebuilt the thing around multimodal input. It takes text, images, video, and audio together, and its @-reference system accepts up to twelve reference files in a single generation. That's the architecture a 2.5 release would extend, not replace. So when people predict "more references" and "more control," they're really predicting more of the 2.0 direction. That's a safe bet on direction, a shaky bet on numbers.

One word of caution on the lineage, because it gets blurred constantly: Seedance is the video line, Seedream is the image line. They're cousins, not the same model. If a "2.5 leak" mixes up resolution figures from an image model, that's a tell it isn't well-sourced.

What Seedance 2.0 already does today

Since 2.0 is the model you can actually use, here's the part that's grounded in shipping specs rather than forecasts. The numbers below come from ByteDance's own material and launch reporting.

A couple of honest caveats, because the model isn't magic. It runs strict face-detection filters and IP blocks, so anything involving real faces or recognizable characters will get rejected, by design. And character consistency, while good, can drift over longer sequences; teams working on multi-shot narratives often lean on reference images to hold a character steady. The short version: it's strong for short-form, reference-guided work, and you should plan around the guardrails rather than fight them.

Try it now: Seedance 2.0 via API

Here's where waiting for 2.5 stops making sense. You can call Seedance 2.0 through GPT Proto's API and get a real clip back today. The model ID is dreamina-seedance-2-0-260128.

The call is a POST with your prompt and settings. Note the auth header takes your raw key with no Bearer prefix.

curl --location --request POST \
  'https://gptproto.com/api/v3/bytedance/dreamina-seedance-2-0-260128/text-to-video' \
  --header 'Authorization: YOUR_GPTPROTO_API_KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "prompt": "A lighthouse keeper climbs a spiral staircase at dawn, warm light spilling through narrow windows. Slow push-in, then a cut to the lamp room as the beam sweeps the fog.",
    "duration": 5,
    "aspect_ratio": "16:9",
    "resolution": "1080p",
    "generate_audio": true,
    "seed": -1
  }'

Generation is asynchronous: the POST returns a prediction id and a get URL, and you poll that URL until the status flips to completed. Here's the full loop in Python.

import requests
import time

BASE = "https://gptproto.com/api/v3"
HEADERS = {
    "Authorization": "YOUR_GPTPROTO_API_KEY",  # raw key, no "Bearer"
    "Content-Type": "application/json",
}

def generate_video(prompt: str) -> dict:
    payload = {
        "prompt": prompt,
        "duration": 5,
        "aspect_ratio": "16:9",
        "resolution": "1080p",
        "generate_audio": True,
        "seed": -1,
    }
    resp = requests.post(
        f"{BASE}/bytedance/dreamina-seedance-2-0-260128/text-to-video",
        headers=HEADERS,
        json=payload,
        timeout=30,
    )
    resp.raise_for_status()
    data = resp.json()["data"]
    poll_url = data["urls"]["get"]

    # Poll until the prediction finishes
    while True:
        result = requests.get(poll_url, headers=HEADERS, timeout=30).json()["data"]
        status = result.get("status")
        if status == "completed":
            return result
        if status in ("failed", "canceled"):
            raise RuntimeError(f"Generation {status}: {result}")
        time.sleep(5)

if __name__ == "__main__":
    out = generate_video(
        "A lighthouse keeper climbs a spiral staircase at dawn. "
        "Slow push-in, then a cut to the lamp room as the beam sweeps the fog."
    )
    print(out["outputs"])

For image-to-video, you send the same shape to the image-to-video path and add your source frame; the reference-to-video mode is where the 12-file @-system comes in, if you need a character or product held consistent across the clip.

On cost: GPT Proto bills pay-as-you-go per generation, starting around $0.30, and the price scales with resolution, duration, aspect ratio, and how many reference files you attach. A 1080p, 15-second clip lands near the top of that range. I'll be straight with you here rather than sell it: Seedance 2.0 is not the cheapest video model on the market, and if your only goal is the lowest possible per-clip cost, it isn't the obvious pick. What you're paying for is the multimodal reference control and native audio in one pass. The current rate matrix and the per-mode parameters both live on the model page.

When 2.5 lands, what changes for you

When ByteDance ships 2.5, the migration story should be mild. Across the family, each version has kept the prior API shape largely intact, so I expect the call pattern above to carry over with new parameter ranges rather than a rewrite. We'll publish a follow-up the day it drops, with real generations and a hands-on comparison against 2.0, instead of the predictions in this post. If you want the working version in the meantime, 2.0 is it.