Analysis and edit lists

The analysis and edit list tools read existing recordings and turn them into structured data or finished cuts. video_analysis and video_audit break a video down scene by scene so it can be re-created. shot_cuts, silence_detect, audio_sync and speaker_map measure recordings. plan_edit and apply_edl plan and render cuts from a transcript, switch_cameras chooses the camera for each cut by who is speaking, and speaker_view lays the speakers out on screen. The podcast tools run a whole job in one call: tighten_episode tightens an episode, make_chapters lists its chapters, make_trailer cuts a trailer, make_clip_pack cuts short clips and speaker_layout frames the recording by speaker. Every tool needs the workflows:execute permission. Every tool except estimate_use_case returns a job id.

video_analysis

Analyzes a video into a scene-by-scene breakdown built for AI re-creation. It works like the Video Analysis node.

• Scenes are cut at natural boundaries and last at most 8 seconds, one image or video generation per scene.
• visualResolved is a self-contained, prompt-ready description of each scene. It is the field that later steps read.
• Each scene also has a shot type, a camera movement, and a list of audio layers. Speech is quoted word for word, music and sound effects are described so they can be generated, and an empty list means silence.
• Slots are the people, objects and places that recur, so you can re-cast them with your own characters.

Permission: workflows:execute. Credits: by video length, in the table below.

Returns: a job id. The analysis, meta, slots and scenes, is in the job's output_data.

The tool always runs the Smart analysis, the most accurate tier, and takes no tier or result-strategy parameter. A client that still sends llm_model or selection_mode gets Smart, and those parameters are ignored. The other tiers stay available on the Video Analysis node, also in workflows you run over MCP, and on the REST route.

The price depends on the length bucket, the smallest of 60, 180, 360 or 600 seconds that fits the video. The 60-, 180- and 360-second buckets each have 3 seconds of grace, so a video up to 1:03 is priced in the 60-second bucket:

list_models returns the current prices.

video_audit

Watches a video again against its analysis and fixes what is wrong. Every correction is applied under checks and reported, and what could not be fixed is flagged, not changed. It works like the AI Audit node.

Permission: workflows:execute. Credits: by length, and cheaper when you pass an analysis.

Returns: a job id. The job's output_data holds the report: what was checked, what changed and what was left open.

shot_cuts

Finds where every shot of a video starts and ends, measured from the file itself. Every decoded frame is scored, and each hard cut starts a new shot. Dissolves and fades are not cuts. It works like the Shot Cuts node.

Permission: workflows:execute. Credits: one flat price per run, with or without frames. The tool is not listed where the Shot Cuts node is not offered.

Returns: a job id. outputData.json is { shotCount, cutsSec, durationSec, shots }. Each shot has index, startSec, endSec and durationSec, in seconds from the first frame. cutsSec is in ascending order and never holds 0. It is [] for a video of one shot. With frames, each shot also has firstFrameUrl and lastFrameUrl, and outputData.firstFrames and outputData.lastFrames list the frame URLs in shot order.

silence_detect

Finds the silent ranges in a recording, from its audio only: no transcript and no pictures. It works like the Silence Detect node.

Permission: workflows:execute. Credits: 11.

Returns: a job id. The result is output_data.json, { ranges, durationMs }. Pass that object, not the whole output_data, as the silence of plan_edit, or use ranges to write an edit list by hand.

audio_sync

Measures how far apart the clocks of 2 to 6 recordings of one conversation are, such as camera files and a main microphone, by comparing their audio. It works like the Audio Sync node.

Permission: workflows:execute. Credits: from 11 for 2 sources to 55 for 6, by the number of recordings aligned to the reference.

Returns: a job id. The result is output_data.json: { reference, offsets, notes }, where each offset has sourceId, offsetMs, confidence and driftMsPerHour. A time on the reference clock is the time in the source plus offsetMs. Low confidence and clock drift are reported in notes, never corrected.

speaker_map

Works out which camera each speaker is on, from the cameras' own microphones. It works like the Speaker Map node.

Permission: workflows:execute. Credits: one flat price per run. The tool is not listed where the Speaker Map node is not offered.

Returns: a job id. output_data.json is { version, speakerMap, confidence, notes, edl? }. edl is the recordings as one edit, also on output_data.edl. Pass the result to switch_cameras as speaker_map_result. A speaker with no clear camera gets "": the speaker is shown on the wide shot, or, with no wide shot, on any camera with picture. A camera that heard nothing is reported in notes and never fails the run.

plan_edit

Turns a timed transcript into an edit decision list for a recording. It reads the transcript, never the pictures. It works like the Edit Plan node.

Permission: workflows:execute. Credits: 3–1,664, by the recording's length, the mode and the tier. Nodaro Cloud only.

The master is the source with the master-audio role, or else the first source. The tool refuses the call before any charge when the offsets would put the cut out of sync:

