Treza

Join clips the account already has into ONE finished video, in the order given, optionally over a voiceover (narrationUrl) and a music bed, which become separate tracks with the clips ducked under the voice, and with burned-in captions. The bed is a track from the library (musicUrl) or one composed for this cut from a description (musicPrompt), never both. One clip plus a track is how to put music or narration under a single video: "add music to my video" is clipUrls [that video] with a musicPrompt, and no pipeline to build. Every url must come from list_assets or a run's outputs in get_run. A slideshow of photos or images, with a push-in, a pan or Ken Burns, is ONE call with the image urls, stillMotion and stillSeconds, never an image-to-video clip per photo. Stills hold 3 seconds each (or stillSeconds), or stretch so a longer voiceover plays in full. With no stills, the clips have to run as long as the voice (list_assets gives each durationSec): the last frame holds up to 3 seconds so the voice can finish, and a voice longer than that past the clips is refused with nothing charged. lengthSec in the result is how long the cut will run, and any warning in it should be passed on. Renders in the background: poll get_run with the returned pipelineId and runId. Free once the account has bought credits (the result carries charged: false), so never ask a paying account to top up before assembling; charged on a trial. The same request made again within a few minutes returns the render already started (repeat: true) rather than starting another; to render the same cut a second time on purpose, pass a new requestId. Needs the pipelines:run and pipelines:write scopes.

Stop a run that is still going: one run_pipeline, assemble_video or edit_asset started. Use it when the person asks to cancel, stop or kill a render, including "stop, that's wrong" about one they can see running. A render that is rendering stops once its current step finishes (status "cancelling", then "cancelled" in get_run); one still waiting to start is closed at once and costs nothing. Steps that already finished keep their output and are not refunded. Leave out runId to cancel the pipeline's newest running run. Needs the pipelines:run scope.

Posts a video prepared by publish_asset, with the settings the person chose in the publish panel. Called by the panel when they press Post, never by the model.

A link the person opens to connect a YouTube channel or a TikTok account to their Treza account, so a pipeline can post there. Returns what is already connected on that platform and connectUrl. Only the person can finish it, in their own browser: give them the link, tell them the platform will ask their permission to post and that the page says when it is connected, and after they say so check list_connected_channels. The link asks them to sign in to Treza first with the Google account this connection uses, and it does not expire. When something is already connected, the link adds another, so only offer it when that is what they want.

"Make it like this video": read a reference short the account has (a music edit: titles over a beat) and save a pipeline that makes more like it. Its cuts, the music's tempo and drop, and how they line up are measured; its hook, titles, top bar, music genre and picture look are read by a model. The result is a draft Beat Edit Short pipeline cutting the same beats a shot, with the music brief at the reference's tempo and drop and the writer told its style; copied and couldNotCopy say what carried over. Takes about a minute and a few cents, waited on in this call; nothing renders. Then estimate_run_cost and run_pipeline with the person's topic on the brief input. The video must be in the library (import_media); YouTube links cannot be fetched. Needs the pipelines:run and pipelines:write scopes.

Put the account's own footage, pictures, music or voiceover on a new editable timeline project, in order: video and image clips on the video track, each video's sound on the audio track under it, and music or voiceover on a track of their own from the start. This is how raw footage someone uploaded gets edited by hand-tuned cuts rather than a one-shot assemble_video: create it, read it with get_project, cut and caption it with edit_project, then render_project. Urls come from list_assets (import_media or create_upload_url brings new files in). Up to 30 clips. Needs the pipelines:write scope.

Create a new pipeline (as a draft) on your Treza account, from a template (templateId, see list_pipeline_templates) or with an initial node graph. Use list_node_types / get_node_type to learn the graph vocabulary: every edge names the two nodes it joins and a port on each, e.g. {"source":"music","sourceHandle":"audio","target":"sequence","targetHandle":"shots"}. A graph with error-level issues is refused with every issue listed, and nothing is saved. That includes a config key the node does not define, a value outside a field's options or range, and a model id, duration, aspect ratio or voice the chosen model does not offer: pick them from get_node_type. Drafts can be run with run_pipeline; publish_pipeline makes them invokable over the public API. To put music under a video the account already has, call assemble_video with musicPrompt instead of building a graph.

A one-time link to upload a local file into the media library, for a client that can run a command (Claude Code, Codex, Cursor): PUT the file to uploadUrl with the returned Content-Type (the result includes the curl command), then call import_media with url set to the returned mediaUrl. A Blender scene (.blend, contentType application/x-blender) is the exception: it skips import_media and its mediaUrl goes into a Blender Render node's Blend file field. So is a Gaussian splat (contentType model/x-spz, model/x-ply or model/x-splat): its mediaUrl goes into a Splat Render node's Splat field, to film a camera move through it. The link expires in 15 minutes and signs one content type. If you cannot run a command, do not call this: ask the person to drop the file into their Treza library in the web app and find it with list_assets. Needs the pipelines:write scope. Spends no credits.

