How to Use Seedance 2.5 in Claude, Claude Code and Cursor?

Yes. You can run Seedance 2.5, ByteDance's video model, from Claude, Claude Code or Cursor by connecting the Makernice MCP server. The agent then prices a clip with estimate_cost, asks you to approve the amount, and starts it with generate, which won't spend more than the cap you approved. A 5-second 720p clip is $1.296 at price list v15 (November 12, 2026).

How do you connect Seedance 2.5 to Claude Code or Cursor?

Seedance 2.5 reaches Claude Code and Cursor through one MCP server, Makernice, which you add once per editor. In Claude Code, run the one-line claude mcp add --transport http --scope user makernice command from the Claude Code setup page, which also gives you the server URL. Start Claude Code, type /mcp, choose makernice and sign in to Makernice in the browser window that opens.

In Cursor, use the one-click install link or paste the server block into ~/.cursor/mcp.json, both on the Cursor setup page. Then sign in next to makernice in Cursor's MCP settings.

Either way, the connection has its own per-job limit and can have a daily limit too. Ask the agent to call get_balance once: it returns your available balance, today's spend and those connection limits, so you know a job will fit before you ask for one.

Makernice offers Seedance 2.5 in four places: MCP clients such as Claude, ChatGPT and Codex, the REST API, and the Create area of the Makernice console, where a browser form runs the same model at the same price. Every route shares one prepaid balance and the same price list.

• Claude: add the server under Customize → Connectors → Add custom connector and sign in to Makernice; on Team and Enterprise plans an owner adds it first in Organization settings → Connectors. The URL is on the Claude connect page.
• ChatGPT on the web: add it from Plugins as a custom MCP server with OAuth, using the separate address on the ChatGPT connect page. Your plan or workspace has to allow custom MCP servers, and that version has no get_topup_link tool.
• Codex: run codex mcp add makernice --url with the address from the Codex connect page, then approve the connection in the browser page that opens.
• REST API: quote, create, poll and download; the Seedance 2.5 API tutorial shows the four calls with curl.

Other platforms that list Seedance 2.5 with a US-dollar per-second price are in the Seedance 2.5 price comparison table, with the date each one was checked. ByteDance's own apps aren't covered on this page.

What does a first Seedance 2.5 request look like from Claude Code?

A first Seedance 2.5 request from Claude Code takes three tool calls: estimate_cost for the price, generate once you approve it, and check_job for the finished MP4. Here is the whole exchange.

You: Make a 5-second 16:9 clip of a cook tossing noodles in a flaming wok at a rainy night market. Tell me the price before you start.

Claude Code calls estimate_cost with the request it built:

{
  "name": "estimate_cost",
  "arguments": {
    "input": {
      "model": "seedance-2.5",
      "mode": "t2v",
      "prompt": "Night market in the rain, a cook tosses noodles in a flaming wok, steam drifting through neon signs, slow handheld push-in",
      "duration": 5,
      "resolution": "720p",
      "aspect_ratio": "16:9"
    }
  }
}

Claude Code: That clip is $1.296 (Seedance 2.5, 720p, 5 seconds, price list v15). Nothing has been charged. Shall I start it?

You: Yes, go ahead.

The agent sends the same input to generate, with the approved amount as max_cost_usd and a request_id of its own choosing:

{
  "name": "generate",
  "arguments": {
    "input": {
      "model": "seedance-2.5",
      "mode": "t2v",
      "prompt": "Night market in the rain, a cook tosses noodles in a flaming wok, steam drifting through neon signs, slow handheld push-in",
      "duration": 5,
      "resolution": "720p",
      "aspect_ratio": "16:9"
    },
    "max_cost_usd": "1.296",
    "request_id": "night-market-wok-720p-1"
  }
}

generate quotes the input again at that moment and creates the job only if the price is at or below max_cost_usd and within the connection's per-job limit; the charge equals that quote. It returns a job_id with billing set to held. If the reply is lost and the agent retries with the same request_id and input, it gets the same job back, so you are never charged twice.

