Building Short Midjourney V1 Videos with an Image-to-Video API

Midjourney’s V1 video model is designed around a straightforward workflow: start with one still image and turn it into a short animated clip. The source image can come from Midjourney or from an externally hosted URL.

The default output is roughly five seconds long. Clips can be extended in four-second increments to approximately 21 seconds, and the result is delivered as an MP4. This makes V1 useful for animated stills, product loops, stylized social content, and short visual experiments rather than long-form cinematic sequences.

What V1 Actually Does

Midjourney V1 is an image-to-video model. It prioritizes preserving the source image’s visual identity, including its color palette, brushwork, subject, and overall mood.

The main characteristics are:

• Base clip length of approximately five seconds.
• Extensions in four-second increments, up to a documented limit of roughly 21 seconds.
• Automatic or manual animation modes.
• Low- and high-motion controls through --motion low and --motion high.
• Configurable batch size, looping, and end frames.
• MP4 output.
• Primarily SD output at 480p, with HD output at 720p available through the appropriate model or video-type parameter.
• A quality and resolution tradeoff aimed at quick iteration, web content, and social media rather than full cinematic production.

The practical implication is that the starting image matters more than it would in a text-to-video workflow. A clear subject, deliberate composition, and usable aspect ratio give the model less ambiguity to resolve.

For programmatic access, I use CometAPI’s unified REST interface, which exposes the Midjourney V1 video capability through /mj/submit/video. The request accepts an image URL in prompt, a videoType such as vid_1.1_i2v_480, a generation mode, and an animateMode.

Decide the Parameters Before Submitting

There are a few decisions worth making before writing the request.

Starting image

External images need to be available at publicly reachable URLs. Choose an image with:

• A clear primary subject.
• Enough visual separation between foreground and background.
• A composition that works at the intended output aspect ratio.
• A subject whose expected movement is physically plausible.

Starting aspect ratio affects the final video dimensions and whether the result maps cleanly to SD or HD output.

Motion

Use low motion for subtle camera movement, restrained subject animation, or loop-friendly clips. High motion is more appropriate when the subject needs to travel or the scene contains more visible movement.

You can either let the model infer motion automatically or describe it explicitly in manual mode.

Duration and batch size

The default clip is approximately five seconds. Extensions add four seconds at a time, up to roughly 21 seconds.

The default batch size is four variants. For production jobs or cost-sensitive iteration, request one or two variants instead. A batch size of one is represented by bs: 1.

Resolution

V1 is primarily oriented around 480p SD output. HD output is 720p and requires the relevant documented video type or parameter. The examples below use vid_1.1_i2v_480.

Submit a Video Job

The smallest useful request includes:

• prompt: an image URL, optionally followed by a motion description.
• videoType: for example, vid_1.1_i2v_480.
• mode: usually "fast", or "relax" when supported by the plan.
• animateMode: "automatic" or "manual".

Here is a complete request:

curl --location --request POST 'https://api.cometapi.com/mj/submit/video' \
  --header 'Authorization: Bearer sk-YOUR_COMETAPI_KEY' \
  --header 'Content-Type: application/json' \
  --data-raw '{
    "prompt": "https://cdn.midjourney.com/example/0_0.png A peaceful seaside scene — camera slowly zooms out and a gull flies by",
    "videoType": "vid_1.1_i2v_480",
    "mode": "fast",
    "animateMode": "manual",
    "motion": "low",
    "bs": 1
  }'

The image URL and motion instruction are combined in the prompt field. In this example, manual animation is paired with low motion, a single output variant, and a slow zoom.

Submit and Poll from Python

The API is asynchronous, so the basic integration pattern is:

1. Submit the generation request.
2. Extract the returned job identifier.
3. Poll the status endpoint.
4. Download the video once the job reaches completed.

A minimal requests implementation looks like this:

import time
import requests

API_KEY = "sk-YOUR_COMETAPI_KEY"
BASE = "https://api.cometapi.com"
HEADERS = {"Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json"}

payload = {
    "prompt": "https://cdn.midjourney.com/example/0_0.png A calm city street — camera pans left, rain falling",
    "videoType": "vid_1.1_i2v_480",
    "mode": "fast",
    "animateMode": "manual",
    "motion": "low",
    "bs": 1
}

