3D to Video API

wavespeed-ai/3d-to-video

3D to Video turns a rough 3D viewport animation (a clay render or a blocking playblast from Blender, Unreal or similar) into a finished shot: the camera move and object placement follow your layout, and the look follows a reference image. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing.

Video Editing
Input

Drag & drop or click to upload

Drag & drop or click to upload

preview

Drag & drop or click to upload

Idle

$0.04per run·~25 / $1

ExamplesView all

A cozy log cabin among snow-dusted pine trees, a trodden path in fresh snow, golden winter light, photoreal cinematic shot.

A cozy log cabin among snow-dusted pine trees, a trodden path in fresh snow, golden winter light, photoreal cinematic shot.

Related Models

README

3D to Video

3D to Video turns a rough 3D viewport animation into a finished shot. Export a grey clay render or a simple blocking playblast from Blender, Unreal, or any 3D tool, add one image that shows the look you want, and get a video that moves exactly like your layout and looks like your image.

Why Choose This?

  • Your camera, your blocking The camera path, the timing, and where objects sit come from your layout and stay aligned through the shot.

  • Art direction from one image Palette, lighting, and materials follow the look image. No texturing, lighting, or rendering in the 3D tool.

  • Rough layouts work A blocking animation built from boxes, spheres, and cylinders is enough. A detailed clay render is not required.

  • Fast look development Try several looks for the same shot by changing only the image and the prompt.

Parameters

ParameterRequiredDescription
videoYesThe layout video: a 3D viewport animation (grey clay render or blocking playblast). It sets the camera move, the motion, and object placement. 24 fps works best.
imageYesThe look image. Take the first frame of the layout video and turn it into the finished look with any image model. Do not use the grey layout frame itself.
last_imageNoThe look of the shot's last frame, in the same style as image. Recommended for shots longer than about three seconds.
promptYesOne or two sentences describing the finished shot, matching the look image.
target_resolutionNoOutput resolution: 720p or 1080p. Default: 1080p. The layout's aspect ratio is preserved.
seedNoRandom seed for reproducible results.

How to Use

  1. Export the layout — Render a short viewport animation of your scene in grey, with the camera move you want.
  2. Make the look image — Take the first frame of that animation and restyle it with an image model into the final look.
  3. Write a short prompt — Describe the finished shot, not the layout.
  4. Choose target resolution and submit — Download the rendered video.

Pricing

Pricing is based on the layout video's duration and selected target_resolution.

Billed duration is rounded up to the next whole second, with a minimum billed duration of 3 seconds and a maximum billed duration of 120 seconds.

Output ResolutionPer 5sPer second
720p$0.20$0.04
1080p$0.50$0.10

Best Use Cases

  • Previsualization — Turn animatics and blocking into shots a client can judge.
  • Look development — Compare lighting and material directions on a locked camera.
  • Camera-accurate shots — Get a specific move that a text prompt cannot describe.
  • Indie and solo production — Skip texturing, lighting, and rendering for background shots.

Pro Tips

  • The look image decides the picture. If the result ignores your art direction, improve that image first.
  • Using the grey layout frame as the look image gives a grey result.
  • Keep the prompt short and about the finished shot. Do not write "clay", "3D", or the name of your 3D tool.
  • One look image holds the look for about three seconds. For longer shots add last_image: take the layout's last frame and restyle it the same way. Very long layouts still drift in the middle, so keep shots short.
  • The output has the layout's length and frame rate. The frame count is trimmed slightly to fit (for example 72 frames become 65).
  • No audio is generated.

Limits and Performance

  • Maximum processed layout length per job: 120 seconds.
  • Width and height are fitted to the chosen resolution in multiples of 64.

Related Models

Note:This website uses AI models provided by third parties. Documentation prices are for reference and may be outdated. The Generate button shows an estimate; the final task charge prevails.

3d To Video API — Quick start

Grab a WaveSpeedAI API key, then call POST https://api.wavespeed.ai/api/v3/wavespeed-ai/3d-to-video with your input as JSON. The endpoint returns a prediction id. Start polling the result endpoint around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. On completed, read output values from data.outputs. Examples for 3d To Video below.

HTTP example
set -euo pipefail

: "${WAVESPEED_API_KEY:?Set WAVESPEED_API_KEY}"

REQUEST_BODY=$(cat <<'JSON'
{
    "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "target_resolution": "1080p"
}
JSON
)

# 1. Submit the prediction.
SUBMIT_RESPONSE=$(curl --silent --show-error --fail-with-body \
  -X POST "https://api.wavespeed.ai/api/v3/wavespeed-ai/3d-to-video" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $WAVESPEED_API_KEY" \
  -d "$REQUEST_BODY")

TASK=$(printf '%s' "$SUBMIT_RESPONSE" | jq 'if has("data") then .data else . end')
PREDICTION_ID=$(printf '%s' "$TASK" | jq -r '.id')
if [ -z "$PREDICTION_ID" ] || [ "$PREDICTION_ID" = "null" ]; then
  printf 'Submission response did not contain a prediction id
' >&2
  exit 1
fi
RESULT_URL="https://api.wavespeed.ai/api/v3/predictions/$PREDICTION_ID/result"

# 2. Poll until the prediction finishes.
while true; do
  RESPONSE=$(curl --silent --show-error --fail-with-body "$RESULT_URL" \
    -H "Authorization: Bearer $WAVESPEED_API_KEY")
  RESULT=$(printf '%s' "$RESPONSE" | jq 'if has("data") then .data else . end')
  STATUS=$(printf '%s' "$RESULT" | jq -r '.status')
  case "$STATUS" in
    completed) printf '%s\n' "$RESULT" | jq '.outputs'; break ;;
    failed|cancelled|timeout|deleted) printf '%s\n' "$RESULT" | jq . >&2; exit 1 ;;
    *) sleep 2 ;;
  esac
