Wan 2.7 VideoEdit API on Novita AI: How to Edit Videos with AI

Wan 2.7 VideoEdit on Novita AI is the right endpoint when you already have footage and want the model to restyle or rewrite the scene without rebuilding motion from scratch. You submit a source video to POST https://api.novita.ai/v3/async/wan2.7-videoedit, get back a task_id, and then poll GET /v3/async/task-result until the edited clip is ready. This guide shows the exact request shape, when to add reference images, and the implementation details that matter before you wire it into production.

When Wan 2.7 VideoEdit Is the Right Tool

Use Wan 2.7 VideoEdit when the timing and camera movement in your source clip are already good enough, and you want AI to change what the viewer sees rather than how the shot is blocked.

Typical fits:

• You have a live-action clip and want to convert it into an anime, cinematic, or stylized render.
• You need to change wardrobe, environment, props, or atmosphere while preserving the original motion arc.
• You want to apply a prompt-guided transformation to footage and optionally ground the look with a reference image.

It is not the right endpoint when:

• You need net-new motion from text alone. Use Wan 2.7 T2V instead.
• You want to animate a still image. Use Wan 2.7 I2V instead.
• You need multi-character role-play with named reference slots across a generated scene. Use Wan 2.7 R2V instead.

That distinction matters because VideoEdit starts from an input clip. If the original motion is wrong, the model will not fix the choreography for you.

Verified Endpoint and Workflow

Wan 2.7 VideoEdit on Novita AI uses one submission endpoint and the shared async task-result endpoint:

Field	Value
Submit endpoint	POST https://api.novita.ai/v3/async/wan2.7-videoedit
Result polling	GET https://api.novita.ai/v3/async/task-result?task_id=<id>
Auth header	Authorization: Bearer $NOVITA_API_KEY
Content type	application/json
Official docs	Wan 2.7 VideoEdit API reference

The API is asynchronous. A successful submit call returns a task_id, not the finished video URL. Your application should persist that task ID and build polling or background-job logic around it.

Step 1: Get a Novita AI API Key

Create a key from Novita AI key management and keep it in an environment variable:

export NOVITA_API_KEY="your_api_key_here"

Do not hard-code the key in browser code, mobile apps, or checked-in config files.

Step 2: Understand the Request Shape

Wan 2.7 VideoEdit uses a flat JSON body. The request does not nest fields under input or parameters.

At minimum, send:

• video_url
• prompt

The documented optional fields you will usually care about first are:

• reference_image_url for a look/style reference
• resolution
• duration
• audio_setting
• prompt_extend
• seed

Step 3: Submit Your First VideoEdit Request

This is the smallest practical request:

curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "prompt": "Turn this office hallway scene into a neon cyberpunk corridor, preserve the walking motion and camera path",
    "resolution": "720P",
    "duration": 5
  }'

Expected response:

{
  "task_id": "abc123..."
}

Nothing else is guaranteed at submit time. Treat the request as a job enqueue step, not a synchronous editing response.

Step 4: Poll the Task Result Endpoint

Use the returned task_id with the shared task-result API:

curl -s "https://api.novita.ai/v3/async/task-result?task_id=abc123..." \
  -H "Authorization: Bearer $NOVITA_API_KEY"

Build around these states:

Status	Meaning
TASK_STATUS_QUEUED	Accepted and waiting for execution
TASK_STATUS_PROCESSING	Editing is in progress
TASK_STATUS_SUCCEED	Edited video is ready
TASK_STATUS_FAILED	The task failed; inspect the response body

When the task succeeds, the response includes a videos array with the edited output URL and URL TTL. Download or move that asset promptly rather than treating the hosted URL as permanent storage.

Step 5: Add a Reference Image When You Need Tighter Visual Control

reference_image_url is optional, but it changes the editing behavior in useful ways.

Use it when:

• You want the final clip to follow a particular character look, costume, or palette.
• You want to steer the output toward a specific art direction instead of leaving everything to the text prompt.
• The source video motion is correct, but the scene identity is too loose with text-only guidance.

Example request with a reference image:

curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "reference_image_url": "https://example.com/reference-look.png",
    "prompt": "Transform the performer into the look and color palette of the reference image while keeping the same dance timing",
    "resolution": "1080P",
    "duration": 6,
    "audio_setting": "auto"
  }'

