Community

Turn a topic into a creative brief, script and visual bible; characters and locations already in the asset library are reused with their references, and only new ones get a turnaround sheet or concept art — saved to the library — auto-build a 3D blockout with each shot's camera position and move, then generate each shot from a first frame (and a last frame where needed) painted on the blockout — or straight from the turnarounds and the blockout camera move — and assemble, caption and export the video. Cost: by default up to 8 shots, each one video generation plus one or two keyframe images, on top of up to 7 turnaround and location images (none for those already in the library), 5 chat calls and per-shot narration — the most expensive template here; max_shots on the start node caps the shot count, and shot_seconds sets each shot's length (preset to the length the chosen video model can make that is closest to its default).

1. 1Choose a topic
2. 2Script, characters and visual bible
3. 3Reuse library assets; draw and save new turnarounds and location art
4. +5

Remove background hiss, transcribe the video with timestamps, identify pauses, fillers and repetition, then create a cut plan and a cleaned video while preserving the original. Suited to talks and interviews up to about 30 minutes; split longer footage first.

1. 1Choose a video
2. 2Remove hiss
3. 3Transcribe
4. +3

Transcribe a video sentence by sentence, translate each line, lay translated subtitles on the original timecodes, then dub each line and time-compress it back into its own slot. Pick the target language on the translate step (English by default). The original voice is separated out and the background music kept; a voice separation engine must be ready before the workflow starts.

1. 1Choose a video
2. 2Choose the target language
3. 3Transcribe with timecodes
4. +4

Everything in translated dubbing with subtitles, then re-sync the speaker's lips to the translated dub: cut the source into chunks the model accepts at the gaps between lines, lip-sync the chunks with speech, and lay the joined result on the top video track over the source (delete that track to undo the lip-sync). The export carries an "AI-generated" label. Pick the target language on the translate step (English by default). Confirm the speaker's consent on the lip-sync step before running. Cost: lip-sync is billed by source length (Bailian videoretalk lists about 0.08 CNY per second, so roughly 5 CNY a minute), plus translation and per-line dubbing; a re-run doesn't pay again for chunks whose translation, voice and timing are unchanged (a reworded line re-buys its chunk).

1. 1Choose a video
2. 2Choose the target language
3. 3Transcribe with timecodes
4. +5

Transcribe a talk, interview or stream recording, pick the passages that stand on their own (up to 12), then give each one its own vertical timeline in a single project, take that range from the source, lay rewritten short captions on it and export. No image or video generation, so nothing is billed beyond the transcription and one chat call.

1. 1Pick the long video
2. 2Transcribe with timecodes
3. 3Pick the passages that stand alone
4. +3

From one flat-lay or fabric photo, plan a few sellable scenes (up to 12) and shoot a portrait on-model image for each; where a video model is available, put every scene in motion with that image as its first frame. The product photo is carried into every generation — cut, colour, texture and logo come from it, not from a description. Images and clips are filed into one project and the copy lines are saved as a note. Each scene is one paid image generation (plus one video generation with motion). This copy includes “Put this scene in motion”. Without a video model, delete “Put this scene in motion” and “File this scene's clip” on the canvas after importing and it shoots stills only — the loop hands over the on-model images and doesn't depend on those two.

1. 1Describe the product and audience (its name, plus a line or two on category, colour, material and cut)
2. 2Pick the product photo
3. 3Plan the scenes
4. +3

From a product photo and a few selling points, write a beat-by-beat script (the first beat is the hook, the last the call to action, up to 12 beats), paint one portrait frame per beat with the product in it, lay each on the timeline for that beat's length, voice each beat lined up with its start (your cloned voice if you have one, otherwise a free Edge voice), add the on-screen lines, and export a vertical short. Nobody appears on camera. Only the selling points you provide are used — no invented claims or figures. Where a video model is available, every beat moves: its frame becomes the first frame of a clip, the clip is what goes on the timeline, and every beat is the same length (the start node's beat_seconds, a length that model can make). Cost: one paid image per beat, plus one paid video generation per beat when beats move — about target length ÷ beat_seconds beats, so 30 seconds at 5 seconds a beat is about 6 images and 6 clips. This copy includes “Put this beat in motion”: the start node's beat_seconds is every beat's length, and the video model you pick has to make that length. Without a video model, open the per-beat loop on the canvas after importing, delete “Put this beat in motion”, “File this beat's clip” and “Mute this beat's clip”, then wire the output of “Paint this beat” into the asset of “Lay it down for this beat's length” — every beat then lays a still for beat_seconds. Or add the template from the in-app gallery: without a video model it is built with stills.

1. 1Product name and selling points (one per line, only claims you can stand behind)
2. 2Write the beat-by-beat script
3. 3Paint and voice each beat onto the timeline
4. +3