# Submit job
r = requests.post(f"{BASE}/mj/submit/video", json=payload, headers=HEADERS)
r.raise_for_status()
job = r.json()
job_id = job.get("id") or job.get("job_id")

# Poll for completion (example polling)
status_url = f"{BASE}/mj/status/{job_id}"
for _ in range(60):  # poll up to ~60 times
    s = requests.get(status_url, headers=HEADERS)
    s.raise_for_status()
    st = s.json()
    if st.get("status") == "completed":
        download_url = st.get("result", {}).get("video_url")
        print("Video ready:", download_url)
        break
    elif st.get("status") in ("failed", "error"):
        raise RuntimeError("Video generation failed: " + str(st))
    time.sleep(2)

For a production worker, I would move the polling loop into a job system, add request timeouts and retry handling, and persist the provider job ID rather than keeping it only in process memory.

Writing Motion Prompts

Motion prompts are natural-language instructions. I get more predictable results by keeping the movement description short and separating camera movement from subject movement.

Useful patterns include:

• "camera dolly left while the subject walks forward"
• "leaf falls from tree and drifts toward camera"
• "slow zoom in, slight parallax, 2x speed"
• "subtle motion, loopable, cinematic rhythm"

A more structured prompt can be written like this:

start_frame_url animate: "slow spiral camera, subject bobs gently, loopable", style: "film grain, cinematic, 2 fps tempo"

The useful progression is to state the action first, then add timing and stylistic constraints. Small iterations are more productive than stacking a long list of unrelated instructions.

Automatic versus manual animation

Automatic animation is useful when plausible motion is enough. The model infers how the scene should move and is usually the fastest way to test an image.

Manual animation is better when camera direction, subject movement, or choreography needs to be repeatable. It is also the better choice when the clip must align with live-action footage or a predefined sequence.

Extending and Looping Clips

A generated five-second clip can be extended by four seconds per operation, up to approximately 21 seconds. In the UI, this is exposed through an Extend control. Programmatically, wrappers generally expose an extend flag or a separate extend job referencing the original clip. The exact parameterized endpoints and controls depend on the API documentation.

Extensions should be treated as additional generation work, with costs similar to an initial generation.

For loops, reuse the starting frame as the ending frame or use the --loop parameter. For a different ending, provide another image URL through end and keep its aspect ratio compatible with the starting image. Midjourney also supports a --end parameter. Manual extension can help adjust the motion prompt when continuity starts to drift.

Batch size is another simple cost control. Since the default is four variants, setting bs: 1 is useful when the goal is a single production candidate rather than exploration.

Adding Audio After Generation

Midjourney V1 produces silent MP4 video. Audio is not generated natively, so voice, music, and effects need to be added afterward.

A practical audio pipeline usually has three parts:

1. Generate narration with a text-to-speech service such as ElevenLabs, Replica, or another voice-cloning/TTS provider.
2. Generate or source music and sound effects using tools such as MM Audio, Magicshot, or specialized SFX generators.
3. Mix the tracks in DaVinci Resolve, Premiere, Audacity, or a similar editor.

For timing-sensitive work, I would do the final mix in a DAW or video editor. That provides better control over dialogue timing, sound effects, background levels, and synchronization than trying to assemble everything through isolated API calls.

For a simple silent video plus speech track, ffmpeg is enough:

# Normalize audio length (optional), then combine:
ffmpeg -i video.mp4 -i speech.mp3 -c:v copy -c:a aac -shortest output_with_audio.mp4

For dialogue, music, and effects, render one mixed audio track first, then mux that track into the MP4 using the same approach.

Where V1 Fits

V1 is deliberately constrained: short clips, image-driven motion, and relatively modest control over long sequences. Those constraints are also what make it useful for fast iteration.

The strongest use cases are:

• Animated illustrations.
• Product hero loops.
• Short character movements.
• Stylized social clips.
• Loopable background visuals.
• Motion studies from existing still images.

It is less suitable for long continuous scenes, complex multi-shot narratives, or workflows that require precise cinematic camera rigs. The model is expected to improve over time in sequence length, fidelity, and camera control, but the current workflow is best treated as concise motion design built from a strong still frame.

---

Originally published at cometapi.com