add_ratios
ChatGPTAdd vertical aspect ratios (9:16, 3:4, 1:1, 4:5) to finished vertical videos: each new ratio renders the existing video again in the new frame, with the same shots, sound and subtitles, on the original's engine and resolution. It spends credits per added ratio: quote_ratios gives the exact price and the ratios that already exist, so call it and get the user's go-ahead first. Each call is a new order: it spends for every ratio it starts, and skips, without charge, a ratio the video already has (delivered or in progress). If no answer arrives, check get_batch or list_tasks before sending it again. Returns the submitted tasks, the skipped ones with a reason, and a batch_id to follow with get_batch.
analyze_template
ChatGPTAnalyze a TikTok video link into a template in the user's own library, without making a video: Riffkit downloads the video from that link, and each call makes a new template. tiktok_url is required: the link is the only source this tool takes. It costs no credits but is not open to every account: one that cannot use it gets a 403 and can pass the same link to remake_video instead. Returns a task_id to watch with list_tasks; when it completes the template appears in list_templates.
burn_subtitles
ChatGPTRender a new version of a finished video with its current caption list burned in. The new version takes the video's place: the library, get_video_link and a public share link of the video then show it (earlier versions are kept, but no tool switches the video back to one). Call it once, after all edits: there is no preview, so give the user the new version's link when the task is done. It costs no credits and returns a task_id and batch_id to follow with get_batch. A 409 means a burn for this video is already running, or (film_pending) it is made in sections and not all of it is made yet; at most 6 a minute.
cancel_task
ChatGPTStop a queued or running task. Seconds of video already rendered stay charged, and a task in its final steps cannot be stopped (409) and will deliver. A stop is final: retry_task does not take a stopped task (submit the video again instead), and stopping a remake's analysis also stops the video it was going to make. Use it only when the user asks to stop.
continue_video
ChatGPTMake more of a video made in sections (staged.pending in list_videos): next is the next section, rest all that is left, redo the last delivered one. An account held to the first section (staged_delivery in get_options) can only redo it. Each makes a new version of the same video (same asset_id), shown on its public share link too, if made; give it with get_video_link once done. It spends: say the price from staged.prices_shown, as credits, not money, get the go-ahead, then send its staged.prices figure as credits, with staged.delivered_through as delivered_through: without both, nothing starts. Finishing it also makes its ordered extra ratios, each at its own price. Each call is a new order: calling it again spends again. If no answer arrives, check get_batch or list_tasks before sending it again. 409 price_changed or confirm_needed: nothing started; say the price its message gives, get the go-ahead, then send its credits. 409 film_busy: in progress. 410: past staged.finish_by. 402 or 403: nothing started.
create_image_upload_link
ChatGPTMake a link to a Riffkit page where the user adds one image from their device: a product's picture (send product_id: it joins that product's images) or a reference image for the account's library (no product_id; reference_type, if known: worn, place, object or other). A file attached to this chat does not reach Riffkit, and Riffkit takes no link to an image: never ask the user for either. Always give the user url exactly as returned: open it, add the image, then say when it is added. Where the host shows apps, an upload box under this call takes it too and says it is added (as the user, in their language) or leaves that in the chat box to send. The page asks for no sign-in, so anyone who holds the link can add one image to this account for up to 90 minutes. Keep upload_id: once it is added, get_image_upload gives its id. One image per link; at 10 unused links (video and image) the oldest one still waiting stops working (429 if none is). A name the user gave becomes its name. Nothing is charged.
create_product
ChatGPTCreate a product from a name and a description (the description is the only source of product facts a video draws on), once the user has confirmed both. Returns the product with its id. Its pictures are files from the user's own device: create_image_upload_link with this id as product_id makes the page they add one on. The number of products an account may own is capped (creation_limits in get_options); past the cap the call is refused, so reuse an existing product.
create_upload_link
ChatGPTMake a link to a Riffkit page where the user adds one video from their device, as the source of a remake: a video of their own, or one from a site whose links Riffkit does not take. A file attached to this chat is not sent to Riffkit: never ask the user to attach, paste or send one here. Always give the user url exactly as returned: open it, add the video, then say when it is added. Where the host shows apps, an upload box under this call takes the video and says it is added (as the user, in their language) or leaves that in the chat box to send. The page asks for no sign-in, so anyone who holds the link can add one video to this account for up to 90 minutes. A video over max_render_duration (get_options) is turned away. Keep upload_id: once the video is added, call get_upload; when it reads ready, upload_id is the source for quote_remake, then remake_video. Each call makes a new link; at 10 unused links (video and image) the oldest one still waiting stops working (429 if none is). Nothing is charged.
create_video
ChatGPTMake an original video from a written creative direction (content_anchor, required: it is the whole script), with no source video or template. It spends credits per second of video rendered, one video per character: get the price from quote_create with the same arguments and the user's go-ahead first. duration_mode fixed with duration_seconds sets the length and so the cost; smart lets the length follow the content, up to 45 seconds and to what the balance covers. Always send duration_mode, and duration_seconds with fixed: a call without duration_mode runs as smart, whatever length the user approved. delivery: sections only when the user asks; continue_video makes the rest, never on an account held to the first section. Each call is a new order: calling it again spends again. If no answer arrives, check get_batch or list_tasks before sending it again. task_ids are the videos, one per character; follow batch_id with get_batch. A 402 means nothing was submitted.
get_batch
ChatGPTFollow one submission: every task of the batch with its status, progress and error, plus counts of completed, failed, running and queued. This is the progress check after remake_video, create_video, add_ratios or burn_subtitles; poll no faster than every 30 seconds. Tell progress in plain words from status and progress: current_step is an internal step name (a code, or a word in Chinese) and is never shown. A batch whose analysis task carries result.auto_generate_error made no video, even when that task reads completed. A finished task's result.asset_id is its video: read it with list_videos and hand it over with get_video_link. A task that reads dead was interrupted and can be retried.
get_credits
ChatGPTRead the credit balance: available (what a new video can use), held by videos still rendering, today's spend and the daily limit (daily_limit_shown null: none). Say amounts from the *_shown fields, as credits (Riffkit's own unit, not money): credits_shown 1000 is "1,000 credits". Call it when the user asks what is left, or before offering a retry.
get_image_upload
ChatGPTCheck an image added through the link create_image_upload_link made. Call it when the user says the image is added, not in a loop. status waiting: nothing has arrived, ask the user to finish on the page (seconds_valid 0: make a new link); refused_as is why the page refused the last file: too_large, bad_type, too_small, bad_shape (too long and thin), too_many_pixels, not_an_image, full (the product or library holds all the images this account may keep) or name_taken (another image of the product has that name: make a link with another); otherwise the same link takes another file. status added: the image is in: image_id for a product (an id for product_image_ids), reference_id for the library (an id for reference_ids). Its description (and name, unless given) is written from the picture shortly after, when Riffkit can: read it in list_products or list_references. status expired: make a new link. A 404: its record is gone: look in those lists before making another. It cannot show the image. Nothing is charged.
get_options
ChatGPTRead what this account can use before proposing a video: the video engines with their resolutions and which of them are locked for this account (offer only unlocked ones), the default engine and resolution per mode (default_video_pairs), the engine that swaps best (swap_recommended_video_backend), the longest source video accepted in seconds (max_render_duration), how many products the account may own, how many seconds of video the balance covers on the default engine (credit_cover), and whether its videos are made a section at a time whatever is sent (staged_delivery.forced sections: the account is held to the first section, the only one it can make). Takes no arguments.
get_subtitles
ChatGPTRead the caption layer Riffkit burned onto a finished video: the editable list of lines with their text, timing, position and colour. A 404 that mentions reconcile means no layer is recorded yet, so run reconcile_subtitles first. Text that is part of the picture itself is not in this list and cannot be edited.
get_template
ChatGPTRead one template: its summary fields plus extraction_summary (what happens in the source video, its spoken lines, what is on screen and the attention formula of each part). Use it to understand a template before writing content_anchor for it.
get_upload
ChatGPTCheck a video the user added through an upload link (create_upload_link). Call it when the user says the video is added, never back to back. status waiting: nothing has arrived yet (an upload still in progress reads waiting too), so ask the user to finish on the page; refused_as then says why the page turned the last file away: too_long (over max_render_duration in get_options), too_large, bad_type or not_a_video, and the same link takes another file. status ready: the video is in and seconds is its length; send this upload_id as the source to quote_remake, then remake_video, before expires_at. status used: it was already submitted as batch_id; for another video from the same source, send its formula_id as the source once get_template reads that template as analyzed (the first submit's analysis). status expired, or a 404: the link or the video is gone, so make a new link with create_upload_link. This tool cannot show the video. Nothing is charged.
get_video_link
ChatGPTGet a link that opens a finished video in a browser without signing in. Call it when a video is finished, and whenever the user asks for the video. asset_id is the video's id: a finished task's result.asset_id, or an id from list_videos. Returns url, seconds_valid (6 hours from the call), the UTC time until which the link works, and watermarked: true when this video's file carries Riffkit's small watermark. Give the user url exactly as it is, and say that anyone who holds the link can open the video while it works; it cannot be withdrawn before then. It opens the video's current version: after burn_subtitles, or once the link has stopped working, call it again for a fresh one. A 404 means this account has no finished video with that id. Nothing is charged and nothing about the video changes.
list_characters
ChatGPTList the digital characters (the on-screen person of a video) this account can use. Each has an id, a persona text and has_any_active_avatar; only a character where that is true can render. In a swap the character's photo replaces the source's person. That works from one clear, front-facing photo of one person, and from one image with that person's chest-up close-up on the left and the same person head to toe on the right, in the same outfit; a sheet of many small poses usually leaves the original face. One with example true is a Riffkit platform character that every account can use, not the user's own: offer it as a ready-made choice, never as theirs; its photo cannot be changed. This tool cannot show the photo. Characters and their photos are managed in the Riffkit web app, not here.
list_products
ChatGPTList the account's products with their images. A product's id places it in a video. appearance is how it shows on camera: object (held or shown), worn (wear_part says where), place (the scene itself), screen (an app or a site, on a screen) or null (the video decides). Each image has an id, a name and a description, and this tool cannot show the pictures: choose by those. A video with the product on camera uses its images: the ones sent as product_image_ids, or, left out, as many as fit, in their order. An image's media.id can also be sent as a reference image (reference_ids). In a swap only a product that has images changes anything.
list_references
ChatGPTList the account's reference images: pictures of an outfit, a location, a prop or anything else a video should show, kept in its Riffkit library. Each has an id, a name, a description and reference_type (worn, with wear_part; place; object; other; null: not set). Send the ids as reference_ids to remake_video or create_video; to say where or how one is used, name it in content_anchor with an @-mention (mentions). seedance_review refused: a Seedance engine cannot use that image; another engine can. This tool cannot show the pictures: choose by name and description. A new one comes from the user's own device through create_image_upload_link.
list_tasks
ChatGPTList the account's tasks, newest first, filtered by status, type or date. Use it to find recent or failed work, to follow a task that has no batch, and to check whether a submit went through before submitting again.
list_templates
ChatGPTList templates a video can be made from: the account's own and the public library. Returns items and total; only a template with status analyzed and analysis_prompt_is_latest true can be used. Prefer public ones (visibility public) and the most used (sort used_desc). bgm_status says which music choices a template has. Ask for about 20 at a time with limit and offset, and narrow with search or tags.
list_videos
ChatGPTList finished videos (send asset_role final_reel: without it, files uploaded in the web app are listed too; reference images are in list_references), each with its suggested caption and hashtags (the post text to publish with it). Filter by asset_id to read the video a finished task made. The answer carries no link to the file: get_video_link gives one for a video's id.
quote_create
ChatGPTPrice a Create before create_video, with the submit's arguments: duration_mode (with duration_seconds when fixed), video_backend, resolution, n_characters (one video per character) and delivery. Say amounts from the *_shown fields, as credits (Riffkit's own unit, not money): credits_shown 1000 is "1,000 credits". credits is the whole batch, or with delivery sections the first section's, and sections_estimate.whole_credits the whole video's, which an account held to the first section can't make; seconds is per video. exact true (fixed): that is the charge for its seconds. exact false: say "about" or "up to"; with smart the length follows the content: seconds is the longest the balance allows (at most 45), credits the most the batch can cost. seconds null: the balance is below the shortest video (min_credits). fits false: the balance is short: offer a shorter fixed length or another pair from get_options. locked true: the submit refuses this pair: offer one that is not. daily_limit_reached true: no more today.
quote_ratios
ChatGPTFor one finished video, list the aspect ratios its family already has (delivered or in progress) and the credits one more ratio costs. Say amounts from the *_shown fields, as credits (Riffkit's own unit, not money): credits_shown 1000 is "1,000 credits". reframeable false means no ratio can be added to this video (a landscape video, or one whose original is gone). Call it before offering ratios and before add_ratios.
quote_remake
ChatGPTPrice a remake before remake_video, from a template (formula_id), TikTok link (tiktok_url) or added video (upload_id). Send the submit's arguments: mode (the user's choice; its default is only what a call without it runs as), video_backend, resolution, n_characters, (adapt) n_ratios and delivery. Say amounts from the *_shown fields, as credits (Riffkit's own unit, not money): credits_shown 1000 is "1,000 credits". credits: the whole batch, or with delivery sections the first section's (sections_estimate.whole_credits: the whole video's). Say "about" if exact is false, for several ratios, for a swap over one render (15 s; 30 on Seedance 2.5), or for a Swap on MiniMax H3 made in one go (long change lists can add calls). source_seconds null: credits is a minimum; probe busy or sections_pending true: ask again. over_cap true: no swap of it. locked true: the submit refuses it. daily_limit_reached true: no more today. alternatives: usable pairs, cheapest first; fits false: fitting_templates has up to 3 that fit.
reconcile_subtitles
ChatGPTRecord the caption layer of a finished video that has none stored (get_subtitles answered 404), from the video's script; run it even when you only mean to add lines, or the next render drops the lines the video already shows. It costs no credits and returns a queued task_id to watch with list_tasks, or status exists when a layer is already there. At most 3 every 10 minutes. 409 film_pending: a video made in sections takes caption changes only once all of it is made.
remake_video
ChatGPTRemake an existing video as an adapt or a swap. Always send mode; when the request does not say which, ask before quoting: never assume adapt (its default is only what a call without it runs as). One source: a template (formula_id), a TikTok link (tiktok_url) or a video the user added (upload_id). A swap must change at least one thing: a character, a product with images, a reference image or a written content_anchor. It spends credits per second rendered, one video per character and per extra ratio: get quote_remake's price for the same arguments and the user's go-ahead first. delivery: sections only when the user asks; continue_video makes the rest, never on an account held to the first section. Each call is a new order: calling it again spends again. If no answer arrives, check get_batch or list_tasks before sending it again. Its mode: generate = videos queued (task_ids); analyze_then_generate = analysis first. 402: nothing was submitted. 429 server_busy: nothing was created; wait 30 seconds, submit once.
reset_subtitles
ChatGPTDiscard a finished video's saved caption edits and go back to the lines recorded when it was made. The discarded edits cannot be brought back. It costs no credits and does not change the video itself. 409 film_pending: a video made in sections takes caption changes only once all of it is made.
retry_task
ChatGPTRun a failed or interrupted task again, within 24 hours of its first submission. It reuses the parts that finished and charges only what it renders again, up to the full video's price (quote_remake or quote_create for the same arguments; on MiniMax H3 a Swap can cost a little more), so say that and get the user's go-ahead first. Each call is a new order: it runs the task once more and spends for what it renders again. If no answer arrives, check get_batch or list_tasks before sending it again. A completed analysis with result.auto_generate_error insufficient_credits submits its video, with its original options. A refusal restarts nothing: 410 too old (offer a new submit with the same options), 409 still shutting down (wait a minute, try once more) unless its code is not_submitted (say its message, fix that, submit again), 400 not failed (read its status). Retrying a TikTok analysis downloads it again; retrying a caption render or section replaces the video a public share link, if one was made, shows.
save_subtitles
ChatGPTReplace a finished video's caption list with the complete list you send: an entry left out is deleted from the video, a new object is added. Start from get_subtitles, change only what you mean to change, and keep every other entry (graphic layers too) and every key under params. A line whose align_status is dropped_conflict is not in the video now and any render adds it: retime or delete it first. Never add text that is already part of the picture: it would show twice. The list saved before is replaced: reset_subtitles goes back to the lines recorded when the video was made, not to an earlier save. Saving costs no credits and does not change the video until burn_subtitles. 409 film_pending: a video made in sections takes caption changes only once all of it is made.