Pull a tagged batch of footage you already shot, let the model order the story, decide which part of which clip each beat uses, and write the narration; then lay every segment on the timeline in order, speak and caption each one (ducking the footage's own sound under the narration), and export. Nothing is generated — the picture is your own footage, and without a configured voice it falls back to captions only. If the tag is blank or has no videos, it stops and tells you. Up to 200 videos under the tag are used at a time; split larger batches with finer tags first.

1. 1Topic and footage tag (tag the videos to cut with one shared tag first)
2. 2Fetch the footage by tag
3. 3Order the story and write the narration
4. +3

From one fabric photo and its specs, plan the products it genuinely suits (up to 12), render each one in a real space, and produce a one-page proposal you can send to a client. The spec sheet only restates the numbers you provide; anything missing is marked as needing mill confirmation. Each application is one paid image generation.

1. 1Fabric specs (name, composition, weight, width, hand feel; leave unknowns blank)
2. 2Pick the fabric photo
3. 3Plan applications and the spec sheet
4. +2

A portrait and a script: voice it sentence by sentence, group the sentences into segments the speaking-photo model accepts, make the face speak each one, lay them end to end on the timeline, caption from the real voicing times, and export. The export carries an "AI-generated" label. Confirm consent on "Make it speak" before running.

1. 1Pick a portrait
2. 2Paste the script and pick the voice on “Voice the script in segments”
3. 3Voice the script in segments
4. +3

Everything in the narrated short, but a character from your asset library speaks the hook and the call to action on camera (with its own face and voice), while each beat in between stays a product shot voiced in the same voice, lined up with the beat and captioned, exported as a vertical short with an "AI-generated" label. Pick the character on “Pick the presenter” before running; it needs a front image and a voice in the asset library; real people need a consent declaration, and a cloned voice needs one too. Where a video model is available, the beats in between move, as in the narrated short (the hook and call to action are already presenter video): one more paid video generation per beat, with about (target length minus hook and call to action) ÷ the start node's beat_seconds beats. This copy includes “Put this beat in motion”: the start node's beat_seconds is every beat's length, and the video model you pick has to make that length. Without a video model, open the per-beat loop on the canvas after importing, delete “Put this beat in motion”, “File this beat's clip” and “Mute this beat's clip”, then wire the output of “Paint this beat” into the asset of “Lay it down for this beat's length” — every beat then lays a still for beat_seconds. Or add the template from the in-app gallery: without a video model it is built with stills.

1. 1Product name and selling points (one per line, only claims you can stand behind)
2. 2Pick the presenter
3. 3Write the beat-by-beat script
4. +5

Paste a Douyin, Xiaohongshu or Bilibili profile link to fetch the profile and the latest 30 posts (publish time, caption, length, views / likes / comments / saves / shares). Code works out posting frequency, posting-time distribution, engagement rate, top posts and a recent-half-vs-earlier-half growth or decline signal, then a diagnosis (where it stands, content pillars, what works, problems, concrete next steps) is saved as a note with the key numbers attached. Pick the data source from the start node's drop-down: the built-in browser (nothing to set up and free; Xiaohongshu / Douyin need a signed-in browser profile, other platforms work too, and the numbers are the page's rounded ones) or TikHub (needs the plugin and an API key; 2 calls per run, from about $0.001 each — see your TikHub bill; complete fields, steadier, no sign-in). Plus one or two AI chat calls (one more on the browser route to read the page).

1. 1Profile link and the data source (built-in browser or TikHub), optionally the platform and your question
2. 2Work out the platform and account id
3. 3TikHub fetches profile and posts per platform, or the browser reads the page
4. +4

Paste a Douyin, Xiaohongshu or Bilibili video link to fetch its numbers and most-liked comments, download it and transcribe the speech with timecodes, then break down why it worked (topic, the first-three-second hook, structure and pacing, emotional beats, title and cover, comment feedback, reusable patterns) and outline a script to make one the same way, saved as a note. Pick the data source from the start node's drop-down: the built-in browser (nothing to set up and free; switch to a signed-in browser profile where needed) or TikHub (needs the plugin and an API key; 2 calls per run, from about $0.001 each; complete fields, steadier, no sign-in). The download uses the library's Import from link (Douyin usually needs a signed-in browser profile on the download step); if it fails, the breakdown still runs on the numbers and comments. Transcription runs locally; plus one or two AI chat calls. Frames are not looked at yet.

1. 1Video link and the data source (built-in browser or TikHub), optionally a topic of your own
2. 2Work out the platform and post id
3. 3TikHub fetches details and comments per platform, or the browser reads the page down to the comments
4. +5

Paste a post link to fetch its most-liked comments (50 by default: one page via TikHub, about 20–50; the browser scrolls through the comment section), group them by topic, infer the audience, needs and pain points, open questions, objections and sentiment, suggest next topics and replies to the comments worth answering, saved as a note. Pick the data source from the start node's drop-down: the built-in browser (nothing to set up and free; Xiaohongshu comments need a signed-in browser profile) or TikHub (needs the plugin and an API key; 1 call per run; complete fields, steadier, no sign-in). Plus one or two AI chat calls.

1. 1Post link and the data source (built-in browser or TikHub), optionally your question
2. 2Work out the platform and post id
3. 3TikHub fetches comments per platform, or the browser reads the comment section
4. +4

Pick a video from the asset library. Code first measures every cut and each shot's motion (free, not guessed by a model) and grabs two frames per shot into contact sheets; optionally transcribe the speech so lines are assigned to each shot by timecode. A vision model then judges framing, camera work, transitions and rhythm shot by shot, and writes a picture description plus a storyboard prompt to recreate it (up to 25 shots per call; code reconciles afterwards: out-of-vocabulary words are dropped, and camera moves the pixels don't show are corrected and recorded). Code produces the shot-list report, a model writes the breakdown (structure, pacing curve, hook, reusable techniques), and it is saved as a note and handed over. Cost: no extra spend per shot, 25 shots per vision call — a one-minute, 30-shot video costs two vision calls plus one chat call for the summary. The starting point is a video already in the asset library; to break down a link, import it into the library first with Import from link.

1. 1Pick a video
2. 2Detect shots: code measures cuts and motion, frames into contact sheets (free)
3. 3Optional: transcribe the speech, lines assigned to shots by timecode
4. +5