> ## Documentation Index
> Fetch the complete documentation index at: https://apidoc.cometapi.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Opprett en Seedance-video
> Opprett en Seedance-videooppgave på CometAPI. Bruk tekstprompter eller referansemedier med en varighet og WxH-utdatastørrelse.
Angi `size` til en `WxH`-verdi fra størrelsestabellen for modellen din.
Bruk `doubao-seedance-2-0-mini` nøyaktig for Seedance 2.0 Mini.
Den forkortede `seedance-mini`-verdien er ikke en gyldig modell-ID.
## Støttede modell-ID-er
Velg en modell for inndatamodusen og oppløsningen din, og send deretter den nøyaktige ID-en i feltet `model`.
| Modell | Eksakt modell-ID | Moduser og oppløsningsnivåer | Støttet `seconds` |
| ----------------- | -------------------------- | --------------------------------------------------------------- | ----------------- |
| Seedance 2.5 | `seedance-2-5` | Tekst-til-video, referansemedier; `480p`, `720p` | `4`-`30` |
| Seedance 2.0 | `doubao-seedance-2-0` | Tekst-til-video, referansemedier; `480p`, `720p`, `1080p`, `4K` | `4`-`15` |
| Seedance 2.0 Fast | `doubao-seedance-2-0-fast` | Tekst-til-video, referansemedier; `480p`, `720p` | `4`-`15` |
| Seedance 2.0 Mini | `doubao-seedance-2-0-mini` | Tekst-til-video, referansemedier; `480p`, `720p` | `4`-`15` |
| Seedance 1.5 Pro | `doubao-seedance-1-5-pro` | Tekst-til-video, bilde-til-video; `480p`, `720p`, `1080p` | `4`-`12` |
| Seedance 1.0 Pro | `doubao-seedance-1-0-pro` | Tekst-til-video, bilde-til-video; `480p`, `720p`, `1080p` | `2`-`10` |
## Bruk referansebilder
Send `POST /v1/videos` som `multipart/form-data`, med referansebilder i `input_reference`.
For flere bilder gjentar du feltet i bilderekkefølge, med én offentlig tilgjengelig HTTPS-bilde-URL eller én opplastet bildefil per felt.
Bruk bare URL-er eller bare filer i dette feltet. Send hver URL separat i stedet for å sette sammen URL-er med kommaer.
Hold hvert opplastede bilde på eller under 20 MiB (20 × 1024 × 1024 byte).
Seedance 1.0 Pro og 1.5 Pro bruker ett referansebilde. Seedance 2.0, Fast og Mini godtar opptil 9 referansebilder.
Seedance 2.5 godtar opptil 30 referansebilder. Disse antallene gjelder både URL-er og opplastede filer.
I Prompt-en skal du gi hvert bilde en rolle, for eksempel motivet, miljøet eller den visuelle stilen.
Beskriv utseendet som skal bevares, handlingen og kamerabevegelsen.
Forespørselseksemplene øverst på denne siden viser inndata med bilde-URL-er og opplasting av ett eller flere bilder.
### Send URL-er for referansebilder
Bruk to bilde-URL-er for å styre motivets utseende og miljø:
```bash theme={null}
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=doubao-seedance-2-0' \
--form-string 'prompt=Use the subject in @Image1 and the setting in @Image2. Use a slow camera push-in and natural motion.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form-string 'input_reference=https://your-image-host/subject.png' \
--form-string 'input_reference=https://your-image-host/setting.png'
```
## Bruk referansevideo og -lyd
Seedance 2.0, Fast, Mini og 2.5 godtar `reference_videos` og `reference_audios`.
Bruk MP4-filer for videoreferanser og MP3-filer for lydreferanser. Send hver av dem som en offentlig tilgjengelig HTTPS-URL eller en opplastet fil.
Kombiner referanselyd med minst ett bilde eller én video.
Bruk `@Image1`, `@Video1` og `@Audio1` i Prompt for å tilordne roller til referansene dine.
Nummerer referansene etter rekkefølgen deres innen hver medietype.
Du kan kombinere URL-er og opplastinger på tvers av ulike felt.
I hver av `input_reference`, `reference_videos` og `reference_audios` bruker du enten bare URL-er eller bare filer.
For flere inndata gjentar du feltet én gang per inndata i stedet for å sette sammen URL-er med kommaer.
| Modellfamilie | Referansebilder | Referansevideoer | Referanselyd | Totalt antall referanseinndata |
| -------------------------- | ------------------------------------------------ | ------------------------------ | ------------------------------ | ------------------------------ |
| Seedance 2.0, Fast og Mini | Opptil 9 URL-er eller filer i `input_reference` | Opptil 3 | Opptil 3 | Opptil 12 |
| Seedance 2.5 | Opptil 30 URL-er eller filer i `input_reference` | Opptil 10 URL-er eller 5 filer | Opptil 10 URL-er eller 5 filer | Opptil 50 |
Hold hver opplastede video på maksimalt 50 MiB og hver opplastede lydfil på maksimalt 15 MiB.
Én MiB er 1024 × 1024 byte.
Standard Seedance 2.0 (`doubao-seedance-2-0`) har ytterligere mediegrenser for både URL-er og opplastede filer.
For referansevideoer må den samlede varigheten være mellom 2 og 15 sekunder, og den totale størrelsen under 50 MB.
Bruk en referansevideooppløsning på omtrent 480p (640x640) til 720p (834x1112).
For referanselyd må den samlede varigheten være maksimalt 15 sekunder, og hver fil maksimalt 15 MB.
Opplastede medier må også oppfylle opplastingsgrensene per fil ovenfor.
### Send en URL for referansevideo
Bruk referansevideoen til å styre kamerabevegelsen og handlingen:
```bash theme={null}
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=doubao-seedance-2-0' \
--form-string 'prompt=Follow the camera movement and action in @Video1. Preserve the direction and pace of the motion.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form-string 'reference_videos=https://your-media-host/reference.mp4'
```
### Kombiner en bilde-URL med lyd
Animer referansemotivet i takt med referanselyden:
```bash theme={null}
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=doubao-seedance-2-0' \
--form-string 'prompt=Animate the subject in @Image1 to the rhythm of @Audio1. Preserve the subject appearance and use a fixed camera.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form-string 'input_reference=https://your-image-host/subject.png' \
--form-string 'reference_audios=https://your-media-host/reference.mp3'
```
### Last opp referansemedier med Seedance 2.5
Last opp to bilder, en MP4-video og en MP3-lydfil i én forespørsel:
```bash theme={null}
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=seedance-2-5' \
--form-string 'prompt=Use the subject in @Image1 and the setting in @Image2. Follow the motion in @Video1 and the rhythm of @Audio1.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form 'input_reference=@/path/to/subject.png;type=image/png' \
--form 'input_reference=@/path/to/setting.png;type=image/png' \
--form 'reference_videos=@/path/to/reference.mp4;type=video/mp4' \
--form 'reference_audios=@/path/to/reference.mp3;type=audio/mpeg'
```
## Varighet etter modell
Angi `seconds` til en heltallsverdi innenfor modellens område. Hvis du utelater den, ber CometAPI om et klipp på 5 sekunder.
| Modellfamilie | Støttet `seconds` | Standard | Oppførsel ved grenseverdier |
| ---------------------------------------------------- | ----------------- | -------- | ------------------------------------ |
| Seedance 2.5 | `4`-`30` | `5` | Bruk hele sekunder innenfor området. |
| Seedance 2.0, Seedance 2.0 Fast og Seedance 2.0 Mini | `4`-`15` | `5` | Bruk hele sekunder innenfor området. |
| Seedance 1.5 Pro | `4`-`12` | `5` | Bruk hele sekunder innenfor området. |
| Seedance 1.0 Pro | `2`-`10` | `5` | Bruk hele sekunder innenfor området. |
## Størrelsesstøtte etter modell
### Seedance 2.5
For Seedance 2.5 gjelder disse `WxH`-verdiene både for tekstprompter og referansemedier.
| Oppløsningsklasse | `16:9` | `4:3` | `1:1` | `3:4` | `9:16` | `21:9` |
| ----------------- | ---------- | ---------- | --------- | ---------- | ---------- | ---------- |
| `480p` | `854x480` | `752x560` | `640x640` | `560x752` | `480x854` | `992x432` |
| `720p` | `1280x720` | `1112x834` | `960x960` | `834x1112` | `720x1280` | `1470x630` |
### Tidligere Seedance-modeller
Den siste kolonnen grupperer eksakte `WxH`-verdier for Seedance 1.5 Pro, standard Seedance 2.0 og Fast.
Seedance 2.0 Fast bruker bare verdiene `480p` og `720p` i den kolonnen.
`1080p`-verdiene i den kolonnen gjelder for Seedance 1.5 Pro og standard Seedance 2.0.
`4K`-verdiene gjelder bare for standard Seedance 2.0. I Mini-kolonnen betyr `—` at oppløsningen ikke støttes.
| Oppløsningsklasse | Sideforhold | Seedance 2.0 Mini | Seedance 1.0-serien | Seedance 1.5 Pro / standard Seedance 2.0 / Fast |
| ----------------- | ----------- | ----------------- | ------------------- | ----------------------------------------------- |
| `480p` | `16:9` | `864x496` | `864x480` | `864x496` |
| | `4:3` | `752x560` | `736x544` | `752x560` |
| | `1:1` | `640x640` | `640x640` | `640x640` |
| | `3:4` | `560x752` | `544x736` | `560x752` |
| | `9:16` | `496x864` | `480x864` | `496x864` |
| | `21:9` | `992x432` | `960x416` | `992x432` |
| `720p` | `16:9` | `1280x720` | `1248x704` | `1280x720` |
| | `4:3` | `1112x834` | `1120x832` | `1112x834` |
| | `1:1` | `960x960` | `960x960` | `960x960` |
| | `3:4` | `834x1112` | `832x1120` | `834x1112` |
| | `9:16` | `720x1280` | `704x1248` | `720x1280` |
| | `21:9` | `1470x630` | `1504x640` | `1470x630` |
| `1080p` | `16:9` | — | `1920x1088` | `1920x1080` |
| | `4:3` | — | `1664x1248` | `1664x1248` |
| | `1:1` | — | `1440x1440` | `1440x1440` |
| | `3:4` | — | `1248x1664` | `1248x1664` |
| | `9:16` | — | `1088x1920` | `1080x1920` |
| | `21:9` | — | `2176x928` | `2206x946` |
| `4K` | `16:9` | — | — | `3840x2160` (Kun Seedance 2.0) |
| | `4:3` | — | — | `3326x2494` (Kun Seedance 2.0) |
| | `1:1` | — | — | `2880x2880` (Kun Seedance 2.0) |
| | `3:4` | — | — | `2494x3326` (Kun Seedance 2.0) |
| | `9:16` | — | — | `2160x3840` (Kun Seedance 2.0) |
| | `21:9` | — | — | `4398x1886` (Kun Seedance 2.0) |
Seedance 2.0 Mini støtter `480p` og `720p`. Angi `size` til en `WxH`-verdi fra Mini-kolonnen.
## OpenAPI
````yaml api/openapi/video/seedance/post-seedance-create.openapi.json POST /v1/videos
openapi: 3.1.0
info:
title: Seedance Video Generation API
version: 1.0.0
description: >-
Create an asynchronous ByteDance Seedance video task through CometAPI. Use
one of the six documented model IDs exactly. Seedance 2.5 accepts text
prompts or reference images with the documented 480p and 720p WxH values.
Save the returned id and poll GET /v1/videos/{id} until the status reaches
completed.
servers:
- url: https://api.cometapi.com
security:
- bearerAuth: []
paths:
/v1/videos:
post:
summary: Create a Seedance video task
description: >-
Submit a Seedance video task as multipart/form-data. Use text prompts or
reference images. For multiple images, repeat input_reference with one
HTTPS image URL or uploaded file per field. Use only URLs or only files
within input_reference. Seedance 2.0, Fast, Mini, and 2.5 also accept
reference video and audio. Pair audio with at least one image or video.
The endpoint returns a task ID; use GET /v1/videos/{id} to read the
final result.
operationId: seedance_create_video
requestBody:
required: true
content:
multipart/form-data:
schema:
type: object
required:
- prompt
- model
properties:
prompt:
type: string
description: >-
Text prompt that describes the video. Required. When using
reference images, describe what each image should control,
such as the subject from @Image1, the secondary object from
@Image2, and the background or style from @Image3. Also
state the action, camera motion, visual style, and scene.
example: >-
A slow cinematic camera push across a coastal landscape at
sunrise.
model:
type: string
description: >-
Seedance model ID. Use one of the exact values below.
Aliases such as seedance-mini are not accepted.
enum:
- seedance-2-5
- doubao-seedance-2-0
- doubao-seedance-2-0-fast
- doubao-seedance-2-0-mini
- doubao-seedance-1-5-pro
- doubao-seedance-1-0-pro
example: doubao-seedance-2-0-mini
seconds:
type: integer
description: >-
Video duration in seconds. Seedance 2.5 accepts 4 to 30.
Seedance 2.0, Seedance 2.0 Fast, and Seedance 2.0 Mini
accept 4 to 15. Seedance 1.5 Pro accepts 4 to 12, and
Seedance 1.0 Pro accepts 2 to 10. The default is 5.
minimum: 2
maximum: 30
default: 5
example: 5
size:
type: string
description: >-
Output size as an exact WxH value. For Seedance 2.5
text-to-video and image-to-video, use 854x480, 752x560,
640x640, 560x752, 480x854, or 992x432 for 480p; use
1280x720, 1112x834, 960x960, 834x1112, 720x1280, or 1470x630
for 720p. For Seedance 2.0 Mini, use 864x496, 752x560,
640x640, 560x752, 496x864, or 992x432 for 480p; use the same
documented 720p values. The standard Seedance 2.0 model also
accepts its documented 4K values.
pattern: ^[1-9]\d{2,3}x[1-9]\d{2,3}$
examples:
- 854x480
- 480x854
- 864x496
- 752x560
- 640x640
- 560x752
- 496x864
- 992x432
- 1280x720
- 1112x834
- 960x960
- 834x1112
- 720x1280
- 1470x630
- 1920x1080
- 1080x1920
- 3840x2160
- 3326x2494
- 2880x2880
- 2494x3326
- 2160x3840
- 4398x1886
example: 1280x720
input_reference:
description: >-
Reference images: repeat input_reference with one publicly
accessible HTTPS image URL or one uploaded image file per
field. Use only URLs or only files within this field; do not
join URLs with commas. Keep each uploaded image at or below
20 MiB. Seedance 2.0, Fast, and Mini allow up to nine image
URLs or files and 12 reference inputs in total. Seedance 2.5
allows up to 30 image URLs or files and 50 reference inputs
in total. For Seedance 1.0 Pro and 1.5 Pro, send one URL or
one file. Submit images in the order you want to reference
them in the prompt.
anyOf:
- title: Single image URL
type: string
format: uri
pattern: ^https://
description: One publicly accessible HTTPS image URL.
- title: Image URLs
type: array
minItems: 1
maxItems: 30
items:
type: string
format: uri
pattern: ^https://
description: One publicly accessible HTTPS image URL.
- title: Image files
type: array
minItems: 1
maxItems: 30
items:
type: string
format: binary
description: One uploaded reference image file.
reference_videos:
type: array
minItems: 1
maxItems: 10
items:
anyOf:
- type: string
format: uri
pattern: ^https://
example: https://your-media-host/reference.mp4
- type: string
format: binary
description: >-
Reference video inputs for Seedance 2.0, Fast, Mini, and
2.5. Repeat reference_videos with a publicly accessible
HTTPS MP4 URL or an uploaded MP4 file. Use only URLs or only
files within this field. Each file can be up to 50 MiB.
Seedance 2.0, Fast, and Mini allow up to three video inputs
and 12 reference inputs in total. Seedance 2.5 allows up to
ten video URLs or five uploaded video files, with 50
reference inputs in total. For standard Seedance 2.0
(doubao-seedance-2-0), URL and uploaded references must have
a combined video duration of 2 to 15 seconds and a total
video size under 50 MB. Each reference video must have a
resolution of approximately 480p (640x640) to 720p
(834x1112). These media limits apply in addition to the 50
MiB per-file upload limit.
reference_audios:
type: array
minItems: 1
maxItems: 10
items:
anyOf:
- type: string
format: uri
pattern: ^https://
example: https://your-media-host/reference.mp3
- type: string
format: binary
description: >-
Reference audio inputs for Seedance 2.0, Fast, Mini, and
2.5. Repeat reference_audios with a publicly accessible
HTTPS MP3 URL or an uploaded MP3 file. Use only URLs or only
files within this field. Each file can be up to 15 MiB.
Seedance 2.0, Fast, and Mini allow up to three audio inputs
and 12 reference inputs in total. Seedance 2.5 allows up to
ten audio URLs or five uploaded audio files, with 50
reference inputs in total. Pair audio with at least one
reference image or video. For standard Seedance 2.0
(doubao-seedance-2-0), URL and uploaded audio references
must have a combined duration at or below 15 seconds, with
each audio file at or below 15 MB. These media limits apply
in addition to the 15 MiB per-file upload limit.
encoding:
input_reference:
contentType: text/plain, image/jpeg, image/png, image/webp
style: form
explode: true
reference_videos:
contentType: text/plain, video/mp4
style: form
explode: true
reference_audios:
contentType: text/plain, audio/mpeg
style: form
explode: true
examples:
seedance_2_5_text_to_video:
summary: Seedance 2.5 text-to-video
value:
prompt: >-
A matte magenta cube rotates slowly above a cyan studio
floor while a small yellow sphere circles it.
model: seedance-2-5
seconds: 4
size: 1280x720
seedance_2_5_single_reference_image:
summary: Seedance 2.5 single-reference image-to-video
value:
prompt: >-
Animate the uploaded reference image with a gentle camera
push-in and subtle object motion. Preserve its colors,
shapes, and overall layout.
model: seedance-2-5
seconds: 4
size: 720x1280
input_reference:
-
seedance_2_0_multiple_reference_images:
summary: Multiple reference images (Seedance 2.0)
value:
prompt: >-
Use the uploaded images in order: keep the boy wearing
glasses and a blue T-shirt from [Image 1], add the corgi
puppy from [Image 2], and use the lawn from [Image 3] as the
setting. Create a 4-second 3D cartoon video with the boy and
puppy sitting together, a slow camera push-in, soft
daylight, and no extra characters.
model: doubao-seedance-2-0
seconds: 4
size: 720x1280
input_reference:
- '@/path/to/seelite_ref_1.png'
- '@/path/to/seelite_ref_2.png'
- '@/path/to/seelite_ref_3.png'
seedance_2_0_mini_text_to_video:
summary: Seedance 2.0 Mini text-to-video
value:
prompt: >-
A matte red cube rotates slowly on a clean white studio
floor. The camera remains fixed. Soft daylight and a short
shadow.
model: doubao-seedance-2-0-mini
seconds: 15
size: 1280x720
seedance_2_0_url_reference_image:
summary: HTTPS reference image URLs (Seedance 2.0)
value:
model: doubao-seedance-2-0
prompt: >-
Use the subject in @Image1 and the setting in @Image2. Use a
slow camera push-in and natural motion.
seconds: 5
size: 1280x720
input_reference:
- https://your-image-host/subject.png
- https://your-image-host/setting.png
seedance_2_0_reference_video_url:
summary: HTTPS reference video (Seedance 2.0)
value:
model: doubao-seedance-2-0
prompt: >-
Follow the camera movement and action in @Video1. Preserve
the direction and pace of the motion.
seconds: 5
size: 1280x720
reference_videos:
- https://your-media-host/reference.mp4
seedance_2_0_image_audio_urls:
summary: HTTPS reference audio with an image (Seedance 2.0)
value:
model: doubao-seedance-2-0
prompt: >-
Animate the subject in @Image1 to the rhythm of @Audio1.
Preserve the subject appearance and use a fixed camera.
seconds: 5
size: 1280x720
reference_audios:
- https://your-media-host/reference.mp3
input_reference: https://your-image-host/subject.png
seedance_2_5_uploaded_reference_media:
summary: Uploaded reference media (Seedance 2.5)
value:
model: seedance-2-5
prompt: >-
Use the subject in @Image1 and the setting in @Image2.
Follow the motion in @Video1 and the rhythm of @Audio1.
seconds: 5
size: 1280x720
input_reference:
- '@/path/to/subject.png'
- '@/path/to/setting.png'
reference_videos:
- '@/path/to/reference.mp4'
reference_audios:
- '@/path/to/reference.mp3'
responses:
'200':
description: Task created. Save the returned id and poll GET /v1/videos/{id}.
content:
application/json:
schema:
$ref: '#/components/schemas/CreateVideoResponse'
example:
id: task_abc123
task_id: task_abc123
object: video
model: doubao-seedance-2-0-mini
status: queued
progress: 0
created_at: 1776681149
'400':
description: >-
The request is missing a required field or contains an out-of-range
value.
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
examples:
missing_prompt:
summary: prompt field missing
value:
code: invalid_request
message: prompt is required
missing_model:
summary: model field missing
value:
error:
code: ''
message: model name is required
type: comet_api_error
invalid_duration:
summary: seconds outside the per-model range
value:
code: InvalidParameter
message: >-
the parameter duration specified in the request is not
valid
i2v_not_supported:
summary: input_reference sent with a 1.0 Pro or 1.5 Pro model
value:
code: InvalidParameter
message: >-
The parameter task_type specified in the request is not
valid: the specified task_type r2v does not support model
seedance-1-5-pro
'401':
description: The API key is missing or invalid.
content:
application/json:
schema:
$ref: '#/components/schemas/ErrorResponse'
examples:
invalid_token:
summary: Bearer token rejected
value:
error:
code: ''
message: invalid token
type: comet_api_error
x-codeSamples:
- lang: Shell
label: Text-to-video (Seedance 2.5, exact 1280x720)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="A matte magenta cube rotates slowly above a cyan studio floor while a small yellow sphere circles it."' \
-F 'model="seedance-2-5"' \
-F 'seconds="4"' \
-F 'size="1280x720"'
- lang: Python
label: Text-to-video (Seedance 2.5, exact 1280x720)
source: |
import os
import requests
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": "A matte magenta cube rotates slowly above a cyan studio floor while a small yellow sphere circles it.",
"model": "seedance-2-5",
"seconds": "4",
"size": "1280x720",
},
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Text-to-video (Seedance 2.5, exact 1280x720)
source: >
const form = new FormData();
form.append("prompt", "A matte magenta cube rotates slowly above a
cyan studio floor while a small yellow sphere circles it.");
form.append("model", "seedance-2-5");
form.append("seconds", "4");
form.append("size", "1280x720");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: Single reference image (Seedance 2.5)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="Animate the uploaded reference image with a gentle camera push-in and subtle object motion. Preserve its colors, shapes, and overall layout."' \
-F 'model="seedance-2-5"' \
-F 'seconds="4"' \
-F 'size="720x1280"' \
-F 'input_reference=@"/path/to/reference.png"'
- lang: Python
label: Single reference image (Seedance 2.5)
source: >
import os
import requests
prompt = "Animate the uploaded reference image with a gentle camera
push-in and subtle object motion. Preserve its colors, shapes, and
overall layout."
with open("/path/to/reference.png", "rb") as image:
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": prompt,
"model": "seedance-2-5",
"seconds": "4",
"size": "720x1280",
},
files={"input_reference": ("reference.png", image, "image/png")},
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Single reference image (Seedance 2.5)
source: >
import { readFile } from "node:fs/promises";
const image = await readFile("/path/to/reference.png");
const form = new FormData();
form.append("prompt", "Animate the uploaded reference image with a
gentle camera push-in and subtle object motion. Preserve its colors,
shapes, and overall layout.");
form.append("model", "seedance-2-5");
form.append("seconds", "4");
form.append("size", "720x1280");
form.append("input_reference", new Blob([image], { type: "image/png"
}), "reference.png");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: Text-to-video (Seedance 2.0 Mini, exact 1280x720)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="A matte red cube rotates slowly on a clean white studio floor. The camera remains fixed. Soft daylight and a short shadow."' \
-F 'model="doubao-seedance-2-0-mini"' \
-F 'seconds="15"' \
-F 'size="1280x720"'
- lang: Python
label: Text-to-video (Seedance 2.0 Mini, exact 1280x720)
source: |
import os
import requests
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": "A matte red cube rotates slowly on a clean white studio floor. The camera remains fixed. Soft daylight and a short shadow.",
"model": "doubao-seedance-2-0-mini",
"seconds": "15",
"size": "1280x720",
},
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Text-to-video (Seedance 2.0 Mini, exact 1280x720)
source: >
const form = new FormData();
form.append("prompt", "A matte red cube rotates slowly on a clean
white studio floor. The camera remains fixed. Soft daylight and a
short shadow.");
form.append("model", "doubao-seedance-2-0-mini");
form.append("seconds", "15");
form.append("size", "1280x720");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: Single reference image (Seedance 2.0)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="Use [Image 1] as the main visual reference. Preserve the subject identity, clothing colors, and overall composition from [Image 1]. Create a 4-second video with a gentle camera push-in, subtle natural motion, warm daylight, and a realistic cinematic style."' \
-F 'model="doubao-seedance-2-0"' \
-F 'seconds="4"' \
-F 'size="720x1280"' \
-F 'input_reference=@"/path/to/reference.png"'
- lang: Python
label: Single reference image (Seedance 2.0)
source: >
import os
import requests
prompt = "Use [Image 1] as the main visual reference. Preserve the
subject identity, clothing colors, and overall composition from
[Image 1]. Create a 4-second video with a gentle camera push-in,
subtle natural motion, warm daylight, and a realistic cinematic
style."
with open("/path/to/reference.png", "rb") as image:
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": prompt,
"model": "doubao-seedance-2-0",
"seconds": "4",
"size": "720x1280",
},
files=[("input_reference", ("reference.png", image, "image/png"))],
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Single reference image (Seedance 2.0)
source: >
import { readFile } from "node:fs/promises";
const prompt = "Use [Image 1] as the main visual reference. Preserve
the subject identity, clothing colors, and overall composition from
[Image 1]. Create a 4-second video with a gentle camera push-in,
subtle natural motion, warm daylight, and a realistic cinematic
style.";
const image = await readFile("/path/to/reference.png");
const form = new FormData();
form.append("prompt", prompt);
form.append("model", "doubao-seedance-2-0");
form.append("seconds", "4");
form.append("size", "720x1280");
form.append("input_reference", new Blob([image], { type: "image/png"
}), "reference.png");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: Multiple reference images (Seedance 2.0)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="Use the uploaded images in order: keep the boy wearing glasses and a blue T-shirt from [Image 1], add the corgi puppy from [Image 2], and use the lawn from [Image 3] as the setting. Create a 4-second 3D cartoon video with the boy and puppy sitting together, a slow camera push-in, soft daylight, and no extra characters."' \
-F 'model="doubao-seedance-2-0"' \
-F 'seconds="4"' \
-F 'size="720x1280"' \
-F 'input_reference=@"/path/to/seelite_ref_1.png"' \
-F 'input_reference=@"/path/to/seelite_ref_2.png"' \
-F 'input_reference=@"/path/to/seelite_ref_3.png"'
- lang: Python
label: Multiple reference images (Seedance 2.0)
source: >
import os
import requests
prompt = "Use the uploaded images in order: keep the boy wearing
glasses and a blue T-shirt from [Image 1], add the corgi puppy from
[Image 2], and use the lawn from [Image 3] as the setting. Create a
4-second 3D cartoon video with the boy and puppy sitting together, a
slow camera push-in, soft daylight, and no extra characters."
with open("/path/to/seelite_ref_1.png", "rb") as image_1,
open("/path/to/seelite_ref_2.png", "rb") as image_2,
open("/path/to/seelite_ref_3.png", "rb") as image_3:
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": prompt,
"model": "doubao-seedance-2-0",
"seconds": "4",
"size": "720x1280",
},
files=[
("input_reference", ("seelite_ref_1.png", image_1, "image/png")),
("input_reference", ("seelite_ref_2.png", image_2, "image/png")),
("input_reference", ("seelite_ref_3.png", image_3, "image/png")),
],
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Multiple reference images (Seedance 2.0)
source: >
import { readFile } from "node:fs/promises";
const prompt = "Use the uploaded images in order: keep the boy
wearing glasses and a blue T-shirt from [Image 1], add the corgi
puppy from [Image 2], and use the lawn from [Image 3] as the
setting. Create a 4-second 3D cartoon video with the boy and puppy
sitting together, a slow camera push-in, soft daylight, and no extra
characters.";
const image1 = await readFile("/path/to/seelite_ref_1.png");
const image2 = await readFile("/path/to/seelite_ref_2.png");
const image3 = await readFile("/path/to/seelite_ref_3.png");
const form = new FormData();
form.append("prompt", prompt);
form.append("model", "doubao-seedance-2-0");
form.append("seconds", "4");
form.append("size", "720x1280");
form.append("input_reference", new Blob([image1], { type:
"image/png" }), "seelite_ref_1.png");
form.append("input_reference", new Blob([image2], { type:
"image/png" }), "seelite_ref_2.png");
form.append("input_reference", new Blob([image3], { type:
"image/png" }), "seelite_ref_3.png");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: Text-to-video (exact 1920x1080)
source: |-
curl https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
-F 'prompt="A slow cinematic camera push across a coastal landscape at sunrise"' \
-F 'model="doubao-seedance-1-5-pro"' \
-F 'seconds="4"' \
-F 'size="1920x1080"'
- lang: Python
label: Text-to-video (exact 1920x1080)
source: |
import os
import requests
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]},
data={
"prompt": "A slow cinematic camera push across a coastal landscape at sunrise",
"model": "doubao-seedance-2-0",
"seconds": "4",
"size": "1920x1080",
},
timeout=30,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Text-to-video (exact 1920x1080)
source: >
const form = new FormData();
form.append("prompt", "A slow cinematic camera push across a coastal
landscape at sunrise");
form.append("model", "doubao-seedance-1-5-pro");
form.append("seconds", "4");
form.append("size", "1920x1080");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
const result = await response.json();
console.log(result);
- lang: Shell
label: HTTPS reference image URLs (Seedance 2.0)
source: |
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string model=doubao-seedance-2-0 \
--form-string 'prompt=Use the subject in @Image1 and the setting in @Image2. Use a slow camera push-in and natural motion.' \
--form-string seconds=5 \
--form-string size=1280x720 \
--form-string input_reference=https://your-image-host/subject.png \
--form-string input_reference=https://your-image-host/setting.png
- lang: Python
label: HTTPS reference image URLs (Seedance 2.0)
source: |
import os
import requests
fields = [
("model", (None, "doubao-seedance-2-0")),
(
"prompt",
(
None,
"Use the subject in @Image1 and the setting in @Image2. Use a "
"slow camera push-in and natural motion."
),
),
("seconds", (None, "5")),
("size", (None, "1280x720")),
("input_reference", (None, "https://your-image-host/subject.png")),
("input_reference", (None, "https://your-image-host/setting.png")),
]
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
},
files=fields,
timeout=120,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: HTTPS reference image URLs (Seedance 2.0)
source: >
const form = new FormData();
form.append("model", "doubao-seedance-2-0");
form.append(
"prompt",
"Use the subject in @Image1 and the setting in @Image2. Use a slow " +
"camera push-in and natural motion.",
);
form.append("seconds", "5");
form.append("size", "1280x720");
form.append("input_reference",
"https://your-image-host/subject.png");
form.append("input_reference",
"https://your-image-host/setting.png");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
if (!response.ok) {
throw new Error(await response.text());
}
console.log(await response.json());
- lang: Shell
label: HTTPS reference video (Seedance 2.0)
source: |
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=doubao-seedance-2-0' \
--form-string 'prompt=Follow the camera movement and action in @Video1. Preserve the direction and pace of the motion.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form-string 'reference_videos=https://your-media-host/reference.mp4'
- lang: Python
label: HTTPS reference video (Seedance 2.0)
source: |
import os
import requests
prompt = (
"Follow the camera movement and action in @Video1. Preserve the "
"direction and pace of the motion."
)
fields = [
("model", (None, "doubao-seedance-2-0")),
("prompt", (None, prompt)),
("seconds", (None, "5")),
("size", (None, "1280x720")),
("reference_videos", (None, "https://your-media-host/reference.mp4")),
]
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
},
files=fields,
timeout=120,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: HTTPS reference video (Seedance 2.0)
source: >
const form = new FormData();
form.append("model", "doubao-seedance-2-0");
form.append(
"prompt",
"Follow the camera movement and action in @Video1. Preserve the " +
"direction and pace of the motion.",
);
form.append("seconds", "5");
form.append("size", "1280x720");
form.append("reference_videos",
"https://your-media-host/reference.mp4");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
if (!response.ok) {
throw new Error(await response.text());
}
console.log(await response.json());
- lang: Shell
label: HTTPS reference audio with an image (Seedance 2.0)
source: |
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string model=doubao-seedance-2-0 \
--form-string 'prompt=Animate the subject in @Image1 to the rhythm of @Audio1. Preserve the subject appearance and use a fixed camera.' \
--form-string seconds=5 \
--form-string size=1280x720 \
--form-string reference_audios=https://your-media-host/reference.mp3 \
--form-string input_reference=https://your-image-host/subject.png
- lang: Python
label: HTTPS reference audio with an image (Seedance 2.0)
source: |
import os
import requests
fields = [
("model", (None, "doubao-seedance-2-0")),
(
"prompt",
(
None,
"Animate the subject in @Image1 to the rhythm of @Audio1. "
"Preserve the subject appearance and use a fixed camera."
),
),
("seconds", (None, "5")),
("size", (None, "1280x720")),
("reference_audios", (None, "https://your-media-host/reference.mp3")),
("input_reference", (None, "https://your-image-host/subject.png")),
]
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
},
files=fields,
timeout=120,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: HTTPS reference audio with an image (Seedance 2.0)
source: >
const form = new FormData();
form.append("model", "doubao-seedance-2-0");
form.append(
"prompt",
"Animate the subject in @Image1 to the rhythm of @Audio1. Preserve the " +
"subject appearance and use a fixed camera.",
);
form.append("seconds", "5");
form.append("size", "1280x720");
form.append("reference_audios",
"https://your-media-host/reference.mp3");
form.append("input_reference",
"https://your-image-host/subject.png");
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
if (!response.ok) {
throw new Error(await response.text());
}
console.log(await response.json());
- lang: Shell
label: Uploaded reference media (Seedance 2.5)
source: |
curl \
https://api.cometapi.com/v1/videos \
-H "Authorization: Bearer $COMETAPI_KEY" \
--form-string 'model=seedance-2-5' \
--form-string 'prompt=Use the subject in @Image1 and the setting in @Image2. Follow the motion in @Video1 and the rhythm of @Audio1.' \
--form-string 'seconds=5' \
--form-string 'size=1280x720' \
--form 'input_reference=@/path/to/subject.png;type=image/png' \
--form 'input_reference=@/path/to/setting.png;type=image/png' \
--form 'reference_videos=@/path/to/reference.mp4;type=video/mp4' \
--form 'reference_audios=@/path/to/reference.mp3;type=audio/mpeg'
- lang: Python
label: Uploaded reference media (Seedance 2.5)
source: |
import os
from contextlib import ExitStack
import requests
prompt = (
"Use the subject in @Image1 and the setting in @Image2. Follow the "
"motion in @Video1 and the rhythm of @Audio1."
)
with ExitStack() as stack:
fields = [
("model", (None, "seedance-2-5")),
("prompt", (None, prompt)),
("seconds", (None, "5")),
("size", (None, "1280x720")),
(
"input_reference",
(
"subject.png",
stack.enter_context(
open("/path/to/subject.png", "rb")
),
"image/png",
),
),
(
"input_reference",
(
"setting.png",
stack.enter_context(
open("/path/to/setting.png", "rb")
),
"image/png",
),
),
(
"reference_videos",
(
"reference.mp4",
stack.enter_context(
open("/path/to/reference.mp4", "rb")
),
"video/mp4",
),
),
(
"reference_audios",
(
"reference.mp3",
stack.enter_context(
open("/path/to/reference.mp3", "rb")
),
"audio/mpeg",
),
),
]
response = requests.post(
"https://api.cometapi.com/v1/videos",
headers={
"Authorization": "Bearer " + os.environ["COMETAPI_KEY"]
},
files=fields,
timeout=120,
)
response.raise_for_status()
print(response.json())
- lang: JavaScript
label: Uploaded reference media (Seedance 2.5)
source: |
import { readFile } from "node:fs/promises";
const form = new FormData();
form.append("model", "seedance-2-5");
form.append(
"prompt",
"Use the subject in @Image1 and the setting in @Image2. Follow the " +
"motion in @Video1 and the rhythm of @Audio1.",
);
form.append("seconds", "5");
form.append("size", "1280x720");
form.append(
"input_reference",
new Blob([await readFile("/path/to/subject.png")], {
type: "image/png",
}),
"subject.png",
);
form.append(
"input_reference",
new Blob([await readFile("/path/to/setting.png")], {
type: "image/png",
}),
"setting.png",
);
form.append(
"reference_videos",
new Blob([await readFile("/path/to/reference.mp4")], {
type: "video/mp4",
}),
"reference.mp4",
);
form.append(
"reference_audios",
new Blob([await readFile("/path/to/reference.mp3")], {
type: "audio/mpeg",
}),
"reference.mp3",
);
const response = await fetch("https://api.cometapi.com/v1/videos", {
method: "POST",
headers: { Authorization: `Bearer ${process.env.COMETAPI_KEY}` },
body: form,
});
if (!response.ok) {
throw new Error(await response.text());
}
console.log(await response.json());
components:
schemas:
CreateVideoResponse:
type: object
required:
- id
- object
- model
- status
- progress
- created_at
properties:
id:
type: string
description: Task id. Use it as the path parameter for GET /v1/videos/{id}.
task_id:
type: string
description: Alias of id returned for compatibility. The value matches id.
object:
type: string
description: Object type, always video.
model:
type: string
description: Echo of the requested model id.
status:
type: string
description: Initial task status. Newly created tasks are returned as queued.
enum:
- queued
- in_progress
- completed
- failed
- error
progress:
type: integer
minimum: 0
maximum: 100
description: Completion percentage. 0 at creation.
created_at:
type: integer
description: Task creation time as a Unix timestamp in seconds.
additionalProperties: true
ErrorResponse:
description: >-
Error body. The endpoint returns one of two shapes depending on where
the validation fails.
oneOf:
- type: object
properties:
code:
type:
- string
- 'null'
description: Short error code such as invalid_request or InvalidParameter.
message:
type: string
description: Human-readable error message.
required:
- message
additionalProperties: true
- type: object
properties:
error:
type: object
properties:
code:
type:
- string
- 'null'
description: Error code that identifies the request failure.
message:
type: string
description: Description of the request failure.
type:
type: string
description: Error category, for example comet_api_error.
required:
- message
- type
additionalProperties: true
description: Error details for a request that could not be processed.
required:
- error
additionalProperties: true
securitySchemes:
bearerAuth:
type: http
scheme: bearer
description: Bearer token authentication. Use your CometAPI key.
````