Delete pipelines from the account for good, up to 50 per call, in two steps. First call it with pipelineIds alone: nothing is deleted, and it returns willDelete (names, and which are published or on a schedule), cannotDelete with the reason (locked, or a run still in flight), notFound, and a confirmToken. Show the person what would go and wait for their yes; it cannot be undone. Then call again with the confirmToken and the willDelete ids (or fewer): only ids that preview showed are deleted, each checked again, and the token expires after 15 minutes. Use it when the person asks to delete or clean up pipelines, or when a create is refused at the 500-pipeline limit and they agree to clear space. Never pick pipelines to delete on your own: match them by name in list_pipelines and let the person choose. A deleted pipeline's schedule stops and its published API endpoint goes away; the images and videos its runs made stay in the library. Needs the pipelines:write scope.

Run pipeline nodes over ONE video, image, or audio file the account already has and get the edited file back: captions, an upscale, background removal, lipsync, a crop, an overlay, a cutaway, a thumbnail, a trim, or any other transform in list_node_types. To put music under a video, use assemble_video with musicPrompt instead. Operations run in order, each fed the output of the one before, so "caption it and upscale it" is one call with two operations; a Transcribe stage is added wherever an operation needs a transcript. Check a node's config and ports with get_node_type first. A setting the node does not define, or a value outside what it offers, is refused with the valid ones listed. The source, and any url given as an input, must come from list_assets or a run's outputs in get_run. Renders in the background and spends credits: poll get_run with the returned pipelineId and runId. The same edit asked for again within a few minutes returns the render already started (repeat: true) rather than charging for another; to render it a second time on purpose, pass a new requestId. Needs the pipelines:run and pipelines:write scopes.

Change a timeline project. Each entry in actions is an object with "action" set to one of the names get_project listed, plus that action's own arguments, applied in order: "the narration is two seconds too long" is one trim_clip. After a trim, add {"action":"transcribe"} in the same call so the captions follow the new cut (a small transcription charge, which also needs the pipelines:run scope). The edit is saved and the previous version kept for undo_project_edit. Saving is not rendering: follow with render_project when the person wants the corrected video. Up to 25 actions a call. Needs the pipelines:write scope.

