# Vidjutsu Clone

> Clone a TikTok video's motion onto a new character using only the VidJutsu API — download, cloneability check, character, starting image, motion clone, poll to a finished video URL. No WaveSpeed, Gemini, or other provider keys required; VidJutsu holds those internally.

- Skill: `tfcbot/vidjutsu-clone` (Agent Skill)
- Install (CLI): `npx skillmds@latest add tfcbot/vidjutsu-clone`
- Raw SKILL.md: https://api.skillmd.com/api/skills/tfcbot/vidjutsu-clone/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Integrations & APIs
- Author: tfcbot (https://skillmd.com/u/tfcbot)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/tfcbot/vidjutsu-clone

---


# vidjutsu-clone

Recreate a TikTok video's motion on a new character end to end, driving only
the VidJutsu API. Every step in this skill — download, cloneability check,
character generation, starting-image generation, motion clone, and status
poll — is a deterministic VidJutsu endpoint. VidJutsu holds the WaveSpeed and
Gemini credentials on its own side; you never see or hold them.

## When to invoke

- The user has a TikTok URL and wants that video's motion recreated on a
  different character (a new face/persona doing the same moves, same sound)
- They want the full chain run for them — download through a finished,
  hosted video URL — without touching a provider SDK directly
- The source clip is 15 seconds or shorter (VidJutsu caps clone sources at 15s)

This is not the same job as `clone-ad` (sibling skill, same repo). `clone-ad`
clones an ad's *pacing and shot structure* for a different product using
Gemini + Wavespeed directly, producing a fresh multi-shot 15s spot.
`vidjutsu-clone` clones a *single performer's motion* from one source clip
onto one character image, through VidJutsu's motion-clone endpoints only. If
the user wants a multi-shot product ad, use `clone-ad`. If they want "make
this TikTok but with a different person doing it," use this skill.

## Required environment variables

- `VIDJUTSU_API_KEY` — required. This is the only key this skill uses. Set it
  once via `vidjutsu auth` (writes `~/.vidjutsu/config.json`) or export it as
  `VIDJUTSU_API_KEY` in the shell. Do not ask the user for a WaveSpeed key, a
  Gemini/GOOGLE_ key, or any other provider credential — VidJutsu's clone
  endpoints call those providers server-side under VidJutsu's own
  request-scoped credentials and never expose them to the caller.

Stop before running anything if `VIDJUTSU_API_KEY` isn't set. Point the user
to `curl -fsSL https://vidjutsu.ai/install.sh | bash` followed by
`vidjutsu subscribe --email you@example.com` (see below) rather than
attempting a partial run.

## Output

Save the download source, character image, starting image, and final clone
video URL as a JSON manifest under `CWD/vidjutsu-clone-<timestamp>/result.json`
so a run is never overwritten and outputs are easy to find and clean up.

## Primary path: the CLI (`vidjutsu clone run`)

Prefer this. It is the same deterministic chain described below, wrapped in
one command:

```bash
vidjutsu clone run "https://www.tiktok.com/@handle/video/1234567890" \
  --character-prompt "A neutral, camera-ready presenter" \
  --model kling
```

What it does, in order:

1. `POST /v1/videos/download/tiktok` — pulls the TikTok video onto VidJutsu's
   CDN and returns a stable `url` + `assetId`.
2. `POST /v1/clones/check` — scores cloneability. Prints the verdict, a
   0–100 score, and evidence. **If the verdict is `weak`, the command stops
   before spending anything on generation** and exits nonzero. Pass `--force`
   only if the user explicitly wants to proceed anyway, and say so out loud —
   a weak verdict means the clone is unlikely to look good.
3. `POST /v1/characters` — generates a reusable character identity image from
   `--character-prompt` (default: "A neutral, camera-ready presenter" if the
   user hasn't described one).
4. `POST /v1/clones/starting-image` — composes a clean, text-free opening
   frame that swaps the character into the source video's framing and pose.
5. `POST /v1/clones/video` — submits the motion clone. **Kling motion control
   is the default model** (puppets the character image with the source
   video's motion, keeps the original sound). Pass `--model seedance` for the
   alternate model (480p, 9:16, VidJutsu can rewrite the prompt).
6. Polls `GET /v1/clones/video/{id}` until `status` is `completed` (or
   `failed`), then prints the final `videoUrl`.

Install if the CLI isn't present yet:

```bash
curl -fsSL https://vidjutsu.ai/install.sh | bash
vidjutsu subscribe --email you@example.com   # only if not already subscribed
```

The CLI resolves the key from `VIDJUTSU_API_KEY`, then
`~/.vidjutsu/config.json` — nothing else to configure.

## Fallback path: raw curl chain

Use this only if the CLI isn't installed and installing it isn't an option.
Every call needs `Authorization: Bearer $VIDJUTSU_API_KEY`.

```bash
# 1. Download the TikTok source onto VidJutsu's CDN
download=$(curl -fsS -X POST https://api.vidjutsu.ai/v1/videos/download/tiktok \
  -H "Authorization: Bearer $VIDJUTSU_API_KEY" -H "Content-Type: application/json" \
  -d "{\"url\":\"$TIKTOK_URL\"}")
source_url=$(echo "$download" | jq -r '.url')

# 2. Cloneability check — branch on the verdict before spending on generation
check=$(curl -fsS -X POST https://api.vidjutsu.ai/v1/clones/check \
  -H "Authorization: Bearer $VIDJUTSU_API_KEY" -H "Content-Type: application/json" \
  -d "{\"videoUrl\":\"$source_url\"}")
verdict=$(echo "$check" | jq -r '.verdict')
if [ "$verdict" = "weak" ]; then
  echo "Cloneability verdict is weak — stopping. Evidence:"
  echo "$check" | jq -r '.evidence[]'
  exit 1
fi

# 3. Generate the character
character=$(curl -fsS -X POST https://api.vidjutsu.ai/v1/characters \
  -H "Authorization: Bearer $VIDJUTSU_API_KEY" -H "Content-Type: application/json" \
  -d "{\"prompt\":\"A neutral, camera-ready presenter\"}")
character_url=$(echo "$character" | jq -r '.imageUrl')

# 4. Generate the starting image (character swapped into the source framing)
starting=$(curl -fsS -X POST https://api.vidjutsu.ai/v1/clones/starting-image \
  -H "Authorization: Bearer $VIDJUTSU_API_KEY" -H "Content-Type: application/json" \
  -d "{\"characterImageUrl\":\"$character_url\",\"prompt\":\"Match the framing and pose of the source video's opening frame\",\"sourceVideoUrl\":\"$source_url\"}")
starting_url=$(echo "$starting" | jq -r '.imageUrl')

# 5. Submit the motion clone (kling is the default model; pass "model":"seedance" for the alternate)
submit=$(curl -fsS -X POST https://api.vidjutsu.ai/v1/clones/video \
  -H "Authorization: Bearer $VIDJUTSU_API_KEY" -H "Content-Type: application/json" \
  -d "{\"startingImageUrl\":\"$starting_url\",\"sourceVideoUrl\":\"$source_url\",\"model\":\"kling\"}")
task_id=$(echo "$submit" | jq -r '.id')

# 6. Poll to completion
while true; do
  status=$(curl -fsS https://api.vidjutsu.ai/v1/clones/video/$task_id \
    -H "Authorization: Bearer $VIDJUTSU_API_KEY")
  state=$(echo "$status" | jq -r '.status')
  [ "$state" = "completed" ] && { echo "$status" | jq -r '.videoUrl'; break; }
  [ "$state" = "failed" ] && { echo "$status" | jq -r '.error'; exit 1; }
  sleep 3
done
```

Do not poll in a tight loop with no delay — 3s between checks is enough and
avoids hammering the endpoint.

## Model choice

- **Kling motion control (default)** — puppets the character with the
  source's motion and keeps the original audio untouched. Preserve its output
  exactly as returned; don't resize, transcode, or otherwise normalize the
  pixels.
- **Seedance (alternate, `--model seedance`)** — video-edit model, submitted
  at 480p / 9:16. Accepts an optional prompt override for the identity swap
  if the default composition instruction isn't specific enough.

Don't switch models mid-run once one has been picked — regenerating with a
different model after a failure should be a deliberate retry, not a silent
fallback.

## Constraints

- **Source clips are capped at 15 seconds.** Longer TikToks will fail the
  download or check step — tell the user to trim first if their source is
  longer.
- **Stop on a weak cloneability verdict.** Don't spend on character,
  starting-image, or video generation past a `weak` verdict unless the user
  has explicitly said to proceed anyway.
- **One motion-clone attempt at a time per source.** If a clone comes back
  wrong, retry the same model at most twice before telling the user it isn't
  working and asking how they want to proceed — don't loop indefinitely.

## Cost

Every call in this chain — download, check, character, starting-image,
video, and the status poll — is metered against your VidJutsu account, not
billed separately per provider. VidJutsu is a flat monthly subscription with
per-endpoint daily rate limits (reset 00:00 UTC), not a pay-per-call credit
system. `GET /v1/pricing` (or `vidjutsu pricing` if the CLI exposes it) is
the current source of truth for the subscription price and daily limits per
endpoint — check it before running this at volume so you don't hit a 429
mid-chain. Status polls (`GET /v1/clones/video/{id}`) are not billed.

The chain takes about 5 minutes end to end once submitted, mostly waiting on
the motion-clone step.

## No provider keys, ever

This skill talks to `api.vidjutsu.ai` only, authenticated with
`VIDJUTSU_API_KEY`. VidJutsu's clone endpoints call WaveSpeed (character and
starting-image generation, Kling/Seedance motion clone) and other model
providers on its own side, using its own request-scoped credentials. Never
ask the user to set `WAVESPEED_API_KEY`, `GEMINI_API_KEY`, a `GOOGLE_*`
variable, or any other provider key for this skill — if a step ever appears
to need one, that's a sign the wrong endpoint is being called.