• A source has no offset_ms, and audio_sync did not measure it, or matched it weakly, with a confidence below 0.5. Set its offset_ms.
• The master has an offset_ms other than 0.
• Other sources use measured offsets, but audio_sync did not measure the master, or matched it weakly.
• offsets is not an audio_sync result, or a source has no id to match it with.
• The transcript was made from a source that is off the master's clock. Transcribe the master, or give that source the master-audio role.

Returns: a job id. The plan is in the job's output_data, ready for apply_edl.

switch_cameras

Chooses which camera shows each cut of a multicam edit, by who is speaking. It works like the Camera Switch node. The sound never changes.

Permission: workflows:execute. Credits: one flat price per run, whatever the length of the recording or the number of cameras. Nodaro Cloud only.

A speaker left out of speaker_map goes to the source whose speakers list names them, else to the wide source, else to any camera with picture. A speaker set to "" skips the speakers list. A new speaker on the same camera still gets a named segment of their own.

The call is refused before any charge in two cases. The first is a transcript with no speaker labels. The second is an edl that is not one edit on the master clock, such as a clip set, a chapters plan or the edit list of a rendered output.

Returns: a job id. output_data.json is the switched edit list for apply_edl, and output_data.transcript is the transcript with the speaker names.

speaker_view

Renders an edit with its speakers laid out on screen, from the original cameras and with the edit's own sound. It draws a layout, a switch at each speaker change and an emphasis on whoever is talking. It works like the Speaker View node.

Permission: workflows:execute. Credits: per minute of rendered output, as on the Speaker View node. The rate is lower at the proxy quality, and higher with three to six pictures on screen or a zoom. Nodaro Cloud only.

The tool does not take face tracks. To follow faces with Speaker Frames, build the workflow in the editor. A call is refused before any request when it sends both or neither of edl and video_url, an edl string that is not JSON, a video_url without a transcript with speaker labels, or a crop outside the limits. The route's own refusals come back as tool errors, before anything is charged: an edit it cannot draw, or a video it cannot measure or that is not wider than the shape.

Returns: a job id. The video is in output_data.videoUrl, the edit as drawn in output_data.json, and the transcript, remapped through the edit, in output_data.transcript.

apply_edl

Renders an edit decision list into a finished cut. It works like the Apply EDL node, which also gives the price per minute.

Permission: workflows:execute. Credits: priced per minute of rendered output, at the rate of the quality. A proxy preview, video or audio, has its own lower rate.

A render can produce at most 180 minutes. A malformed list, or one that is too long, is refused before anything runs, with the segment and the rule it breaks.

Returns: a job id. The rendered file is the job's result, and its output_data.quality says whether it is a preview or the final.

tighten_episode

Tightens a podcast or interview recording in one call. It transcribes the recording with speaker labels, finds the silences, plans the tightened cut and renders it. It can also add captions and a music bed that dips under the voice. It works like the Tighten Episode node.

Permission: workflows:execute. Credits: each step at its own price, plus a fixed fee for each run.

Returns: a job id. The episode is in output_data.videoUrl or output_data.audioUrl, and the edit is in output_data.json. On a self-hosted install, the tool needs a connection to Nodaro Cloud, and it is refused at once without one.

Several recordings

tighten_episode, make_trailer, make_clip_pack and speaker_layout also take several recordings of one conversation, such as one camera per speaker and a separate microphone. The run lines the recordings up, works out who is on which camera, and cuts to whoever is talking.

Several recordings, or a master audio, need Speaker Map. Where Speaker Map is not available to you, the call is refused with 403 node_not_available. A run with several recordings reports who is on which camera in output_data.cameras.

make_chapters

Lists the chapters of a podcast or interview recording in one call. It transcribes the recording, then plans its chapters, each with a title and a start time. Nothing is rendered. It works like the Chapters node.

Permission: workflows:execute. Credits: each step at its own price, plus a fixed fee for each run.

Returns: a job id. The show notes are in output_data.text: one 0:00 Title line per chapter. Once a chapter starts at 1:00:00 or later, every line uses H:MM:SS. The list is in output_data.json, as [{ startMs, title }], and the first chapter starts at 0. When two chapters start in the same second, the first one is kept.

A run that finds no chapters fails, and its fee is refunded. That run cannot be continued, because every step completed, so run it again. Any other failed run continues with continue_use_case and mode: "from-failed". On a self-hosted install, the tool needs a connection to Nodaro Cloud.

make_trailer

Cuts a 20 to 40 second trailer from a podcast or interview recording in one call, and delivers it in each social format you choose. It transcribes the recording, plans the trailer from its strongest moments and renders it. The plan chooses the length and joins the moments with short crossfades. Each format is padded, never cropped. It works like the Trailer node.

Permission: workflows:execute. Credits: each step at its own price, plus a fixed fee for each run.

