> ## 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. # Create a MiniMax H3 video > Create a MiniMax H3 video task with text, reference media, or first and last frames through CometAPI Create a MiniMax H3 video from text, reference media, or first and last frames. Store the returned `id` to poll the task and download the completed video. `POST /v1/videos` uses `multipart/form-data`. Send controls as form fields and repeat each reference field once per media input. ## Choose an input mode | Goal | Required fields | Optional fields | | -------------------------------------- | -------------------------------------------------------------------------------------- | ------------------------------------ | | Text-to-video | `model=minimax-h3`, `prompt` | `seconds`, `size` | | Reference images | `model=minimax-h3`, `prompt`, one or more `input_reference` URLs or files | `seconds`, `size` | | Reference video URL, data URI, or file | `model=minimax-h3`, `prompt`, one or more `reference_videos` fields | `seconds`, `size` | | Reference audio with an image | `model=minimax-h3`, `prompt`, `input_reference`, one or more `reference_audios` fields | `seconds`, `size` | | First and last frame URLs | `model=minimax-h3`, `prompt`, `first_frame` | `last_frame`, `seconds`, `size` | | Uploaded first and last frames | `model=minimax-h3`, `prompt`, `first_frame` file | `last_frame` file, `seconds`, `size` | ## Use reference images Send reference images through `input_reference` as publicly accessible HTTPS URLs or uploaded files. For multiple images, repeat the field in image order, with one URL or file per field. Use all URLs or all files within this field. Send each URL separately rather than combining URLs into a comma-separated value. You can send up to nine PNG or JPEG reference images, whether you use URLs or uploaded files. Keep each uploaded image at or below 20 MiB. In the prompt, describe the visual details that the generated video should preserve. ## Use reference video and audio Send `reference_videos` and `reference_audios` as multipart text values or uploaded files, using the formats below. Repeat each field once per input, using only text values or only files within that field. Do not combine inputs into a comma-separated value. Different fields can use different input types, such as an image URL with an uploaded audio file. | Field | Input | Format | | ------------------ | ------------------------------------------------------------------- | ---------------------------------------------------- | | `reference_videos` | A direct, publicly accessible HTTPS MP4 URL or an uploaded MP4 file | MP4 with H.264 video; an AAC audio track is optional | | `reference_videos` | A complete Base64 data URI in a text field | `data:video/mp4;base64,` | | `reference_audios` | A direct, publicly accessible HTTPS MP3 URL or an uploaded MP3 file | MP3 | Send at most 12 reference inputs in total, including no more than three videos and three audio clips. Each video or audio clip must be 2–15 seconds. The combined video duration and combined audio duration must each be at or below 15 seconds. Pair reference audio with at least one image through `input_reference`. Describe the motion, timing, or sound that the generated video should follow. Keep each uploaded MP4 at or below 50 MiB and each uploaded MP3 at or below 15 MiB. One MiB is 1024 × 1024 bytes. The request samples at the top of this page show MP4 URLs, MP4 data URIs, and MP3 URLs paired with an image. ### Upload a reference video Upload an MP4 file to guide the shot structure and motion: ```bash theme={null} curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Follow the uploaded reference video shot structure and motion. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form 'reference_videos=@/path/to/reference.mp4;type=video/mp4' ``` ### Upload reference audio with an image Pair a reference image URL with an uploaded MP3 file: ```bash theme={null} curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Animate the reference image and synchronize the motion with the uploaded reference audio. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form-string 'input_reference=https://your-image-host/reference.png' \ --form 'reference_audios=@/path/to/reference.mp3;type=audio/mpeg' ``` ## Set the first and last frames Send `first_frame` for the opening image and optionally one `last_frame` for the ending image. Each field accepts one direct, publicly accessible HTTPS PNG URL or one uploaded PNG file. Keep each uploaded PNG at or below 20 MiB (20 × 1024 × 1024 bytes). Do not combine frame fields with reference image, video, or audio fields. Use a separate request for frame-based generation. The service can normalize the final output dimensions when you provide first or last frames. Continue to send `size` in `WxH` form. Store the returned `id`. Poll the task until `status` is `completed` or `failed`. When the task is completed, download the video content. ## Set duration and size Set `seconds` to an integer from `5` through `15`. The default is `5` seconds. Choose a resolution and aspect ratio from the table, then send the corresponding **Request size** value as `size` in `WxH` form. The service can normalize the final output dimensions based on the requested size and supplied reference media. | Resolution | Aspect ratio | Request size | | ---------- | ------------ | ------------ | | `768P` | `21:9` | `1536x672` | | `768P` | `16:9` | `1344x768` | | `768P` | `4:3` | `1024x768` | | `768P` | `1:1` | `768x768` | | `768P` | `3:4` | `768x1024` | | `768P` | `9:16` | `768x1344` | | `2K` | `21:9` | `2912x1280` | | `2K` | `16:9` | `2544x1456` | | `2K` | `4:3` | `1920x1440` | | `2K` | `1:1` | `1440x1440` | | `2K` | `3:4` | `1440x1920` | | `2K` | `9:16` | `1440x2560` | ## Task flow Send the multipart form request and store the returned `id`. Call [Retrieve a MiniMax H3 video](./retrieve) until `status` is `completed` or `failed`. When the task is `completed`, call [Download MiniMax H3 video content](./retrieve-content) to save the MP4 file. ## OpenAPI ````yaml api/openapi/video/minimax-h3/post-create.openapi.json POST /v1/videos openapi: 3.1.0 info: title: MiniMax H3 Video Create API version: 1.0.0 description: >- Create an asynchronous MiniMax H3 video task from text, reference media, or first and last frames through CometAPI. Send the request as multipart/form-data, then use the returned id to retrieve the task and download its completed MP4 file. servers: - url: https://api.cometapi.com security: - bearerAuth: [] paths: /v1/videos: post: summary: Create a MiniMax H3 video task description: >- Create a MiniMax H3 video task from a text prompt, reference images, reference video or audio, or first and last frames. Repeat input_reference with one publicly accessible HTTPS image URL or uploaded image file per field, up to nine images. Use all URLs or all files within input_reference. Send size in WxH form. The service can normalize the final output dimensions. operationId: minimax_h3_create_video requestBody: required: true content: multipart/form-data: schema: $ref: '#/components/schemas/MiniMaxH3CreateRequest' encoding: input_reference: contentType: text/plain, image/png, image/jpeg style: form explode: true reference_videos: style: form explode: true contentType: text/plain, video/mp4 reference_audios: style: form explode: true contentType: text/plain, audio/mpeg first_frame: style: form last_frame: style: form examples: text_2544x1456: summary: Text-to-video at 2544x1456 value: model: minimax-h3 prompt: >- A paper boat glides across a still pond, daylight, locked camera, no text. seconds: 5 size: 2544x1456 text_1344x768: summary: Text-to-video at 1344x768 value: model: minimax-h3 prompt: >- A cinematic view of clouds moving over green mountains, locked camera, no text. seconds: 5 size: 1344x768 url_reference_image: summary: HTTPS reference images at 1344x768 value: model: minimax-h3 prompt: >- The referenced characters walk together through a city street. Preserve their appearance and use natural motion. No text. seconds: 5 size: 1344x768 input_reference: - https://your-image-host/reference-1.png - https://your-image-host/reference-2.jpg uploaded_reference_images: summary: Uploaded reference images value: model: minimax-h3 prompt: >- The uploaded reference characters walk together through a city street. Preserve their appearance and use natural motion. No text. seconds: 5 size: 2544x1456 input_reference: - '@/path/to/reference-1.png' - '@/path/to/reference-2.jpg' https_reference_video: summary: HTTPS MP4 reference video value: model: minimax-h3 prompt: >- Follow the reference clip's shot structure and motion. No text. seconds: 5 size: 1344x768 reference_videos: - https://your-media-host/reference.mp4 https_reference_audio: summary: HTTPS MP3 reference audio with an image value: model: minimax-h3 prompt: >- Animate the reference image and synchronize the motion with the reference audio. No text. seconds: 5 size: 1344x768 reference_audios: - https://your-media-host/reference.mp3 input_reference: https://your-image-host/reference.png https_first_last_frames: summary: HTTPS first and last frames value: model: minimax-h3 prompt: >- Move naturally from the opening frame to the ending frame. No text. seconds: 5 size: 1344x768 first_frame: https://your-image-host/first-frame.png last_frame: https://your-image-host/last-frame.png uploaded_first_last_frames: summary: Uploaded first and last frames value: model: minimax-h3 prompt: >- Move naturally from the uploaded opening frame to the uploaded ending frame. No text. seconds: 5 size: 1344x768 first_frame: last_frame: uploaded_reference_video: summary: Uploaded MP4 reference video value: model: minimax-h3 prompt: >- Follow the uploaded reference video shot structure and motion. No text. seconds: 5 size: 1344x768 reference_videos: - '@/path/to/reference.mp4' uploaded_reference_audio_with_image: summary: Uploaded MP3 reference audio with an image value: model: minimax-h3 prompt: >- Animate the reference image and synchronize the motion with the uploaded reference audio. No text. seconds: 5 size: 1344x768 reference_audios: - '@/path/to/reference.mp3' input_reference: https://your-image-host/reference.png responses: '200': description: >- Task created. Store the returned id and use it in retrieve and content requests. content: application/json: schema: $ref: '#/components/schemas/MiniMaxH3VideoTask' example: id: task_id: object: video model: minimax-h3 status: queued progress: 0 created_at: 1779938152 security: - bearerAuth: [] x-codeSamples: - lang: Shell label: Text-to-video at 2544x1456 source: |- curl https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=A paper boat glides across a still pond, daylight, locked camera, no text.' \ --form-string 'seconds=5' \ --form-string 'size=2544x1456' - lang: Python label: Text-to-video at 2544x1456 source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "A paper boat glides across a still pond, daylight, " "locked camera, no text.", ), ), ("seconds", (None, "5")), ("size", (None, "2544x1456")), ] 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: Text-to-video at 2544x1456 source: | const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "A paper boat glides across a still pond, daylight, " + "locked camera, no text.", ); form.append("seconds", "5"); form.append("size", "2544x1456"); 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: Text-to-video at 1344x768 source: |- curl https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=A cinematic view of clouds moving over green mountains, locked camera, no text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' - lang: Python label: Text-to-video at 1344x768 source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "A cinematic view of clouds moving over green mountains, " "locked camera, no text.", ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ] 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: Text-to-video at 1344x768 source: | const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "A cinematic view of clouds moving over green mountains, " + "locked camera, no text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); 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 images at 1344x768 source: | curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string model=minimax-h3 \ --form-string 'prompt=The referenced characters walk together through a city street. Preserve their appearance and use natural motion. No text.' \ --form-string seconds=5 \ --form-string size=1344x768 \ --form-string input_reference=https://your-image-host/reference-1.png \ --form-string input_reference=https://your-image-host/reference-2.jpg - lang: Python label: HTTPS reference images at 1344x768 source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "The referenced characters walk together through a city street. " "Preserve their appearance and use natural motion. No text." ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ("input_reference", (None, "https://your-image-host/reference-1.png")), ("input_reference", (None, "https://your-image-host/reference-2.jpg")), ] 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 images at 1344x768 source: > const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "The referenced characters walk together through a city street. " + "Preserve their appearance and use natural motion. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append("input_reference", "https://your-image-host/reference-1.png"); form.append("input_reference", "https://your-image-host/reference-2.jpg"); 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 images source: |- curl https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=The uploaded reference characters walk together through a city street. Preserve their appearance and use natural motion. No text.' \ --form-string 'seconds=5' \ --form-string 'size=2544x1456' \ --form 'input_reference=@/path/to/reference-1.png;type=image/png' \ --form 'input_reference=@/path/to/reference-2.jpg;type=image/jpeg' - lang: Python label: Uploaded reference images source: | import os from contextlib import ExitStack import requests prompt = ( "The uploaded reference characters walk together through a city street. " "Preserve their appearance and use natural motion. No text." ) with ExitStack() as stack: files = [ ( "input_reference", ( "reference-1.png", stack.enter_context( open("/path/to/reference-1.png", "rb") ), "image/png", ), ), ( "input_reference", ( "reference-2.jpg", stack.enter_context( open("/path/to/reference-2.jpg", "rb") ), "image/jpeg", ), ), ] response = requests.post( "https://api.cometapi.com/v1/videos", headers={ "Authorization": "Bearer " + os.environ["COMETAPI_KEY"] }, data={ "model": "minimax-h3", "prompt": prompt, "seconds": "5", "size": "2544x1456", }, files=files, timeout=120, ) response.raise_for_status() print(response.json()) - lang: JavaScript label: Uploaded reference images source: | import { readFile } from "node:fs/promises"; const firstReference = await readFile("/path/to/reference-1.png"); const secondReference = await readFile("/path/to/reference-2.jpg"); const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "The uploaded reference characters walk together through a city street. " + "Preserve their appearance and use natural motion. No text.", ); form.append("seconds", "5"); form.append("size", "2544x1456"); form.append( "input_reference", new Blob([firstReference], { type: "image/png" }), "reference-1.png", ); form.append( "input_reference", new Blob([secondReference], { type: "image/jpeg" }), "reference-2.jpg", ); 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 MP4 reference video source: |- curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Follow the reference clip shot structure and motion. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form-string 'reference_videos=https://your-media-host/reference.mp4' - lang: Python label: HTTPS MP4 reference video source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "Follow the reference clip shot structure and motion. " "No text.", ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ( "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 MP4 reference video source: | const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Follow the reference clip shot structure and motion. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); 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: MP4 reference video data URI source: |- curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Follow the reference clip shot structure and motion. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form 'reference_videos=<-;type=text/plain' \ < <(printf 'data:video/mp4;base64,'; openssl base64 -A -in /path/to/reference.mp4) - lang: Python label: MP4 reference video data URI source: | import base64 import os from pathlib import Path import requests video_base64 = base64.b64encode( Path("/path/to/reference.mp4").read_bytes() ).decode("ascii") fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "Follow the reference clip shot structure and motion. " "No text.", ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ( "reference_videos", (None, "data:video/mp4;base64," + video_base64), ), ] 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: MP4 reference video data URI source: | import { readFile } from "node:fs/promises"; const videoBase64 = ( await readFile("/path/to/reference.mp4") ).toString("base64"); const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Follow the reference clip shot structure and motion. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append( "reference_videos", `data:video/mp4;base64,${videoBase64}`, ); 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 MP3 reference audio with an image source: | curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string model=minimax-h3 \ --form-string 'prompt=Animate the reference image and synchronize the motion with the reference audio. No text.' \ --form-string seconds=5 \ --form-string size=1344x768 \ --form-string reference_audios=https://your-media-host/reference.mp3 \ --form-string input_reference=https://your-image-host/reference.png - lang: Python label: HTTPS MP3 reference audio with an image source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "Animate the reference image and synchronize the motion with the " "reference audio. No text." ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ("reference_audios", (None, "https://your-media-host/reference.mp3")), ("input_reference", (None, "https://your-image-host/reference.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 MP3 reference audio with an image source: > const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Animate the reference image and synchronize the motion with the " + "reference audio. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append("reference_audios", "https://your-media-host/reference.mp3"); form.append("input_reference", "https://your-image-host/reference.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 first and last frames source: |- curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Move naturally from the opening frame to the ending frame. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form-string 'first_frame=https://your-image-host/first-frame.png' \ --form-string 'last_frame=https://your-image-host/last-frame.png' - lang: Python label: HTTPS first and last frames source: | import os import requests fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "Move naturally from the opening frame to the ending " "frame. No text.", ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ( "first_frame", (None, "https://your-image-host/first-frame.png"), ), ( "last_frame", (None, "https://your-image-host/last-frame.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 first and last frames source: | const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Move naturally from the opening frame to the ending frame. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append( "first_frame", "https://your-image-host/first-frame.png", ); form.append( "last_frame", "https://your-image-host/last-frame.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 first and last frames source: |- curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Move naturally from the uploaded opening frame to the uploaded ending frame. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form 'first_frame=@/path/to/first-frame.png;type=image/png' \ --form 'last_frame=@/path/to/last-frame.png;type=image/png' - lang: Python label: Uploaded first and last frames source: | import os from contextlib import ExitStack import requests prompt = ( "Move naturally from the uploaded opening frame to the uploaded " "ending frame. No text." ) with ExitStack() as stack: files = { "first_frame": ( "first-frame.png", stack.enter_context( open("/path/to/first-frame.png", "rb") ), "image/png", ), "last_frame": ( "last-frame.png", stack.enter_context( open("/path/to/last-frame.png", "rb") ), "image/png", ), } response = requests.post( "https://api.cometapi.com/v1/videos", headers={ "Authorization": "Bearer " + os.environ["COMETAPI_KEY"] }, data={ "model": "minimax-h3", "prompt": prompt, "seconds": "5", "size": "1344x768", }, files=files, timeout=120, ) response.raise_for_status() print(response.json()) - lang: JavaScript label: Uploaded first and last frames source: | import { readFile } from "node:fs/promises"; const firstFrame = await readFile("/path/to/first-frame.png"); const lastFrame = await readFile("/path/to/last-frame.png"); const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Move naturally from the uploaded opening frame to the uploaded " + "ending frame. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append( "first_frame", new Blob([firstFrame], { type: "image/png" }), "first-frame.png", ); form.append( "last_frame", new Blob([lastFrame], { type: "image/png" }), "last-frame.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 MP4 reference video source: | curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string 'model=minimax-h3' \ --form-string 'prompt=Follow the uploaded reference video shot structure and motion. No text.' \ --form-string 'seconds=5' \ --form-string 'size=1344x768' \ --form 'reference_videos=@/path/to/reference.mp4;type=video/mp4' - lang: Python label: Uploaded MP4 reference video source: | import os from contextlib import ExitStack import requests prompt = ( "Follow the uploaded reference video shot structure and motion. No " "text." ) with ExitStack() as stack: fields = [ ("model", (None, "minimax-h3")), ("prompt", (None, prompt)), ("seconds", (None, "5")), ("size", (None, "1344x768")), ( "reference_videos", ( "reference.mp4", stack.enter_context( open("/path/to/reference.mp4", "rb") ), "video/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: Uploaded MP4 reference video source: | import { readFile } from "node:fs/promises"; const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Follow the uploaded reference video shot structure and motion. No " + "text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append( "reference_videos", new Blob([await readFile("/path/to/reference.mp4")], { type: "video/mp4", }), "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: Uploaded MP3 reference audio with an image source: | curl \ https://api.cometapi.com/v1/videos \ -H "Authorization: Bearer $COMETAPI_KEY" \ --form-string model=minimax-h3 \ --form-string 'prompt=Animate the reference image and synchronize the motion with the uploaded reference audio. No text.' \ --form-string seconds=5 \ --form-string size=1344x768 \ --form 'reference_audios=@/path/to/reference.mp3;type=audio/mpeg' \ --form-string input_reference=https://your-image-host/reference.png - lang: Python label: Uploaded MP3 reference audio with an image source: | import os from contextlib import ExitStack import requests with ExitStack() as stack: fields = [ ("model", (None, "minimax-h3")), ( "prompt", ( None, "Animate the reference image and synchronize the motion with " "the uploaded reference audio. No text." ), ), ("seconds", (None, "5")), ("size", (None, "1344x768")), ( "reference_audios", ( "reference.mp3", stack.enter_context(open("/path/to/reference.mp3", "rb")), "audio/mpeg", ), ), ("input_reference", (None, "https://your-image-host/reference.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: Uploaded MP3 reference audio with an image source: > import { readFile } from "node:fs/promises"; const form = new FormData(); form.append("model", "minimax-h3"); form.append( "prompt", "Animate the reference image and synchronize the motion with the " + "uploaded reference audio. No text.", ); form.append("seconds", "5"); form.append("size", "1344x768"); form.append( "reference_audios", new Blob([await readFile("/path/to/reference.mp3")], { type: "audio/mpeg", }), "reference.mp3", ); form.append("input_reference", "https://your-image-host/reference.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()); components: schemas: MiniMaxH3CreateRequest: type: object required: - model - prompt properties: model: type: string const: minimax-h3 default: minimax-h3 description: Model ID for this route. Use minimax-h3. prompt: type: string minLength: 1 description: >- Text that describes the scene, motion, camera behavior, and visual details that the video should preserve. default: >- A paper boat glides across a still pond, daylight, locked camera, no text. seconds: type: integer minimum: 5 maximum: 15 default: 5 description: >- Requested clip duration in whole seconds. Use an integer from 5 through 15. The default is 5. size: type: string pattern: ^[1-9][0-9]*x[1-9][0-9]*$ examples: - 1536x672 - 1344x768 - 1024x768 - 768x768 - 768x1024 - 768x1344 - 2912x1280 - 2544x1456 - 1920x1440 - 1440x1440 - 1440x1920 - 1440x2560 description: >- Requested frame size in WxH form. The service can normalize the final output dimensions based on the requested size and supplied reference media. input_reference: description: >- PNG or JPEG reference images. Repeat input_reference with one publicly accessible HTTPS image URL or uploaded image file per field. Send up to nine reference images, whether you use URLs or uploaded files. Use all URLs or all files within this field. Do not combine URLs into a comma-separated value. Keep each uploaded image at or below 20 MiB. Do not combine this field with first_frame or last_frame. Across images, videos, and audio, send at most 12 reference inputs. Each reference video or audio clip must be 2–15 seconds; keep the combined video duration and combined audio duration at or below 15 seconds each. 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: 9 items: type: string format: uri pattern: ^https:// description: One publicly accessible HTTPS reference image URL. - title: Image files type: array minItems: 1 maxItems: 9 items: type: string format: binary description: One uploaded reference image file. reference_videos: type: array minItems: 1 maxItems: 3 items: anyOf: - type: string format: uri pattern: ^(https://|data:video/mp4;base64,) example: https://your-media-host/reference.mp4 - type: string format: binary description: >- Reference video inputs. Repeat reference_videos with a direct publicly accessible HTTPS MP4 URL or an uploaded MP4 file. Use only text values or only files within this field. Each uploaded file can be up to 50 MiB. Send no more than three video inputs. A complete data:video/mp4;base64,... URI is also accepted as a text value. Use MP4 with H.264 video; an AAC audio track is optional. Do not combine this field with first_frame or last_frame. Across images, videos, and audio, send at most 12 reference inputs. Each reference video or audio clip must be 2–15 seconds; keep the combined video duration and combined audio duration at or below 15 seconds each. reference_audios: type: array minItems: 1 maxItems: 3 items: anyOf: - type: string format: uri pattern: ^https:// example: https://your-media-host/reference.mp3 - type: string format: binary description: >- Reference audio inputs. Repeat reference_audios with a direct publicly accessible HTTPS MP3 URL or an uploaded MP3 file. Use only text values or only files within this field. Each uploaded file can be up to 15 MiB. Send no more than three audio inputs. Pair reference audio with at least one reference image. Do not combine this field with first_frame or last_frame. Across images, videos, and audio, send at most 12 reference inputs. Each reference video or audio clip must be 2–15 seconds; keep the combined video duration and combined audio duration at or below 15 seconds each. first_frame: description: >- Opening frame input as one direct publicly accessible HTTPS PNG URL or one uploaded PNG file at or below 20 MiB (20 x 1024 x 1024 bytes). Do not combine frame fields with reference media fields. anyOf: - type: string format: uri pattern: ^https:// example: https://your-image-host/first-frame.png - type: string format: binary last_frame: description: >- Optional ending frame input, used with first_frame, as one direct publicly accessible HTTPS PNG URL or one uploaded PNG file at or below 20 MiB (20 x 1024 x 1024 bytes). Do not combine frame fields with reference media fields. anyOf: - type: string format: uri pattern: ^https:// example: https://your-image-host/last-frame.png - type: string format: binary dependentRequired: last_frame: - first_frame additionalProperties: false MiniMaxH3VideoTask: type: object required: - id - object - model - status - progress - created_at properties: id: type: string description: Task ID. Use this value as task_id in retrieve and content requests. example: task_id: type: string description: >- Compatibility alias for id. This field can be omitted from retrieve responses. example: object: type: string const: video description: Object type for the asynchronous video task. model: type: string const: minimax-h3 description: Model ID that the task uses. status: type: string enum: - queued - in_progress - completed - failed description: Task lifecycle status. Poll until the value is completed or failed. progress: type: integer minimum: 0 maximum: 100 description: Task progress as a coarse percentage. created_at: type: integer format: int64 description: Task creation time as a Unix timestamp in seconds. completed_at: type: integer format: int64 description: >- Unix timestamp returned by the platform. Use status, not this field, to decide when polling can stop. expires_at: type: integer format: int64 description: >- Result expiration time as a Unix timestamp in seconds when the task provides one. video_url: type: string format: uri description: Video delivery URL. This field appears on completed tasks. example: https://your-media-host/result.mp4 error: type: object description: Failure details. This field appears when the task fails. properties: message: type: string description: Human-readable failure description. code: type: string description: Failure code when the task provides one. additionalProperties: true additionalProperties: true securitySchemes: bearerAuth: type: http scheme: bearer description: Bearer authentication. Use your CometAPI API key. ````