done
Node.js example
const submitUrl = "https://api.wavespeed.ai/api/v3/wavespeed-ai/3d-to-video";
const apiKey = process.env.WAVESPEED_API_KEY;
if (!apiKey) throw new Error('Set WAVESPEED_API_KEY');

async function requestJson(url, options = {}) {
  const response = await fetch(url, options);
  if (!response.ok) throw new Error(await response.text());
  return response.json();
}

// 1. Submit the prediction.
const body = await requestJson(submitUrl, {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${apiKey}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
        "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
        "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
        "prompt": "A cinematic shot of a city at sunset, soft golden light",
        "target_resolution": "1080p"
}),
});
const task = body.data ?? body;
if (!task.id) throw new Error("Submission response did not contain a prediction id");
const resultUrl = `https://api.wavespeed.ai/api/v3/predictions/${task.id}/result`;

// 2. Poll until the prediction finishes.
while (true) {
  const resultBody = await requestJson(resultUrl, {
    headers: { "Authorization": `Bearer ${apiKey}` },
  });
  const result = resultBody.data ?? resultBody;
  if (result.status === "completed") {
    console.log(result.outputs);
    break;
  }
  if (["failed", "cancelled", "timeout", "deleted"].includes(result.status)) throw new Error(JSON.stringify(result));
  await new Promise(resolve => setTimeout(resolve, 2000));
}
Python example
import json
import os
import time
from urllib.request import Request, urlopen

api_key = os.environ["WAVESPEED_API_KEY"]
headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
payload = {
    "video": "https://interactive-examples.mdn.mozilla.net/media/cc0-videos/flower.mp4",
    "image": "https://interactive-examples.mdn.mozilla.net/media/cc0-images/painted-hand-298-332.jpg",
    "prompt": "A cinematic shot of a city at sunset, soft golden light",
    "target_resolution": "1080p"
}

def request_json(url, data=None):
    request = Request(url, data=data, headers=headers, method="POST" if data else "GET")
    with urlopen(request) as response:
        return json.load(response)

# 1. Submit the prediction.
body = request_json("https://api.wavespeed.ai/api/v3/wavespeed-ai/3d-to-video", json.dumps(payload).encode())
task = body.get("data", body)
if not task.get("id"):
    raise RuntimeError("Submission response did not contain a prediction id")
result_url = f"https://api.wavespeed.ai/api/v3/predictions/{task['id']}/result"

# 2. Poll until the prediction finishes.
while True:
    result_body = request_json(result_url)
    result = result_body.get("data", result_body)
    status = result.get("status")
    if status == "completed":
        print(result.get("outputs", []))
        break
    if status in {"failed", "cancelled", "timeout", "deleted"}:
        raise RuntimeError(result)
    time.sleep(2)

3d To Video API — Frequently asked questions

What is the 3d To Video API?

3d To Video is a WaveSpeedAI model for video editing, exposed as a REST API on WaveSpeedAI. 3D to Video turns a rough 3D viewport animation (a clay render or a blocking playblast from Blender, Unreal or similar) into a finished shot: the camera move and object placement follow your layout, and the look follows a reference image. Ready-to-use REST inference API, best performance, no coldstarts, affordable pricing. You can call it programmatically or try it from the playground above.

How do I call the 3d To Video API?

POST your input parameters to the model's REST endpoint (shown in the API tab of this playground) with your WaveSpeedAI API key in the Authorization header. Submission returns a prediction ID. Poll the result endpoint starting around every 2 seconds, increase the interval for long-running tasks, and stop on any terminal status. The playground generates Python, JavaScript, and cURL examples for submitting requests and polling results. Full request/response shape is documented at https://wavespeed.ai/docs/docs-api/wavespeed-ai/3d-to-video.

How much does 3d To Video cost per run or per second?

3d To Video starts at $0.04 per run or per second. That figure is the base price — the final charge scales with the parameters you set in the form (output size, length, count, references, or whatever knobs this model exposes), so a higher-quality or larger output costs more than a minimal one. The exact cost for your current input is shown live next to the Generate button before you submit, and the actual per-call charge is recorded on the prediction afterwards.

What inputs does 3d To Video accept?

Key inputs: `prompt`, `image`, `video`, `seed`, `last_image`, `target_resolution`. The full JSON schema (types, defaults, allowed values) is rendered above the Generate button and mirrored in the API reference at https://wavespeed.ai/docs/docs-api/wavespeed-ai/3d-to-video.

How do I get started with the 3d To Video API?

Sign up for a free WaveSpeedAI account to claim starter credits, copy your API key from /accesskey, then call the endpoint shown in the API tab of the playground. The playground also auto-generates a code sample in Python, JavaScript, or cURL for the parameters you've set.

Can I use 3d To Video outputs commercially?

Commercial usage rights depend on the model's license, set by its provider (WaveSpeedAI). Check the provider's applicable terms and WaveSpeedAI's Terms of Service before commercial use.

llms.txt — wavespeed-ai/3d-to-video for AI agents and LLMs