To wait for the clip, the agent calls check_job. With wait_s it holds the call open for up to 55 seconds and returns as soon as the job ends:

{
  "name": "check_job",
  "arguments": {
    "job_id": "gen_...",
    "wait_s": 55
  }
}

When status is succeeded, outputs[0].url is a signed link to the MP4 that stays valid for 24 hours; calling check_job again issues a fresh one, and console_url opens the run in your Makernice console. If you'd rather not keep an agent waiting, an account webhook fires for jobs started over MCP too.

Which settings matter in a Seedance 2.5 text-to-video request?

Four fields shape a Seedance 2.5 text-to-video request: prompt (up to 4,000 characters), duration from 4 to 30 seconds (5 if you don't say), resolution at 480p, 720p, 1080p or 4k (720p by default) and aspect_ratio, one of adaptive, 16:9, 9:16, 1:1, 4:3, 3:4, 21:9, 9:21. Say what you want in plain words and the agent fills them in. The price depends only on resolution and length: $0.2592 per second at 720p and $0.6415 per second at 1080p (price list v15), the same in every mode.

Write the prompt as one shot: a subject, a single action, one camera move, the light and a pace that fits the length. The text-to-video prompt guide has weak and better examples. The full specification is on the Seedance 2.5 model page.

How do you turn an image into a video with Seedance 2.5, and how many reference images does it accept?

Seedance 2.5 animates a still in image-to-video mode: the agent sends mode i2v with the picture in image_url. For a shot that must start on one frame and end on another, it sends mode flf with image_url and last_image_url. Both modes accept aspect_ratio and adaptive, which follows the shape of your image.

Images must be public https links to a JPEG, PNG or WebP file of up to 10 MB; Seedance 2.5 also needs the shorter side to be at least 300 px and the longer side at most 6000 px. A local file path won't work over MCP, so upload the still somewhere public first. Here is the agent pricing an 8-second 1080p clip from a still:

{
  "name": "estimate_cost",
  "arguments": {
    "input": {
      "model": "seedance-2.5",
      "mode": "i2v",
      "prompt": "The cook looks up from the wok and grins at the camera as the flames die down",
      "image_url": "https://example.com/stills/wok-cook.png",
      "duration": 8,
      "resolution": "1080p"
    }
  }
}

How first frames and end frames are read is covered in image-to-video and first and last frame.

Reference images. Seedance 2.5 accepts up to 16 reference images in one reference-to-video request: the agent sends mode r2v with the links in reference_images and a prompt that says how the subject should appear. References follow the same file and size rules as frames. Seedance on Makernice takes still images only, so a reference video or an audio file isn't accepted. The reference-to-video guide compares limits across models and explains how to pick references.

How can you use Seedance 2.5 cheaply from Claude Code?

Seedance 2.5 on Makernice costs the per-second price times the seconds, so spending less comes down to resolution, length and drafts. For a shot that may take several tries, ask for a draft: the agent sends draft true at 480p, charged like any 480p clip at $0.1152 per second. Within 3 days, a succeeded draft becomes a 1080p final through generate with from_draft set to the draft's job_id; that is a second charge, so the agent should run estimate_cost on the final first.

The Seedance 2.5 draft mode guide explains when drafts save money. To see what other platforms list per second for the same tiers, open the Seedance 2.5 price comparison table (checked 2026-11-11), and compare their rules for credit expiry and failed runs too.

Does Seedance 2.5 generate audio?

Yes. Every Seedance 2.5 clip on Makernice comes with an audio track, and there is no switch to turn it off: Seedance doesn't take the generate_audio option. Makernice has no separate setting for voice, music or sound effects, and Seedance doesn't accept an audio file as input. If you need a silent clip, remove the audio track after you download it.

Why was my Seedance 2.5 generation blocked by content moderation?

A Seedance 2.5 request on Makernice passes two kinds of checks: Makernice's own moderation of the prompt and input images, and the safety policy of ByteDance's model. BytePlus, ByteDance's cloud platform, says requests can be blocked by an input filter and by output moderation, and that some platform-level safety policies can't be turned off (BytePlus help). ByteDance's Ark error codes list input images that may show a real person, inputs or outputs that may involve copyright, and sensitive content (Ark error codes).

Makernice doesn't offer an unrestricted Seedance 2.5: the same checks apply through MCP, the API and the browser form. A job that content moderation stops after it starts ends with the error code content_rejected in check_job, and the held amount is released; a prompt or image blocked when you submit it is refused with a readable message, and nothing is charged. Note: if a finished output is blocked by output moderation for a policy violation, the run is still charged. You can contact support for a manual review. Rewrite the flagged wording or swap the image; for people in a video, the acceptable use policy lists the allowed cases, and why Seedance generations fail goes through each rejection.

Why did my Seedance 2.5 job fail, get refused or get stuck in queue, and is it charged?

A refused Seedance 2.5 generate call creates no job and charges nothing, and a job that fails after it starts has its held amount released in full. Note: if a finished output is blocked by output moderation for a policy violation, the run is still charged. You can contact support for a manual review. The table lists the refusals: the first column is the name in Makernice's server code, the second is the start of the text the tool returns.

The REST API reports the same limits as 429 rate_limited or 429 concurrency_limit_reached, with a Retry-After header in seconds; wait that long before the next call. Each account runs 2 jobs at once by default, so queue the rest on your side. A job that fails after it starts shows status failed with an error object in check_job, and billing changes to released. The rules for what is and isn't charged are on failed generations.

Stuck or slow. A Seedance 2.5 job on Makernice can take a few minutes, longer for long or high-resolution clips, and Makernice fails it with the error code timeout if it runs past 60 minutes; a timed-out job isn't charged. Makernice reports a status, not a percentage: queued, then generating, then moderating while the finished output is checked, then succeeded.

Let the agent wait with check_job and wait_s instead of starting a second job. If a reply was lost, retrying generate with the same request_id returns the job that already exists. A job still in queued can be stopped with cancel_job, which releases the held amount in full; once generating starts it can't be canceled.

Can you call Seedance 2.5 from Python, and where are the API docs?

Yes. Python can call Seedance 2.5 through the Makernice REST API with any HTTP client: there is no official SDK, and the API is plain REST rather than OpenAI-compatible. The script quotes the input, creates the generation with an Idempotency-Key, polls the status and downloads the file:

import os, time, uuid
import requests

API_BASE = "https://api.makernice.com/v1"
HEADERS = {"Authorization": "Bearer " + os.environ["MAKERNICE_API_KEY"]}
TIMEOUT_S = 30

job = {
    "model": "seedance-2.5",
    "mode": "t2v",
    "prompt": "A paper lantern drifts over a dark lake, slow dolly-in",
    "duration": 5,
    "resolution": "720p",
}

# 1. Quote the exact input (the quote locks the price for 12 minutes)
quote = requests.post(API_BASE + "/generations/quote", json=job, headers=HEADERS, timeout=TIMEOUT_S).json()

# 2. Create the generation; reuse the same Idempotency-Key on any retry
headers = {**HEADERS, "Idempotency-Key": str(uuid.uuid4())}
gen = requests.post(API_BASE + "/generations", json={"quote_id": quote["id"], "input": job}, headers=headers, timeout=TIMEOUT_S).json()

# 3. Poll until the generation reaches a final status
while gen["status"] not in ("succeeded", "failed", "canceled"):
    time.sleep(5)
    gen = requests.get(API_BASE + "/generations/" + gen["id"], headers=HEADERS, timeout=TIMEOUT_S).json()

# 4. Download the MP4 (the endpoint redirects to a short-lived signed URL)
if gen["status"] == "succeeded":
    video = requests.get(API_BASE + "/generations/" + gen["id"] + "/outputs/0", headers=HEADERS, timeout=TIMEOUT_S)
    with open("seedance-2-5.mp4", "wb") as f:
        f.write(video.content)

Every field, status and error code is in the API docs, with a troubleshooting list for common failures. The Seedance 2.5 API tutorial walks through the same four calls with curl, and API integration best practices covers retries and Retry-After.