Returns: a job id. The trailers are in output_data.formats, as [{ format, url }] in format order, and the first one is also in output_data.videoUrl. A format that could not be rendered is named in output_data.failedFormats, and the run completes with the others. When no format is rendered, the run fails and its fee is refunded.

With review_before_render: true, the run stops at a preview of the trailer in output_data.videoUrl, and formats stays empty until the final render. Check the plan in output_data.json, then call continue_use_case with mode: "render-final". On a self-hosted install, the tool needs a connection to Nodaro Cloud.

make_clip_pack

Cuts a podcast or interview recording into a pack of short clips in one call. It transcribes the recording, finds the best moments, renders each one as its own clip and captions it. It works like the Clip Pack node.

Permission: workflows:execute. Credits: each step at its own price, plus a fixed fee for each run. A clip that cannot be rendered is not charged.

Returns: a job id. The clips are in output_data.clips, each { url, title?, hook?, clipKey, thumbnailUrl?, captionsFailed? }. The first clip is also in output_data.videoUrl, or output_data.audioUrl for audio clips.

• Every clip is tried. A clip that cannot be rendered, or cut between cameras, is skipped and not charged. It is counted in output_data.failedClips, and the run completes with the others. When no clip is rendered, the run fails and its fee is refunded.
• Captions can fail on their own. A clip whose captions could not be added comes without them, with captionsFailed. It is counted in output_data.failedCaptions, and those captions are not charged.
• Review first. With review_before_render: true, the run stops at quick previews. Check output_data.json, which holds one EDL per clip. Then call continue_use_case with mode: "render-final" and an edited_edl that keeps or drops clips. Keep at least one clip: dropping every clip is refused with use_case_nothing_kept. The final render makes only the kept clips, with no fee.

On a self-hosted install, the tool needs a connection to Nodaro Cloud.

speaker_layout

Frames a whole podcast or interview recording by speaker in one call. The result has the same length as the recording: nothing is cut. It transcribes the recording, then frames each speaker with Speaker View. It works like the Speaker Layout node.

Permission: workflows:execute. Credits: each step at its own price, plus a fixed fee for each run. The tool is not listed where the Speaker Layout node is not offered.

Returns: a job id. The framed video is in output_data.videoUrl, and the edit that Speaker View drew is in output_data.json. After a preview, call continue_use_case with mode: "render-final" and no edited_edl: the layout has no cut to change, and an edited_edl is refused with use_case_no_plan. On a self-hosted install, the tool needs a connection to Nodaro Cloud.

estimate_use_case

Quotes a run of a podcast tool before it starts. The quote is free: nothing is created or charged.

Permission: workflows:execute. Credits: free.

The arguments are checked against the run tool's own arguments. An argument that the tool does not take is named and refused, and so is a value it refuses. They are then sent the same way the run tool sends them, so the quote is for exactly that run.

Returns: { totalCredits, stepsCredits, feeCredits, estimate?, durationSec }, also as structuredContent with nodeType. The total is the run's steps at their own prices plus its fee. estimate: true means a step is priced at a metered estimate, so the total is approximate. durationSec is null when the recording's length could not be read. Every figure is 0 on an edition without credits. The refusals come back as tool errors: several recordings where Speaker Map is not available to you (403 node_not_available), or a self-hosted install with no connection to Nodaro Cloud (503 nodaro_connection_required).

continue_use_case

Continues a tighten_episode, make_chapters, make_trailer, make_clip_pack or speaker_layout run as a new job.

Permission: workflows:execute. Credits: depends on the mode, below.

• from-failed runs again only the steps of a failed run that did not finish. The finished steps are kept and not charged again. The fee is charged again, because the failed run's fee was refunded, so it applies once overall.
• render-final renders the full-quality result after a preview made with review_before_render. It uses the preview's settings, and edited_edl when you pass it. It charges no fee. It renders Tighten Episode's episode, the trailer with its intro card and every format, Clip Pack's kept clips with their captions, or Speaker Layout's framed video.
• Refusals of render-final. A make_chapters run renders nothing, so it is refused with render_final_not_preview. A clip pack edited_edl that drops every clip is refused with use_case_nothing_kept. A speaker_layout run has no edit to change, so an edited_edl is refused with use_case_no_plan.

The run is continued on the route of its own node type, read from the job itself. A job that is not a run of a podcast use-case node is refused before anything is sent.

Returns: a new job id. A refusal comes back as a tool error with its continuation code. already_running and continuation_superseded name the job to follow, or the job to continue instead. continuation_settling means: try again in a moment.

Edit a recording from its transcript

For a podcast or interview, tighten_episode runs these steps in one call. The podcast-editing recipe guides an assistant through the same steps; see Content recipes. For several cameras and a separate microphone, run audio_sync first and pass each source's offset_ms to plan_edit.