# Video Remake

> Video Remake is AI motion control and character swap: it replaces the people, pets, products or place in a short video with your images and keeps its motion.

Source: https://nodaro.ai/docs/developers/api/video-remake

The **Video Remake API** replaces the people, pets, products or location in a short video with your own reference images. The video keeps its motion, framing, timing and sound: the clip's audio is kept, and the result is as long as the clip. You quote a run for free, start it, and follow its job like any other.

Video Remake is what is often called AI motion control or character swap. To make one still character perform the moves of a video instead, use the [Motion Transfer](https://nodaro.ai/docs/nodes/video/motion-transfer) node.

Video Remake runs on Nodaro Cloud only. On a self-hosted install, every Video Remake route answers `404`. The routes take a bearer token. See [Authentication](https://nodaro.ai/docs/developers/api/authentication).

## Endpoints

| Method | Path | What it does | Cost |
| --- | --- | --- | --- |
| `POST` | `/v1/video-remake/estimate` | Quote a run. Nothing is created or reserved. | Free |
| `POST` | `/v1/video-remake` | Start a run. Answers `202 { jobId }`. Follow the job with `GET /v1/jobs/:id`. | The quoted run |
| `POST` | `/v1/video-remake/:jobId/full-quality/estimate` | Quote the Full Quality version of a draft run. Nothing is created or reserved. | Free |
| `POST` | `/v1/video-remake/:jobId/full-quality` | Finish a draft at 1080p, as a new job. See [Full Quality](#full-quality). | The quoted run |
| `GET` | `/v1/video-remake/style-choice` | Say, per engine, whether you choose a run's `style` or Nodaro fixed it as Motion, whether the engine takes style-only runs, and whether a Precise run takes an art style. Public: no sign-in needed. See [Style](#style). | Free |
| `GET` | `/v1/video-remake/advanced` | Say whether the Video Remake page shows its Advanced options. Public: no sign-in needed. See [Style](#style). | Free |

## The request body

Both routes take the same body.

| Field | What it does |
| --- | --- |
| `videoUrl` | Required. The source clip, from 4 to 30 seconds. |
| `roles` | Required. Up to 6 person roles, 1 location role, 3 pet roles and 3 product roles. See below. |
| `references` | Optional. Up to 5 fixed references: things the video should show that no role replaces. See [Fixed references](#fixed-references). |
| `prePrompt` | Optional. Your own words placed at the start of the prompt, before the role instructions. It has the same limit and `{role:N}` mentions as `postPrompt`. |
| `postPrompt` | Optional. Your own words for the model, up to 4,000 characters. Mention a role as `{role:N}`, where N counts from 1 over `roles`, empty roles included. |
| `preview` | Optional. `true` renders 4 seconds of the clip, from `previewStart`. |
| `previewStart` | Optional. Where the preview starts, in seconds. The default is 0. |
| `engine` | Optional. The engine: `"nodaro-prism"` (Nodaro Prism), the default, or `"nodaro-pulse"` (Nodaro Pulse). See [Engines](#engines). |
| `style` | Optional. How the run follows the clip: `"precise"`, the default, or `"motion"`. See [Style](#style). |
| `direction` | Optional, Nodaro Prism only. An art style, `{ style: "<id>" }`, where the id is one of the [Style](https://nodaro.ai/docs/nodes/creative-controls/style) picker catalog's. See [Art styles](#art-styles). |
| `motionLength` | Optional, Nodaro Pulse only. Where the clip is cut to whole seconds: `"cut-end"`, the default, or `"cut-start"`. |
| `resolution` | Optional. `"480p"`, the default, `"720p"` or `"1080p"`. On Nodaro Pulse, `"720p"`, its default, or `"1080p"`. |
| `draft` | Optional. Off by default, so a 480p run is a plain run. `true` makes a 480p draft, whose same take [Full Quality](#full-quality) can finish at 1080p later. `true` above 480p is refused. Nodaro Pulse has no draft. |
| `prepareReferences` | Optional. The default is `true`. See [Reference preparation](#reference-preparation). |
| `quality` | Deprecated. `"draft"` still works and means a 480p draft. Use `resolution` and `draft` instead. |
| `sessionId`, `origin` | Optional. The session to file the result in, and your app's origin label. |

A role names someone, something or the setting in the video, and takes 0 to 3 images of one subject or one place. A request takes at most 30 images in all.

- **A person:** `{ kind: "person", name?, images, body?, outfit?, hair? }`. `name` says who in the video, for example `"the woman dancing"`.
- **A pet:** `{ kind: "pet", name?, images, body?, coat? }`.
- **A product:** `{ kind: "product", name?, images, shape?, finish? }`.
- **The location:** `{ kind: "location", name?, images }`. The default name is `"the setting"`.

A person, pet or product role can leave `name` out, or send it empty. The role is then named by its first image, and matched to the subject in the video that fits it best. Such a role needs at least one image. A `name` is at most 200 characters. The roles of a trend run are always named.

Each trait (`body`, `outfit`, `hair`, `coat`, `shape`, `finish`) is `"new"`, the default, which takes it from your images, or `"original"`, which keeps it from the video.

A role with no images, empty or `null`, keeps that subject or place as in the video. At least one role with images, a reference, a `prePrompt` or `postPrompt`, or an art style is required. An art style counts only on a style-only run (see [Art styles](#art-styles)).

Any role can also take two settings that apply to a preview only. A full run ignores both.

- `previewName` is the name used instead of `name` in a preview.
- `inPreview: false` leaves the role out of a preview. Its images are not sent, prepared or charged. A `{role:N}` mention keeps its number and reads as the role's `previewName`, or else its `name`.

```json
{
"videoUrl": "https://example.com/clip.mp4",
"roles": [
{ "kind": "person", "name": "the woman dancing", "images": ["https://example.com/me.jpg"], "outfit": "original" }
],
"preview": true
}
```

## Engines
`engine` chooses the engine that makes the result. Leave it out to keep Nodaro Prism.

| Engine | Resolutions | Draft | Full Quality |
| --- | --- | --- | --- |
| `"nodaro-prism"`, Nodaro Prism (default) | 480p (the default), 720p, 1080p | At 480p, with `draft: true` | Re-renders a draft's own take at 1080p |
| `"nodaro-pulse"`, Nodaro Pulse | 720p (the default), 1080p | No | None: run it again at 1080p |

- **Nodaro Pulse** makes a new take guided by the clip and your images.
- `draft: true` on Nodaro Pulse is refused with `draft_unsupported`, and `"480p"` with `resolution_unsupported`.
- Nodaro Pulse renders whole seconds, so the clip is cut to whole seconds. `motionLength` says where: `"cut-end"` drops the fraction of a second at the end, and `"cut-start"` drops it at the start. Nodaro Prism ignores `motionLength`.
- A preview is 4 seconds from `previewStart` on both engines.
- Nodaro Pulse takes at most 10 images per run, across every role and fixed reference. More is refused with `too_many_images`. Nodaro Prism takes up to 30.
- The job records its engine in `input_data.engine`, and a completed job's output names it in `engine`.

## Style
`style` says how the run follows the clip. Leave it out to keep Precise.

- `"precise"`, the default, follows the clip exactly.
- `"motion"` follows the clip's movement and takes the looks of the people, pets and products from your images. It follows the clip more freely than Precise.

Both styles keep the clip's sound and length. Motion can cost a different amount than Precise. Send the same `style` to `POST /v1/video-remake/estimate` to see the exact price.

The job records the `style` you sent in `input_data.style`. The field is absent when you left `style` out, which means Precise. A trend run ignores `style`, because the trend decides it.

Nodaro can fix the style of an engine for everyone as Motion. Every run and estimate on that engine is then a Motion run, whatever `style` says. `GET /v1/video-remake/style-choice` says which, per engine, and needs no sign-in:

```json
{ "engines": { "nodaro-prism": "user", "nodaro-pulse": "precise" } }
```

Each value is `"user"` (you choose, as above), `"precise"` or `"flex"` (Motion, that is `style: "motion"`, fixed as above). `"precise"` changes no request. Nodaro's own apps run Precise on that engine and hide their style choice. Every run and estimate on that engine takes the `style` it sends, as on an engine answered `"user"`. Show a style choice in your app only for an engine answered `"user"`.

The same answer carries three more maps, each `{ "nodaro-prism": boolean, "nodaro-pulse": boolean }`:

- `styleOnly` says whether the engine takes style-only runs. See [Art styles](#art-styles).
- `preciseArtStyle` says whether a Precise run takes an art style on that engine.
- `preciseArtStyleAlone` says whether an art style alone is a Precise run's change on that engine, with no role, reference or prompt. It answers `false` until the engine takes such runs. Nodaro may run such a request as a Motion run, and this map does not say so. See [An art style on a Precise run](#art-styles).

All three follow the engine alone, so read them together with `engines`. Nodaro Pulse is always `false` in all three. A server from before them leaves them out: read that as `false` for every engine. On an engine answered `"flex"`, every run is a Motion run.

The answer can be up to a minute old. Trends are not affected.

**The Advanced options of the Video Remake page.** The Video Remake page offers two fields of the body, `prepareReferences` and `prePrompt`, only under its Advanced options. These options stay hidden unless Nodaro turns them on, with one setting for the whole page and every engine. `GET /v1/video-remake/advanced` needs no sign-in and answers `{ show: boolean }`, so an app built on this API can show or hide the same options. The answer describes the page only: every run and estimate takes `prepareReferences` and `prePrompt` whatever it says. The answer can be up to a minute old. The SDK has no method for it yet, so read it with `client.request()`.

While the way Nodaro prepares Motion runs for the engine limits the clip, a full Motion run of a clip over 27.9 seconds is refused with `clip_too_long_for_style`. On Nodaro Pulse, the length is counted after the clip is cut to whole seconds. A preview is not limited.

## Art styles
`direction: { style: "<id>" }` draws the video in an art style, such as `pop-art`. The id is one of the [Style](https://nodaro.ai/docs/nodes/creative-controls/style) picker catalog's. Only Nodaro Prism takes an art style. Nodaro Pulse refuses one with `400 art_style_needs_prism`.

**Restyling a whole clip (style only).** A Motion run (`style: "motion"`) may take an art style with nothing to swap: no role with images and no fixed reference. The run is still accepted, because the art style is its change. A `prePrompt` or `postPrompt` is still added. The run restyles the whole clip and keeps the people, the places, the motion and the sound.

- It is charged for what it runs: the base fee and the video, with no `privacy` part. A `referenceAudio` part appears only when Nodaro's setting for the engine runs that step, and a `prompt` part only when the setting has a language model write the prompt. Send the same body to `POST /v1/video-remake/estimate` to see the price.
- By default, a black-and-white art style comes out monochrome. Nodaro may instead run these the way it runs other art-style runs, priced as those are and not made monochrome.
- A preview takes the same path as its full run. A preview that leaves out every role with images (`inPreview: false`) takes its full run's path, and the art style counts as the preview's change.
- Offer it only where `GET /v1/video-remake/style-choice` answers `styleOnly: true` for the engine. While Nodaro Prism is answered `false`, an art style with nothing else to change is refused with `400 validation_error`. One with a `prePrompt` or `postPrompt` is accepted, but runs as any other art-style run.
- The run must still be Motion. An engine answered `"precise"` changes no request, so a Motion run there restyles the clip as on an engine answered `"user"`.

**An art style on a Precise run.** Where `GET /v1/video-remake/style-choice` answers `preciseArtStyle: true` for the engine, a Precise run also takes an art style. Nodaro may make it the way a Motion run is made, where an art style holds across the whole picture far more reliably. Then:

- The job still records the style you sent: `input_data.style` is absent, or `"precise"`. Reading the job back, or sending the same body again, asks for the same run.
- Its estimate, sent with the same body, its price, its Full Quality and its style-only behavior are those of a Motion run.
- With nothing else to change, it is accepted as a style-only run.
- `style-choice` does not show which applies. Read the estimate for what a run costs.
- Jobs made this way before the style was kept record `input_data.style: "motion"`.

Otherwise the run is made as Precise: the clip is edited and the people are swapped as Precise does, and the whole video is drawn in the art style. There:

- The art style is not a change on its own here. A Precise run with no role with images, no fixed reference, no `prePrompt` and no `postPrompt` is still refused with `400 validation_error`. To restyle a whole clip alone, use a Motion run (style only, above).
- The price changes only where Nodaro's setting for these runs first redraws the role pictures in the art style. The estimate, sent with the same body, shows it.
- The job records the art style in `input_data.direction`.
- Where `preciseArtStyle` is `false`, or a server from before it leaves it out, a Precise run with an art style is refused with `400 art_style_needs_flex`.

An id that is not in the catalog is refused with `400 unknown_art_style`, and a saved moodboard with `400 art_style_not_supported`. `400 art_style_needs_flex` also answers an art style on a trend run, and on a Motion run whose prompt Nodaro's setting makes Precise. That setting is not the forced style, and `style-choice` does not show it.

## Fixed references
`references` holds up to 5 things the video should show that no role replaces. Each one is `{ images, line }`:

- `images` holds 1 to 3 images of one thing.
- `line` says what the thing is, in 1 to 500 characters, for example `"the glass she drinks from"`.
- `{image}` in a line stands for that reference's first image, for example `"Use {image} for the sky"`. A line without `{image}` gets it added at the end.

References are sent as they are, never prepared. Their images count toward the limit of 30. A reference alone is enough for a run: no role needs images. A line cannot mention a role with `{role:N}`, because a line describes the thing itself.

## Reference preparation
Unless `prepareReferences` is `false`, each person, pet and product role's images are first made into one clean reference picture by an image model. The video is then made from those pictures.

- The preparation costs extra credits, shown as `breakdown.references` in the quote. They are charged when it runs, even if the video then fails.
- It adds about a minute.
- If the picture for a role cannot be made, that role uses your own images.
- Locations are not prepared.

Send `prepareReferences: false` to use your images as they are.

## Preparing the clip
Nodaro sets how the source clip is prepared for the video model, for each engine. For example, it decides whether faces are hidden first, and whether a clip the model refuses is retried once. A run cannot change it. A `faceMasking` field sent by an older client is accepted and ignored.

A completed job's output carries `privacy: { applied, reason }`. `applied` says whether the video was made from the prepared clip, and `reason` says why.

## The quote

`POST /v1/video-remake/estimate` answers `{ engine, totalCredits, expectedCredits, breakdown, privacyCredits?, settlesLower }`. The quote names two totals.

- `totalCredits` is what is held when the run starts.
- `expectedCredits` is what the run is expected to be charged. It is never above `totalCredits`. The run is charged what it actually costs.
- On Nodaro Prism, the model chooses the video's length, so the video is held at its longest output. It is expected to be charged for about the length of the clip in, and as much out. `settlesLower: true` says so: the final charge is expected to be lower than `totalCredits`, at about `expectedCredits`.
- On Nodaro Pulse, the two totals are equal and `settlesLower` is `false`. Nodaro Pulse renders exactly the length asked for.
- `engine` is the engine the quote is for.

`breakdown` names the parts of the quote, for display only:

| Part | What it is |
| --- | --- |
| `base` | The run itself. |
| `references` | The reference preparation. It is 0 when the preparation is off or there is nothing to prepare. |
| `motion` | What the video holds. On Nodaro Pulse, what the video costs. |
| `motionExpected` | What the video is expected to be charged, never above `motion`. Nodaro Prism only. |
| `privacy` | Preparing the clip, when the engine's setting does. It is in both totals when it always runs, and in neither when it is the retry below. |
| `prompt` | The prompt a language model writes for the run, when the engine's setting asks for one. |
| `referenceAudio` | Preparing the clip's sound for the video model, when the engine's setting runs that step. |

`motion` and `motionExpected` are alternatives, so read the totals, never the sum of the breakdown.

When the engine's setting retries a refused clip, `privacyCredits` is the extra charge, made only if that retry runs. It is in neither total. Starting the run needs credits for both the hold and `privacyCredits`.

## Repeats

Send the same `Idempotency-Key` header, 8 to 200 characters, when you retry a run. A repeat within about 10 seconds answers `200 { jobId, deduped: true }` with an `X-Dedup-Hit: 1` header. A later repeat answers `202 { jobId }` with the first run's job. Either way, nothing new is started or charged. Without a key, every request is a new run.

## Full Quality
A finished Nodaro Prism **draft** can be finished at **Full Quality**. A draft is a Video Remake or trend run made at 480p with `draft: true`. Full Quality re-renders the same take at 1080p, fitted to the clip and given the clip's original audio. The result is a new job, linked to the draft, and the draft itself stays.

Only a draft has a Full Quality. A plain run, including a 480p run made without `draft: true`, is refused with `409 not_a_draft`. To finish a 480p take at 1080p later, make it with `draft: true`. Nodaro Pulse makes no drafts, so it has no Full Quality: run it again at 1080p instead. A Pulse Full Quality made before this change stays listed as a run of its own.

The quote's `kind` is `"same-take"`. An older server leaves `kind` out, which means the same. Full Quality is available for 7 days after the draft completed.

| Method | Path | What it does |
| --- | --- | --- |
| `POST` | `/v1/video-remake/:jobId/full-quality/estimate` | Quote it. Free: nothing is created or reserved. Answers `{ kind, totalCredits, breakdown, availableUntil }`. |
| `POST` | `/v1/video-remake/:jobId/full-quality` | Start it. Answers `202 { jobId }`. When this run's Full Quality is already running or done, it answers `200 { jobId, existing: true }`, and nothing new is started or charged. Takes an optional body `{ sessionId }`. |

`:jobId` is the job id of the draft. In the quote, `totalCredits` is `breakdown.base`, the Full Quality job's own steps, plus `breakdown.motionHd`, the 1080p render of the draft's take. `motionHd` is 0 when an earlier failed try of this draft already finished that render: the render is reused, and only the finishing is charged. `availableUntil` is when the 7 days end. The price depends on the draft, so quote it first.

There is one Full Quality per draft. The job is keyed by the draft, so a repeated or concurrent request answers the same job, and an `Idempotency-Key` is not used. A failed or cancelled try can be asked again a few times. The new job keeps the draft's `origin`, and `sessionId` files it in one of your sessions.

Every refusal comes before anything is charged. The body is `{ error: { code, message } }`.

| Status | `code` | When |
| --- | --- | --- |
| `401` | `unauthorized` | No authenticated user. |
| `402` | `insufficient_credits` | Your credits cannot cover it. Start only. In a workspace, the limit that refused it can answer instead: `budget_exceeded`, `member_cap_exceeded` or `user_allowance_exceeded`. |
| `404` | `not_found` | Not your job, or not a Video Remake run. Also a `sessionId` you cannot use, on the start only. |
| `409` | `not_completed` | The run has not finished. |
| `409` | `not_a_draft` | The run is not a Nodaro Prism draft. It is a plain run, including a 480p run made without `draft: true`, or a Nodaro Pulse run, which makes no drafts: run it again at 1080p. |
| `409` | `full_quality_pending` | Not final, so try again later. The body carries `retryable: true`. An earlier try's 1080p render of this draft is being reviewed, or has not started yet. |
| `409` | `full_quality_unavailable` | Final. The run cannot be finished at Full Quality: nothing was kept to re-render, its completion time cannot be read, or the 1080p finish refuses this draft. On the start only, also when every try failed, or no try can be started for this run. |
| `410` | `draft_expired` | More than 7 days after the draft completed, or the draft can no longer be finished at Full Quality. |
| `422` | `job_blocked` | The request was blocked by the deployment's job policy. Start only. |
| `503` | `job_read_failed` | The draft could not be read just now. The body carries `retryable: true`. Try again. |
| `503` | `estimate_unavailable` | The 1080p render cannot be quoted right now. Try again shortly. |
| `503` | `host_too_old` | This platform version cannot run Full Quality. |

Tell `full_quality_pending` from `full_quality_unavailable` by the code, not by the message.

## Errors

Every refusal comes before anything is charged. The body is `{ error: { code, message } }`.

| Status | `code` | When |
| --- | --- | --- |
| `400` | `validation_error` | The body is not valid: no role with images, no reference, no `prePrompt` or `postPrompt` and no art style (an art style counts only where `styleOnly` is `true`), more than 5 references, a reference with no image or more than 3, more roles of a kind than allowed, more than 3 images on a role, more than 30 images in all, `draft: true` at 720p or 1080p, a `prePrompt` or `postPrompt` over 4,000 characters, an invalid `origin`, or a `style` other than `"precise"` or `"motion"`. |
| `400` | `draft_unsupported` | `draft: true` with `engine: "nodaro-pulse"`, which has no draft. |
| `400` | `resolution_unsupported` | `resolution: "480p"` with `engine: "nodaro-pulse"`. |
| `400` | `output_format_unsupported` | A MOV output asked of `engine: "nodaro-pulse"`. Only a Nodaro Prism run can return one. |
| `400` | `too_many_images` | More than 10 images in a Nodaro Pulse run, across every role and fixed reference. |
| `400` | `raw_reference_token` | A role's `name` or `previewName`, a reference's `line`, the `prePrompt` or the `postPrompt` contains a raw reference token: `{image:`, `{video:` or `{audio:`, in any case. |
| `400` | `invalid_role_mention` | `prePrompt` or `postPrompt` mentions `{role:N}` with N outside 1 to the number of roles. Also any `{role:N}` in a reference's `line`. |
| `400` | `no_roles_in_preview` | A preview that would change nothing, judged on what it sends: no role kept in it that has images, no fixed reference, no `prePrompt` or `postPrompt` and no art style. A preview with every role left out still runs when it has a reference, a prompt or, where `styleOnly` is `true`, an art style. |
| `400` | `prompt_too_long` | The prompt would be too long. A `{role:N}` reads as the role's name when the role has no images, so prompts within 4,000 characters can still add up past the engine's limit. The limit of Nodaro Pulse is 8,000 characters. |
| `400` | `unsafe_url` | `videoUrl`, a role image or a reference image is not a public http or https address. |
| `400` | `video_unreadable` | The length of the clip could not be read. It is not a playable video. |
| `400` | `clip_out_of_range` | The clip is shorter than 4 seconds or longer than 30 seconds. |
| `400` | `clip_too_long_for_style` | `style: "motion"` only, while the way Nodaro prepares Motion runs for the engine limits the clip. A full run whose clip is over 27.9 seconds. The message is "This clip is too long for Motion. Use a shorter clip or choose Precise." |
| `400` | `prompt_parts_not_allowed` | The body sends `promptParts`. Only the Nodaro platform itself can send it, for a trend's prompt. |
| `400` | `prompt_style_not_allowed` | The body sends `promptStyle`. Only the Nodaro platform itself can send it. The wording of a run follows its `style`. |
| `400` | `preview_out_of_range` | A preview runs past the end of the clip. `previewStart` plus 4 must be at most the clip's length. |
| `400` | `unnamed_role_needs_picture` | A person, pet or product role with no `name` and no image. An unnamed role is named by its first image, so it needs one. |
| `400` | `art_style_needs_prism` | An art style with `engine: "nodaro-pulse"`, which takes none. |
| `400` | `art_style_needs_flex` | An art style on a Precise run where `preciseArtStyle` is not `true`, on a trend run, or on a Motion run whose prompt Nodaro's setting makes Precise. |
| `400` | `unknown_art_style` | `direction.style` is not an id of the Style picker catalog. |
| `400` | `art_style_not_supported` | `direction` names a saved moodboard, which a Video Remake run cannot take. |
| `400` | `role_name_required` | A trend run with a role that has no name. The roles of a trend are always named. |
| `401` | `unauthorized` | No authenticated user. |
| `402` | `insufficient_credits` | Your credits cannot cover the run. `POST /v1/video-remake` only. When the quote has a `privacyCredits`, the credits needed are the hold plus `privacyCredits`. In a workspace, the limit that refused it can answer instead: `budget_exceeded`, `member_cap_exceeded` or `user_allowance_exceeded`. |
| `404` | `not_found` | `sessionId` names a session you cannot use. `POST /v1/video-remake` only. |
| `422` | `job_blocked` | The request was blocked by the deployment's job policy. `POST /v1/video-remake` only. |
| `503` | `host_too_old` | This platform version cannot run Video Remake. |
| `503` | `estimate_unavailable` | The price cannot be quoted right now. Try again shortly. `/estimate` only. |

## From the SDK

`client.videoRemake` wraps every route. It is also importable as `@nodaro/sdk/video-remake`.

```ts
run(params: VideoRemakeParams, options?: { idempotencyKey?: string }): Promise<{ jobId: string; deduped?: boolean }>
estimate(params: VideoRemakeParams): Promise<VideoRemakeEstimate>
fullQualityEstimate(jobId: string): Promise<VideoRemakeFullQualityEstimate>
fullQuality(jobId: string, params?: { sessionId?: string }): Promise<VideoRemakeFullQualityResult>
styleChoice(): Promise<VideoRemakeStyleChoice> // GET /v1/video-remake/style-choice, public
```

`VideoRemakeParams` is the request body above, with `engine` typed as `VideoRemakeEngine`, `style` as `VideoRemakeStyle` (`"precise" | "motion"`) and `motionLength` as `VideoRemakeMotionLength`. `faceMasking` is still typed, so older code keeps working, but it is deprecated and the server ignores it. `VideoRemakeEstimate` is the quote. `run()` sends `idempotencyKey` unchanged as the `Idempotency-Key` header. Without it, no header is sent. `styleChoice()` answers `VideoRemakeStyleChoice`, `{ engines: { "nodaro-prism", "nodaro-pulse" }, styleOnly?, preciseArtStyle? }`. Each engine is a `VideoRemakeStyleChoiceOption`: `"user"`, `"precise"` or `"flex"`. `styleOnly` and `preciseArtStyle` map each engine to a boolean; read a missing value as `false`. `VideoRemakeParams` takes `direction?: { style: string }`, and the quote's `breakdown` can name `referenceAudio`.

```ts
const { engines, styleOnly } = await client.videoRemake.styleChoice()
if (styleOnly?.["nodaro-prism"] === true) {
await client.videoRemake.run({ videoUrl, roles: [], style: "motion", direction: { style: "pop-art" } })
}
```

```ts
const params: VideoRemakeParams = {
videoUrl,
roles: [{ kind: "person", name: "the woman dancing", images: [myPhotoUrl], outfit: "original" }],
preview: true,
resolution: "480p",
}
const quote = await client.videoRemake.estimate(params)
const { jobId } = await client.videoRemake.run(params, { idempotencyKey: crypto.randomUUID() })
```

Follow the job with `client.jobs.get(jobId)`. A preview's job keeps every input in its `input_data`, so you can run it again with `preview: false` to render the full clip with the same choices.

To finish a run at 1080p, quote it with `fullQualityEstimate(draftJobId)`, which is free, then call `fullQuality(draftJobId)`. The quote's `kind`, a `VideoRemakeFullQualityKind`, is `"same-take"`. The result is `{ jobId, existing? }`. `existing: true` means this run's Full Quality was already running or done, and nothing was charged. A refusal carries a `VideoRemakeFullQualityRefusalCode`. For `full_quality_pending`, `err.details.retryable` is `true`: try again later.

```ts
const quote = await client.videoRemake.fullQualityEstimate(draftJobId) // free
const { jobId, existing } = await client.videoRemake.fullQuality(draftJobId)
```

## From the CLI

```bash
nodaro video-remake full-quality estimate <jobId> [--json]
nodaro video-remake full-quality run <jobId> [--session <id>] [--json]
```

`estimate` is a free quote. It prints the credits, each part of the quote, and until when the run can be finished. `run` spends credits and prints the new job id. When the Full Quality already exists, `run` prints that job and charges nothing. `full_quality_pending` is not final: run the command again later.

## From MCP

The MCP tool is [`video_remake`](https://nodaro.ai/docs/mcp/tools/video#video_remake). It takes the same fields in snake case, for example `pre_prompt`, `prepare_references`, `in_preview`, `engine`, `style` and `motion_length`. It also takes `art_style`, an art style on Nodaro Prism: an id of the [Style](https://nodaro.ai/docs/nodes/creative-controls/style) picker catalog, such as `pop-art`. It works on a Motion run, and on a Precise run where the engine takes one. With no role images and no references, it restyles the whole clip where the engine takes style-only runs. See [`video_remake`](https://nodaro.ai/docs/mcp/tools/video#video_remake). It takes no setting for preparing the clip. Without `confirm`, it returns the quote and charges nothing. With `confirm: true`, after the user accepts the price, it starts the run and returns a job id. The tools `estimate_full_quality` and `full_quality` quote and start the Full Quality version of a draft or of a Nodaro Pulse run at 720p.

## Frequently asked questions

### What does Video Remake do?

Video Remake replaces the people, pets, products or location in a short video with your own reference images. The motion, the framing, the timing and the sound of the video stay as they are, and the result is as long as the clip.

### Is Video Remake motion control or character swap?

Yes. Video Remake is what is often called AI motion control or character swap. The clip's motion, framing, timing and sound stay, and the people, pets, products or place in it come from your images. To make one still character perform the moves of a video instead, use the Motion Transfer node.

### How long can the source video be?

From 4 to 30 seconds. A shorter or longer clip is refused with clip_out_of_range before anything is charged.

### How do I know what a Video Remake run costs?

Call POST /v1/video-remake/estimate with the same body you will run. It is free and returns totalCredits, held when the run starts, and expectedCredits, what the run is expected to be charged. Read the two totals, never the sum of the breakdown.

### Can I try the look before I render the whole clip?

Yes. Send preview set to true to render 4 seconds of the clip, from previewStart. A preview costs less, and its job keeps every input, so you can run it again with preview set to false.

### Can I finish a draft run in full quality?

Yes, within 7 days after the draft completed. Make the run with draft set to true at 480p on Nodaro Prism. POST /v1/video-remake/:jobId/full-quality then re-renders the same take at 1080p, as a new job. Quote it first, for free, with the estimate route.

### Which engines can Video Remake use?

Two. Nodaro Prism is the default and renders 480p, 720p or 1080p, and makes a 480p draft when you send draft true. Send engine set to nodaro-pulse to use Nodaro Pulse, which renders 720p or 1080p, has no draft and makes a new take guided by the clip and your images.

### Can I choose whether the faces in my clip are masked?

No. Nodaro sets how the source clip is prepared for each engine, including whether faces are hidden first. A faceMasking field sent by an older client is accepted and ignored.

### Does Video Remake work on a self-hosted install?

No. Video Remake runs on Nodaro Cloud only. On a self-hosted install, every route answers 404.