If your result keeps drifting, the usual fix is not a longer prompt. It is a tighter prompt plus a better reference image.

Key Parameters You Should Actually Care About

Parameter	Type	Required	What it does
video_url	string	Yes	Source video to edit
prompt	string	Yes	Describes the target transformation
reference_image_url	string	No	Reference image for look and style grounding
resolution	string	No	Output resolution, documented values include 720P and 1080P
duration	integer	No	Target output length in seconds; 0 keeps the full input video length
audio_setting	string	No	Controls audio generation behavior
prompt_extend	boolean	No	Lets the model expand short prompts automatically
seed	integer	No	Improves reproducibility across retries

Check the official parameter reference before assuming defaults. Video model fields change more often than text-model fields, and output constraints are easy to get wrong if you rely on memory.

Documented Limits and Practical Constraints

As of July 29, 2026, Novita’s official docs for Wan 2.7 VideoEdit document these boundaries:

• Supported resolutions: 720P and 1080P
• duration defaults to 0, which means the full input video length; documented explicit output duration range is 2 to 10 seconds when you set it
• Input video formats: mp4 and mov
• Input video size limit: up to 100 MB
• Reference image formats: jpg, jpeg, png, webp
• Reference image size limit: up to 20 MB
• Output video format: mp4

These constraints are easy to miss when you are building a generic media pipeline. The most common integration failure is sending a longer or larger source file than the endpoint accepts.

Two practical implications:

1. If you want the edited clip to preserve the source length, omit duration or set it to 0 rather than forcing a 2-10 second trim.
2. If you are testing prompts rapidly, use 720P first and move to 1080P only when the transformation is working.

Python Example: Submit and Poll

import os
import time
import requests

API_KEY = os.environ["NOVITA_API_KEY"]
BASE_URL = "https://api.novita.ai"
HEADERS = {
    "Authorization": f"Bearer {API_KEY}",
    "Content-Type": "application/json",
}


def submit_video_edit(
    video_url: str,
    prompt: str,
    reference_image_url: str | None = None,
    resolution: str = "720P",
    duration: int = 0,
    audio_setting: str = "auto",
    prompt_extend: bool = True,
    seed: int | None = None,
) -> str:
    payload = {
        "video_url": video_url,
        "prompt": prompt,
        "resolution": resolution,
        "duration": duration,
        "audio_setting": audio_setting,
        "prompt_extend": prompt_extend,
    }
    if reference_image_url:
        payload["reference_image_url"] = reference_image_url
    if seed is not None:
        payload["seed"] = seed

    resp = requests.post(
        f"{BASE_URL}/v3/async/wan2.7-videoedit",
        headers=HEADERS,
        json=payload,
        timeout=60,
    )
    resp.raise_for_status()
    return resp.json()["task_id"]


def poll_result(task_id: str, interval: int = 5, timeout: int = 300) -> dict:
    deadline = time.time() + timeout
    while time.time() < deadline:
        resp = requests.get(
            f"{BASE_URL}/v3/async/task-result",
            headers=HEADERS,
            params={"task_id": task_id},
            timeout=60,
        )
        resp.raise_for_status()
        data = resp.json()
        status = data.get("task", {}).get("status")

        if status == "TASK_STATUS_SUCCEED":
            return data
        if status == "TASK_STATUS_FAILED":
            reason = data.get("task", {}).get("reason", "unknown")
            raise RuntimeError(f"Task {task_id} failed: {reason}")

        time.sleep(interval)

    raise TimeoutError(f"Task {task_id} did not complete within {timeout}s")


if __name__ == "__main__":
    task_id = submit_video_edit(
        video_url="https://example.com/source-clip.mp4",
        prompt="Change the street scene into a rainy retro-futurist city at night, preserve the original tracking shot",
        reference_image_url="https://example.com/reference-frame.png",
        resolution="720P",
        duration=0,
        seed=42,
    )
    print(f"Submitted task: {task_id}")

    result = poll_result(task_id)
    video = result["videos"][0]
    print("Edited video URL:", video["video_url"])
    print("URL TTL:", video["video_url_ttl"])

cURL Example with Shell Polling