Estimate what one run of a pipeline will charge the credit balance, which steps the money goes to (lines, each clip-priced step with the length it was priced over in basis), the files it works on (sources: name, length, size, and whether each was uploaded or made with a model), and whether the current balance covers it. Estimates use the draft graph, the same one run_pipeline executes, with inputs applied: pass the same inputs the run will get (a File node's URL changes what a clip-priced step costs), or the price is for the values saved on the canvas. When a video step would render the same clip for far less on Veo 3.1 Lite, cheaper names it with the run's price on it. When the balance covers neither, preview prices a first look it does cover: the first video step alone as a short Veo 3.1 Lite clip, which run_pipeline with preview: true renders. Call this before running a pipeline you built or changed in this conversation, tell the person the price (and the preview's, when there is one), and wait for their go-ahead before run_pipeline. Pass the returned quoteId to run_pipeline: it starts the run at this price once, and refuses if the pipeline changed since (estimate again then). Clients that show panels put the estimate in front of them with a Start render button, which sends that go-ahead as their message.

Current prepaid credit balance, plan usage, and purchasable credit packs for this account. Use it to budget before starting runs. When the balance is low, hand the returned topUpUrl to a signed-in human; if the response carries an x402 block, a wallet-holding agent can pay that endpoint to top itself up with no human involved. That block also carries x402.video when this deployment sells single clips: one payment renders and returns one video without touching the balance, which is the cheaper path for a one-off.

Full definition of one node type: input/output ports and the config field schema needed to author a node of this type. For a model-bearing node the live model catalog comes with it, and for video-gen each model carries what a second of video costs (usdPerSecond), so compare prices before choosing one.

Get one pipeline: metadata plus a summary of its node graph (node ids, types, labels). Pass includeGraph to get the complete graph — every node with position and config, and every edge — which is what update_pipeline needs as a starting point. Never write a graph reconstructed from the summary: it drops configs.

Which Treza account this connection is signed in to: a stable account id, its email, and its name when it has one. Use it when the person asks which account is connected, or before acting when more than one may be.

Read one timeline project: every track and clip with its start, end, trim points, volume and fades, plus actions, the exact edits edit_project accepts and their arguments. Always call this before edit_project: clip and track ids come from here. Times are in seconds.

Where a render_project render is: status "pending" or "running" (call again after pollAfterSec), "success" with the finished file's url, or "error". Omit jobId for the project's last finished render.

Get one run: overall status plus per-node results and output URLs. Poll this after run_pipeline, assemble_video or edit_asset until the status is no longer "running". A finished run carries outputs, what its Output nodes returned (for assemble_video and edit_asset, the finished file). While a run is still "running", nodes lists the steps that have completed so far (with their outputs) progress says how many of how many and what it is working on now, pollAfterSec is how long to wait before calling again, and finishedAt/durationMs are omitted. Clients that show panels follow the render in the panel, so there is no need to poll faster than pollAfterSec.

Read what is said in a video or audio file the account owns: the full text plus timestamped segments. This is how you know what a clip is about. Call it before writing anything that has to match the footage (a hook, a title, a caption line, a description) and before choosing which seconds to keep: segment times go straight into a trim through edit_asset or edit_project. The first read of a file transcribes it (a few cents, about a minute, waited on inside this call); the same file is free after that. Files up to 25 minutes; for longer, use a clip template. Needs the pipelines:run scope.

Add an image, video or audio file to the account's media library, so assemble_video and edit_asset can use it: a file the user attached in this conversation (file, where the client passes attachments), a public https link to the file itself (url), or a local file uploaded through create_upload_url (url set to its mediaUrl). Returns the library url. Putting an attached logo in the corner of a video or a picture is this, then edit_asset on the video or picture with an overlay operation whose inputs.image is the returned url and whose config.position names the corner (a picture comes back a PNG). Images up to 25 MB, audio 100 MB, video 200 MB; the type is read from the file, and anything else (SVG, PDF, a web page) is refused. When the user attached a file you cannot pass on (you see it but have no file or link to give), ask them to drop it into their Treza library at https://www.trezalabs.com/chat/assets and find it with list_assets. Needs the pipelines:write scope. Spends no credits.

Browse the account's media library: every image, video, and audio file its pipeline runs and chat generations produced, newest first. The urls it returns are the ones assemble_video and edit_asset accept, so start here when asked to cut, caption, score, or otherwise finish media the account already has. A file the user attached in the conversation is not here until import_media adds it. Clients that show panels let the person pick files from this list: the picks reach you as context naming each file by its #position in the list with its exact url, and the person then says in the chat what to do with them. Apply that to exactly those files, and do not assume picks mean joining them.

The YouTube channels and TikTok accounts connected to this Treza account, with the ids a publishing node needs. A youtube-upload node needs a channelId and a tiktok-upload node needs an openId; both come from here. To connect one, call connect_channel and give the person its link.

List the node types available for building pipeline graphs, grouped by category. Use get_node_type for a full port/config schema before wiring a node.

List the video pipelines on your Treza account, with status and a summary of recent runs.

Ready-made pipelines that create_pipeline can copy with templateId, so you do not have to draw a graph node by node. Each entry lists its entry nodes, the ids to key run_pipeline inputs by, and estimatedChargeUsd, what one run charges the balance as the template stands, to compare against get_credit_balance before you pick one. Clipping a long recording, file, or direct video URL into a captioned vertical clip is "video-clip-factory" (entry node "source", a File node that takes a URL); "podcast-clip-factory" pulls the newest episode from a podcast RSS feed; "campaign-clip" is for Vyro / Whop clipping briefs.

The account's timeline projects, newest edit first. A project is a finished cut opened as an editable multi-track timeline (video, audio, captions). Use it when the person wants to change a video they already made ("the narration runs long", "drop the music a bit", "cut the last shot") rather than make a new one. A video from assemble_video, edit_asset or a pipeline run has no project until open_run_in_timeline opens it.

List recent runs for a pipeline, newest first.

One picture from a description in one call, the still twin of make_video: wires the image model, prepares the render and answers like estimate_run_cost: the price, whether the balance covers it, and a quoteId. It does NOT start the render: tell the person the price, and once they accept, call run_pipeline with the returned pipelineId and quoteId (no inputs), then poll get_run; the picture is outputs.image. Pass referenceImageUrls to change or restyle pictures the account already has ("make this render photo real", "same scene at night"): the model works from them and keeps their composition. A local file goes into the library first with create_upload_url and import_media. Needs the pipelines:write scope; the run needs pipelines:run.

The quickest way to make a video from a description: no template, node types or graph to wire. Picks a video model that renders the shape and length asked for (Veo 3.1 Lite unless a model is named or it cannot), prepares the render, and answers like estimate_run_cost: the price, whether the balance covers it, and a quoteId. It does NOT start the render: tell the person what it makes and the price, and once they accept, call run_pipeline with the returned pipelineId and quoteId (no inputs; the prompt is saved). Clients that show panels put the price in front of them with a Start render button. Use 9:16 for Shorts, Reels and TikTok. With maxPriceUsd, a video over it is refused with its price rather than shortened. To extend or continue a video the account already has ("continue it", "make it longer", "the next scene", "what happens next"), pass its url as continueFromVideoUrl: the new clip opens on that video's exact last frame and keeps its shape, and prompt says only what happens next. Never answer one of those with a fresh clip from the prompt alone, which is a different shot that cannot be cut onto the end. For anything beyond one generated clip (clipping a long video, music, narration, editing a file) use a template, assemble_video or edit_asset instead. Needs the pipelines:write scope; the run needs pipelines:run.

The account's media library on a page of its own, newest first, for the person to browse and pick files from. Opened from ChatGPT's sidebar or beside a conversation; only the library panel calls it.

Turn a finished run (run_pipeline, assemble_video or edit_asset) into an editable timeline project and return its projectId: each shot, the narration, the music and the captions land on their own tracks. This is the step that creates a project. When the person asks to change a finished video and list_projects does not show it, call this with the pipelineId that made it rather than rendering it again from scratch. Each call opens a fresh copy. Needs the pipelines:write scope.

Prepare a post of one finished video to a connected YouTube channel or TikTok account, for the person to review and confirm. It posts nothing itself: clients that show panels put the video, the account and the post's settings in front of the person, and it goes out only when they press Post there (TikTok requires them to choose who can view it and to confirm its disclosures themselves). Call it only when the person asked to publish. The video must come from list_assets or a finished run's outputs in get_run, copied exactly; write a real title (on TikTok it is the caption, hashtags allowed). channelId picks the channel or TikTok account from list_connected_channels when more than one is connected; with none connected, call connect_channel first. A client without panels cannot post from here: build a pipeline that ends in a youtube-upload or tiktok-upload node instead. Needs the pipelines:write scope.

Publish a pipeline's current draft graph as an immutable deployed version. Publishing requires a fully valid graph (no errors or warnings) and makes the pipeline invokable via the public /invoke and /chat/completions APIs.

Whether an estimate_run_cost quote has been rendered yet, and the run's status. Called by the cost check panel, never by the model.

Render a timeline project to a finished video, exactly as the editor's Export does. Costs a few cents a minute of video in credits (no generation, just the cut). Renders in the background and returns a jobId: poll get_project_render until it finishes; the file also lands in list_assets. Call it once per edit. Needs the pipelines:run scope.

Start a pipeline run in the background and return its runId immediately. Video pipelines take minutes; poll get_run for progress. Runs consume account credits. inputs is keyed by entry node id (get_pipeline lists them as entryNodes): a Text Input node takes text, an HTTP Payload node takes a JSON value, and a File node takes a URL that overrides the file placed on the canvas, so a clipping pipeline can be pointed at a new source video per run without editing the graph. An entry node left out runs with the value saved on the canvas; one with nothing saved is refused, so pass it (or "" to leave it blank on purpose), and ask the user what it should say when the request does not tell you. A key that names no entry node is refused before anything runs or is charged. Before running a pipeline you built or changed in this conversation, call estimate_run_cost, wait for the person to accept the price, and pass its quoteId here: the run starts only if the pipeline is still the one quoted, and only once, so calling again with the same quoteId (a retry, a second "yes") returns the run already started instead of charging for another. Without a quote, pass a requestId of your own for the same protection on a retry. Every run renders every node again, so to add music, narration or captions to a video an earlier run made, pass its url from get_run outputs to assemble_video (musicPrompt composes a bed) or edit_asset rather than editing the pipeline and running it again.

Pause or resume a published pipeline's schedule. Pausing flips the flag the cron runner checks without touching the published graph, so the deployed snapshot stays an honest record of what was published. Resuming re-anchors the schedule to now, so it waits for the next real slot instead of replaying slots missed while paused. Requires the pipelines:write scope. Schedules themselves are authored as a schedule-trigger node (see get_node_type) and armed by publish_pipeline.

Put a timeline project back the way it was before the last edit_project. One step only. Use it the moment the person says the change was wrong, rather than reversing it by hand with more edits. Needs the pipelines:write scope.

Update a pipeline: rename it, change its description, or replace its node graph. For a graph change, read the current one with get_pipeline includeGraph and send the whole graph back, nodes and edges together, every edge naming the two nodes it joins and a port on each, e.g. {"source":"music","sourceHandle":"audio","target":"sequence","targetHandle":"shots"}. A graph with error-level issues is refused with every issue listed, and nothing is saved; settings you change are checked against get_node_type and the live model catalog the same way create_pipeline checks them. To add music, narration or captions to a video a run already made, pass its url from get_run outputs to assemble_video or edit_asset instead: a changed pipeline renders every node again when it runs, the video included, and charges for it.