TASK_ID=$(curl -s -X POST https://api.novita.ai/v3/async/wan2.7-videoedit \
  -H "Authorization: Bearer $NOVITA_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "video_url": "https://example.com/source-clip.mp4",
    "prompt": "Convert the clip into a hand-drawn anime city scene, preserve the running motion",
    "resolution": "720P",
    "duration": 0,
    "prompt_extend": true
  }' | jq -r '.task_id')

while true; do
  RESULT=$(curl -s "https://api.novita.ai/v3/async/task-result?task_id=$TASK_ID" \
    -H "Authorization: Bearer $NOVITA_API_KEY")
  STATUS=$(echo "$RESULT" | jq -r '.task.status')

  if [ "$STATUS" = "TASK_STATUS_SUCCEED" ]; then
    echo "$RESULT" | jq -r '.videos[0].video_url'
    break
  fi

  if [ "$STATUS" = "TASK_STATUS_FAILED" ]; then
    echo "$RESULT"
    break
  fi

  sleep 5
done

If you are integrating from a backend service, wrap this polling loop in a worker rather than holding open a user request for the full generation window.

Pricing, Credits, and What to Verify Before Estimating Cost

Novita AI exposes pricing for video models on its model and pricing pages, but those numbers can change. For Wan 2.7 VideoEdit, verify current rates directly from the Novita AI pricing page and the model entry linked from the official docs before publishing customer-facing cost estimates.

For engineering planning, the safer assumption is:

• Cost scales with the generated clip settings, not just with one flat request fee.
• 1080P runs are the wrong baseline for iteration.
• Shorter clips are easier to validate and cheaper to debug.

If you are building internal tooling, treat pricing lookup as a configuration concern, not a constant embedded in code.

Common Integration Mistakes

Sending raw uploads instead of a reachable URL. The documented request shape expects URL-based media inputs. Make sure your source clip is already available at a stable URL your server can reference.

Using VideoEdit for motion changes. VideoEdit is a transformation endpoint, not a choreography endpoint. If the original movement is wrong, regenerate with T2V or I2V.

Mixing up source-video and reference-image limits. The source video is the larger asset: mp4/mov, up to 100 MB. The smaller 20 MB limit applies to reference_image_url, not video_url.

Polling too aggressively. Hitting the task-result endpoint every second is unnecessary for multi-second video jobs. A 5-10 second interval is usually a better starting point.

Ignoring URL TTL. The result URL is temporary. Persist the asset promptly if the edited clip matters downstream.

Skipping prompt specificity. “Make it better” is not an editing prompt. Describe the target style, environment, subject treatment, and what motion should remain unchanged.

Which Wan 2.7 Endpoint Should You Choose?

Use this quick rule:

• Choose VideoEdit when you already have a source video.
• Choose I2V when you have a source image or want continuation from a still-led workflow.
• Choose T2V when you only have text.
• Choose R2V when identity consistency and reference-character control matter more than editing an existing clip.

That separation is what keeps your integration simple. Teams often overuse text-to-video for jobs that are really prompt-based editing problems.

FAQ

What is the Novita AI endpoint for Wan 2.7 VideoEdit?

POST https://api.novita.ai/v3/async/wan2.7-videoedit. It returns a task_id, then you poll GET https://api.novita.ai/v3/async/task-result?task_id=<id> for completion.

Can I provide a reference image together with the source video?

Yes. The documented request shape supports an optional reference_image_url alongside video_url and prompt, which is useful for steering the final look more tightly.

What video length does Wan 2.7 VideoEdit support on Novita AI?

As documented on July 29, 2026, duration defaults to 0, which means the full input video length. If you explicitly set duration, the documented range is 2-10 seconds.

Does Wan 2.7 VideoEdit accept large source videos?

Yes, within the documented limit. The official docs list mp4/mov input up to 100 MB. The separate 20 MB limit applies to the optional reference image.

Should I use Wan 2.7 VideoEdit or Wan 2.7 I2V?

Use VideoEdit if you already have a clip and want to transform it. Use I2V if your starting point is a still image or an image-led workflow.

Recommended articles

• Wan 2.7 on Novita AI: Text-to-Video vs Image-to-Video vs Reference-to-Video
• Kling O1 on Novita AI: T2V, I2V, Ref2V, and Video Edit Modes
• PixVerse V4.5 Quick Start for Text-to-Video and Image-to-Video Generation