- Brand
- Donkey Cut
- Category
- Content & Design
- Primary Subcategory
- Pending
Integration details
Description
Donkey Cut is an open-source video editor. Import footage, trim and arrange clips, add captions and titles, and preview your edits. Open existing projects or start a new video, undo changes as you work, and export the finished result when you're ready. Open Donkey Cut from the sidebar or beside a conversation to pick a project, or @-mention a project in the composer to work on it.
- Integration type
- Plugin
- Verification status
- Not applicable
- Platform
- ChatGPT
- Primary Subcategory
- Pending
- Secondary Subcategories
- None listed
- Brand
- Donkey Cut
- Access
- Account required
- First tracked
- 2026-11-20
- Tool count
- 160
- Market
- US
The Primary Subcategory used for this profile’s headline score.
Other Subcategories where the Integration is listed.
Not discoverable in ChatGPT yet
ChatGPT now suggests Plugins on its own when they match a user's request, but not every Plugin is being surfaced yet.We haven’t seen Donkey Cut suggested yet. Sign up and we’ll track it, and your Discoverability Score will appear here once ChatGPT starts surfacing it.
What discovery looks like

Get alerts for Donkey Cut
Get updates when Donkey Cut’s Discoverability Score or category rank changes.
Competitive lineup
160 tools agents can invoke
The connected account's AI credit balance, cloud storage used against its allowance, and plan. Editing, previews and exports never spend credits.
account_status
Put a project asset on the timeline, the same way the user dragging it in would: a video or image lands on video track 0 (at `start`, inserted at `index`, or appended at the end; a taken spot slides it right), audio lands on the soundtrack (at `start`, default the playhead). Asset ids come from `media` in editor_state — imports, attachments, and chat media alike. Call it only when the user asked for the media in the cut ("add my beach photo", "stitch these into a movie"); otherwise media stays on its card or panel for them to drag. Pass `blocks` instead of an asset to lay out a cut whose footage does not exist yet: one block per shot on track 0, each the length that shot runs, labelled with what belongs there. That is how a video you watched becomes a timeline — the cuts land at their real times, titles and sound go on top, and the person fills each block later. Blocks own no file and store nothing; footage dropped on one takes its place and its length, and replace_item does the same from here. A block runs one frame (1/60 s) or longer, so detect_cuts' `shots` go down as they are, flash cuts included — pass each as its `from` and `to`, which land every cut on its frame, where lengths summed from times written to the millisecond drift a frame late; one call takes up to 160, and a longer list goes in more calls with no start, each appending after the last block. Pass `spans` to cut one source into a run of clips — the moments of a talk worth keeping, with everything between them left out, or a video cut at its own shot boundaries when its picture is what plays. add_clip lays down the whole file; an item another timeline already has ("Main's music", "the same intro as Main") is copied with copy_from_timeline, which keeps its trim and mix. It can move, overwrite or delete what the project already holds.
add_clip
Add a time-ranged effect element over the cut: a zoom into part of the frame, a picture treatment (grain, vhs, glitch, blur, vignette, lightleak, lightbars, flash, shake, negative, huecycle), a graded look (vintage, horror, halation, tech, noir, pastel, blockbuster, dreamy), or an audio treatment (echo, reverb, muffle, telephone, deep, bright, wobble, crush) over the sound. A picture effect filters everything visible under its window (start..end); an audio effect treats everything audible under it — clip sound, upper tracks and soundtrack together. They stack. glitch is clean footage broken by runs of corrupted frames — dark pixel-stretch smears, the picture doubled sideways over an orange burn, teal close-ups, blown-out flashes — the glitch ending of a teaser, where amount is how often it hits. A glitch pinned to one kind (glitch "smear", "split", "tint", "blowout" or "rgb") hits with it on every frame; "rgb" pulls the color channels apart, red down and blue up — a 2–3 frame rgb glitch is the RGB-split hit of a collapsing title or HUD. lightleak drifts a warm bloom and light streaks over the picture for as long as it is up; with leak "burn" it is a film burn played once across the element's own length: it climbs from the bottom edge behind a hot orange front, flares near white, settles orange and hands the picture back in its last tenth — the burn-out of a teaser, a 0.4–0.6s element over the end of the last shot, amount 1 for a fully opaque burn. With leak "scorch" it flashes film burn through the picture: every frame maps the picture onto a saturated hot tone by brightness — yellow, orange, or red over pink — across the whole frame or a soft-edged patch of it, a new tone and patch each frame; short 2–12 frame scorches over the last shots, amount 1, are the burn-through flicker of a teaser's ending. With leak "film" it is the film-strip flash over a cut, played once across the element: the picture washes warm orange, a brighter band glows across the lower middle and the strip's sprocket holes blaze cream along the top edge, full through the middle of the element and gone by its ends — a 3–5 frame element centered on a cut, amount 1, is the film-strip light-leak transition of a recap montage (one per section change). With leak "char" it is the burn's climb in dark stock: a hot orange front rises from the bottom edge, the frame cools through ember to black behind it, a thin bright light line crosses, and the picture comes back in the last tenth — never a pale flare; an 8–10 frame element, amount 1, over a black card's end and the next shot's first frames is the dark film-burn handover of a recap opener. lightbars is the streaming-service sting: the camera flies down a ribbon of glowing vertical lines (reds, oranges and pinks on the left, blues on the right) across the element's own length — it opens as one narrow warm column just left of the frame's middle (x about 0.46, a twelfth of the frame wide), bursts out to fill the frame about a quarter of the way in, keeps flowing outward as deeper lines spread after the near ones, flares red and pink about three quarters in, then leaves one red line just right of the middle that widens and sweeps off the right edge as the element ends, on black. Bars add light onto the picture, so over black (no clip under it) they are the whole picture; a 1.6–1.7s element, amount 1, right after a logo reveal whose last red vertical stroke stands where the column opens. flash pops the picture white at the element's start and decays in about 0.4s; tone "black" dips it dark instead, and a strobe rate holds the tone on and off that many times a second for the whole element — a black strobe at 5–6 with amount 0.9–1 is the dark beat-flicker over a teaser's last shot. rhythm "flicker" deals each pulse its own strength and leaves some dark: an uneven exposure flicker, a white flicker at rate 12–15 and amount 0.15–0.25. To flicker one shot inside its mask, give the clip the flash through set_clip_effects. negative flips every colour for the whole element; with a rate it strobes between the negative and the picture, and at 15 on a 30 fps cut it alternates every frame. Tasteful default: one effect at a time, amount under ~0.5. It adds new items and leaves every existing one where it was.
add_effect
Put a project video or image asset on an overlay video track, composited over track 0: tracks stack bottom-up, and the topmost full-frame clip covers everything below. Pick a layout to share the frame — halves for a split screen, pip for picture-in-picture. Asset ids come from `media` in the editor state. An image over a talking head belongs to the line that speaks of it: start it as that line starts and end it as the line ends. It can move, overwrite or delete what the project already holds.
add_overlay_video
Add a vector shape overlay (rect, ellipse, triangle, diamond, star, heart, hexagon, line, arrow, doodle). Position is the shape center as frame fractions; w/h are frame fractions too (a line/arrow's h is its stroke thickness). Rotation gives lines and arrows their direction. A doodle is animated graffiti in translucent paint: inside its box (default: the whole frame) it paints one hand-drawn mark — a dry-brush smear, a painted X, a burst, a tall painted bar, a brushed ring, a pair of fat loops — often with a thin hand line beside it (a tall oval, standing strands, a scribble), and deals new ones 10 times a second, each in the fill or one of its inks (default: the teal, cream, red, orange and white graffiti set). Put it on a row under the titles to paint behind them, or between titles to sit over one line and under another. Pass `shapes` to place a stretch's shapes in one call. It adds new items and leaves every existing one where it was.
add_shape
Add a sticker overlay from a project image asset (asset ids come from `media`; sticker uploads carry origin "sticker"), or draw one from SVG markup you write: pass svg in place of asset_id for a vector graphic no shape covers — a UI icon (download arrow, stacked episodes, speech-bubble subtitles, skip-next), a mouse pointer, a loading-spinner arc, a badge with lettering, a logo mark, line-art doodles around a title (sparkles, starbursts, fireworks, swirls, hearts drawn as thin white strokes). The markup is drawn to a transparent PNG (1024 px on its long side, keeping the viewBox's aspect), saved as an origin-"sticker" asset and placed; the result carries its assetId to place it again without redrawing. Width is a frame-width fraction; height follows the source's own aspect unless h sets it. It adds new items and leaves every existing one where it was.
add_sticker
Place a run of text on the timeline in one call — plain lines timed to speech, a lyric video, a kinetic-typography passage, a quote sequence. Design is opt-in: with no `look` the run comes out plain — one readable face, one place in the frame, a short fade, no cards, no moves, and the project's frame color untouched. That is what a bare "add the text" or "put the words on screen" asks for. Name a `look` when the user asked for a designed run (a lyric video, kinetic type, a style, a vibe, "make it interesting"): `look` carries the design of one line (frame color, cards, type, entrance) AND the ensemble the run walks across its whole length: where successive lines land, which faces they rotate through, which entrances, and what each line does while it holds. So one such call already produces a varied, composed run without a hundred repair calls after it. Lines come from `lines` ({text, start, end} in timeline seconds), or from the caption track with from_captions when a sync already timed them. Each line keeps the start and end you give it, on its frame, and runs one frame (1/60 s) or longer, so a label per shot of a fast cut lands on that shot's frames however short; a line under 0.2 s cuts in and out (no entrance or exit, which would leave it blank on so few frames). In a designed run, mark the loud lines with `emphasis: "hero"` and the quiet ones `"whisper"`, and label passages with `section` ("verse", "chorus") — a new section restarts the type and color rotas, so a chorus does not look like the verse before it. Anything you set per line (font, x/y, rotation, in_style, move, color, size) wins over the ensemble. The words land on `lane` and each card on the row under them. A look that paints a frame color sets the project background to it unless background is false; the plain and over-footage looks leave the background alone unless background is true. Look ids, layouts and moves are in the text-videos and text-creativity skills. It can move, overwrite or delete what the project already holds.
add_text_sequence
Add a text title overlay. Position is the text center as a fraction of the frame (x,y in 0..1; y=0.42 is the default band). Size is px at 1080-wide. Font ids come from the graphics skill (system set + the bundled Google families). A line wider than the room its anchor leaves is broken onto more lines when it draws, so a title always sits inside the frame — write the words and pick the size the design wants. Pass `titles` to place a stretch's titles in one call. It adds new items and leaves every existing one where it was.
add_title
Re-time captions or a run of text elements onto the speech in the cut's own mix — the waveform, not the transcript. It renders the audible mix, reads a 10ms energy envelope to find where speech actually starts and stops, and moves each edge to the speech edge it belongs to; an edge with no audible boundary near it (mid-sentence, or under a bed of music that never lets up) keeps the time it had. Ids, text, word timings and order all survive, and it is one undo step. This is the answer to "the subtitles are off", "sync the text to the audio", "the words land late" — never retime cue by cue with update_cue guesses, and never re-transcribe (that throws away the user's wording). Follow a lyric sync, a hand-edit, or a run built with add_text_sequence from_captions with it. The result says whether the audio could testify at all: `evidence: false` means the mix offered no readable edges and nothing moved, which is not the same as captions already being in sync. It overwrites an existing value; the same call again gives the same result.
align_to_audio
Put one of the user's saved color grades (editor_state.savedGrades, or library_list templates carrying a grade) on a video clip, replacing the clip's whole grade. Pass ids or all_clips for several clips as one undo step. It overwrites an existing value; the same call again gives the same result.
apply_saved_grade
Transcribe (if needed) then REWRITE one subtitle track's captions into punchy social-video captions — short lines that fit inside the video frame (they may wrap onto two lines but never overflow), a few emoji, a curiosity-hook opener. style: clean | hook | punchy (default hook). Cue timings are preserved. It replaces the track's existing text wholesale — for a targeted edit (removing filler words, fixing one line), edit the cues with update_cue instead. It can move, overwrite or delete what the project already holds.
captions_generate
Render one frame of the cut as an image — the whole picture an export would write at that moment: footage, transitions, effects, elements and captions. Defaults to the playhead. Read-only: it changes nothing in the project or the account.
capture_frame
Read render progress, or get a fresh playback URL for an existing preview. Returns expired when the preview needs rendering again.
get_preview_status
Finish a call that answered with a running job (an import, an edit, an export): read its progress and, once done, its results.
get_job_status
Read an export's progress; when it is done the Donkey Cut card offers the download.
get_export_status
Check factual claims against the web: each claim is searched on Google and comes back with a verdict (supported, contradicted, mixed, or unverifiable), the corrected value when the claim is wrong, a one-line note on what the sources say, and the pages the search found, each with its title and URL. A verdict needs several sources behind it, so a claim the search barely covers comes back unverifiable and says how many it found. Check every figure the narration or a title states — a number, a date, a price, a name, a release — before you show it on screen, passing each as its own specific claim worded the way the video says it. Report every contradicted, mixed or unverifiable claim to the user plainly, with what the sources say and where; change their words only when they ask. Sources come only from the search, so quote them as given. Spends credits: one web search per claim. The output's searchSuggestions are the Google searches behind the verdicts: show them to the user as links, with their text and URLs as given, wherever you report the results. Read-only: it searches the public web and changes nothing.
check_facts
Check the cut against the thing it was built from, in numbers and in pictures. Every frame is scored by `diff`: the mean difference per pixel between your frame and the source's, 0 (the same) to 255, read at one small size so a score means the same thing in every call; under 5 reads as the same picture. mode sweep scores every step of the cut (or from/to) with no pictures and returns the median, p95 and max with the worst stretches, each with its peak frame and a 4×4 grid of where in the frame it differs, and `edges`: stretches whose difference runs along whole edges of the frame while the middle matches — a border, band or letterbox — listed under target too, since thin bars barely move the mean. The picture box is already cut out of any app or bars around it, so a band inside it is part of the picture: build it, with shapes or a smaller block. `titles` names each title whose letters read another colour than the source's under it, on every frame it is up: `from`-`to` and how many `frames`, with `ink` yours and `sourceInk` the source's at the worst one, null where that side shows no letters: on yours, something hides them there (a picture effect, a flash too, treats titles as well as footage, and an element on a row in front covers them) or the title is not up yet; on the source's, yours is up early or the source's are washed out. A frame score at this size barely moves for any of it. A decoder that fails mid-read is replaced and the read goes on: `lost` names source frames no decoder read, and a source that stops decoding ends the sweep at `coveredTo` with `stopped` saying where and why. mode moments (the default) takes up to 8 `times` and hands back each as the source's frame and yours side by side, with its score and grid. Either mode says when a frame matches the source better a few frames away: `shift` is that distance, and a positive one means move what is there later by that much. This is how a replica is verified. The loop: sweep, look at the peaks of the worst stretches and the edges in moments mode, fix what differs, sweep again — until the median is under 5 and no stretch in worst or edges stands out. Blocks standing in for footage keep a difference no edit removes, so read those by the grid cells over your titles and shapes. Pass `times` as timeline seconds, or {at, source} pairs when the cut sits at a different second than the source does; `offset` maps every bare second and the whole sweep (source second = timeline second + offset). Only the source's picture box is held against your frame (find_picture), so a reference recorded inside an app scores its picture alone. Read-only: it changes nothing in the project or the account.
compare_to_source
Convert project media to MP4 — H.264 picture, AAC sound — replacing each asset's file in place, so clips already cut from it keep playing. This is the fix for footage that previews black or refuses to play: a phone's HEVC .mov, a screen recorder's ProRes, a camera file with raw PCM sound. It is also the whole answer to "turn these into mp4": the user drops the files on this chat, you convert them, and each converted file is on its own card right here for them to download or drag in — nothing to go looking for. A file already in Media stays in Media. Streams that already fit the container are copied packet for packet, so a .mov of H.264 converts in seconds and loses nothing, and a file that is already an MP4 of those streams comes back untouched. `mode` "reencode" rewrites the picture even when it fits: the fix for H.264 that stays black after a plain conversion. `max_height` shrinks the picture at the same time (1080 for a 4K source that only needs to be a timeline clip). Conversion runs automatically through the project backend. A browser missing a required codec uses hosted preparation and saves the result back into its own project. It overwrites an existing value; the same call again gives the same result.
convert_media
Copy a video clip's whole color grade — preset, sliders, curves, wheels, hue bands, LUT and intensity — onto other clips, as one undo step. This is "apply to all": pass all_clips for every clip on the timeline, or ids for a chosen set. The source clip's grade replaces whatever the targets wore. It overwrites an existing value; the same call again gives the same result.
copy_color_grade
Copy items another timeline holds onto the open one, exactly as that timeline has them: a soundtrack clip keeps its in/out, volume, fades, speed and sound treatment; clips, elements, captions and transitions keep every property, and several items keep their spacing. This is how "Main's music" or "the same title as on Main" lands on this timeline. A parked timeline's soundtrack is in editor_state project.timelines; inspect_project with `timeline` lists all of its items. The source timeline is left as it was. A copy that would overlap an item on its row slides right past it, and the result gives that copy's askedStart and why. It adds new items and leaves every existing one where it was.
copy_from_timeline
Copy files from a reference project into this one without placing anything: a music track, a sticker, a photo, a clip the user wants to reuse. Takes the reference's asset ids from read_project. Each copy keeps its notes, transcript and beat grid, lands on a card in this chat, and is a project asset from then on — add_clip places it when the user asks for it in the cut. It adds new items and leaves every existing one where it was.
copy_project_media
Create an empty cloud project. aspect is the output frame as "W:H" — 9:16 for TikTok, Reels and Shorts, 16:9 for YouTube, 1:1 square (default 9:16). Free.
create_project
Create a custom sticker from an idea: the hosted image model draws it (signed in, spends credits), the background is removed (people on-device, other subjects via hosted matting), a white die-cut outline is added, and it lands as an origin-"sticker" asset placed on the timeline at the playhead. Takes ~10-20s; the tool returns when the sticker is placed. It adds new items and leaves every existing one where it was.
create_sticker
What each hosted generation costs right now, in credits (1,000 credits = $1): a video by resolution and length in seconds ("auto" is the model's own length), one image, a music track by length, and a minute of voiceover; plus the account's credit balance. Call it before quoting a price or when the user asks what something costs or how much they have left. Chat and edits bill by use and have no set price. Needs the user signed in to Donkey. Read-only: it changes nothing in the project or the account.
credit_prices
Remove project assets and every timeline clip that uses them — the Media panel's trash. Pass asset_id for one, asset_ids for several in one call, or unused:true to clear every asset no timeline uses, open or parked (leftover imports, replaced footage, reference images) without touching placed media; another chat thread's unplaced media is out of this chat's reach, and the sweep counts it as heldByOtherChats. Removed media does not come back with undo, so call it only when the user explicitly asked to remove that media, and report how many assets and clips went. It can move, overwrite or delete what the project already holds.
delete_asset
Delete a subtitle cue. It can move, overwrite or delete what the project already holds.
delete_cue
Delete a timeline item and its explicit group by id. Other items keep their timing. The deleted footprint becomes a gap; remove_gap closes it. It can move, overwrite or delete what the project already holds.
delete_item
Detach Audio: lift a clip's sound onto the soundtrack track (mutes the clip) so it can be edited independently. Select the clip first or pass its id. Pass assetId instead to put a source's whole track on the soundtrack with none of its picture placed; the clip still plays that source, so a reference that came from a link brings its sound in as its own file instead (import_media audio_only), and the reference stays off the timeline. It can move, overwrite or delete what the project already holds.
detach_audio
Read a source's musical beat grid — the tempo and where each beat lands — for cutting to the music. Returns bpm and beats in SOURCE seconds; with clip_id it also returns timelineBeats, the beats inside the clip's trimmed range mapped to timeline seconds, ready for split_at. The grid persists on the asset: its clips draw the beats as yellow dots and every drag or trim snaps to them, so one detection serves the whole edit. A stored grid comes back as-is — the user can hand-edit the dots, and their edits hold, and a grid they have edited reports bpm 0 because the tempo is theirs now — so pass regenerate only to re-scan and replace it. Detection always reads the whole source; from/to just window the reply. It overwrites an existing value; the same call again gives the same result.
detect_beats
Find every hard cut in a stretch of a video source, to the frame. Reads every frame between from and to at a few dozen pixels, scores how much of the picture changed since the frame before, and reports each frame that opens a new shot: `t` in SOURCE seconds to the millisecond (the new shot's first frame), its `frame` index at the source's `fps`, and `change`, the percent of the picture that changed — near 100 is a new shot, 10-30 a card or a block of type swapping over the same background. A flat colour cut to a near one counts. `shots` lists the stretches between the cuts with their length in frames. `changes` lists what changes inside a shot over a picture that stays: a word appearing, a word swapping fill for outline, a shape popping in, a face switching — each its first frame (`t`, `frame`), how many frames it runs (a fade-in runs several), its `change` in percent and its `box`. A change marked `flicker` flips back and forth frame by frame over its run — a strobe, a cutout flashing to its negative — so every frame of it differs from the one before and returns to a look two or three frames old; read its frames one at a time. A fade too faint for any one frame to show — small type easing in or out over half a second — still counts: its `frame` is the first step it takes and `frames` runs to where it settles, so a title's fade in, fade out and their lengths come from here. Time titles, their fades, outline swaps, shape pops and font_cycle_switches from these. watch_video lands a frame in every shot and change this reads, so read type after this pass. watch_video's sceneChanges come from samples a step apart and lose a shot shorter than the step; this reads every frame, so a five-frame shot in a fast montage is found. Run it before blocking out a reference: add_clip `blocks` takes one block per shot at that shot's length. Hard cuts only — a dissolve or a fade between two shots changes a little each frame and reads as no cut. A fade of the whole picture into black or white, or out of it, is listed in `fades`: its start `t`, `seconds`, `fade` (to or from), `tone`, how far it goes (`amount`) and the curve it runs along (`ease`), each fitted to every frame — exactly what add_effect flash takes, so a fade to black over the end is set from here, never from sampled colours. Up to 120s, 80 cuts and 120 changes a call; when `truncated`, call again from `coveredTo`. A source with no picture box yet has it found first (find_picture) and kept, and every frame is read inside it, so a card that changes a small part of a recorded frame still counts as the change to the picture it is. It saves the assistant's own analysis on the source asset and leaves the edit as it was.
detect_cuts
Find silent stretches in a source's audio — dead air, long pauses, gaps between takes. Returns [{start,end,duration}] in SOURCE seconds, plus each one's timeline times when clip_id is passed. Cheap and image-free; find_filler finds the filler words, then cut with split_at / trim_clip / delete_item — place speech cuts inside these spans (cue timings drift from the audio), and read the watching-and-cutting skill for the pacing rules. Read-only: it changes nothing in the project or the account.
detect_silence
Open a cloud project initially, switch projects, or recover a missing card. Keep the existing card during edits and preview checks: reopening loads a new card from the saved project, which keeps every edit. The editable card holds the full editor, timeline, media panel, inspector and preview. A read-only connection sees the preview; use render_preview when its revision is stale or missing. With no projectId, show the projects home, where the user opens or starts a project or browses their library; the card then tells you which project it shows. A deleted project answers view "missing" and the card offers to create a new one.
open_project
Render the saved project to an MP4 the user downloads from the Donkey Cut card. preset: original | tiktok | fast | light (original matches the footage; tiktok is best quality 1080p; fast is a smaller 1080p; light is a 720p draft). loudness masters the mix to an integrated target under a true-peak ceiling: off (the mix as it plays), social -14 LUFS (streaming and social platforms), podcast -16 LUFS (spoken word), broadcast -23 LUFS (EBU R128 television); the true-peak ceiling is -1 dBTP; omitted masters to off. stems: true also writes one 24-bit WAV per lane (dialogue from the video clips, then each soundtrack lane), full length and unmastered, zipped as "<name> stems.zip" beside the video in the project's exports. Free; the files count against the account's cloud storage and are listed in the project's exports. A render can outlast this call — finish it with get_export_status.
export_video
File a project asset where the user keeps things: to "media" moves created media (generated, chat, voiceover…) into the Media panel by clearing its origin tag; to "library" copies any project asset into the shared Library for reuse. The same moves as each card's "…" menu — make them when the user asks. It overwrites an existing value; the same call again gives the same result.
file_asset
Search the connected user's cloud projects by name for the composer's @-mention menu.
find_projects
Find the filler words in a subtitle track's transcript — um, uh, a stranded 'like' or 'you know', stutters, repeated words — each judged in its sentence. Returns [{cue_id, text, start, end}] in TIMELINE seconds, neighbouring filler words merged into one span so each entry is one cut, (the cues' own word timings), plus each word's source times when clip_id is passed, so you can cut the speech with split_at / delete_item / trim_clip or tidy the captions with update_cue. Needs a transcribed track (subtitles_generate) first. Words marked estimated sit in cues that lost their word timings. Read-only: it changes nothing in the project or the account.
find_filler
Find the moments in a long source worth cutting a short from, best first. Reads what is SAID over the source — its transcript, or the project's caption cues where they cover it — and ranks every stretch of it on three things: whether it stands on its own to someone who lands on it cold, whether its opening holds them, and whether it finishes the thought. A talk or an interview holds a handful of these and an hour of material that only makes sense in place; this is how the handful is found without watching all of it. Each result is one or more spans in SOURCE seconds with the words over them — two spans means two moments that belong together with the middle cut out, and `add_clip` with `spans` lays that down as one run of clips. The source needs a transcript: listen_audio starts one and it fills in behind you. Ranking reads the words alone, so a moment that reads well can still be someone glancing away — watch_video the spans before you commit to a look. Nothing is written to the timeline by this call. Read-only: it changes nothing in the project or the account.
find_highlights
Find project media by name: every asset whose name or file name contains query (any case), optionally of one kind, with its id. The context snapshot lists at most 60 media items (mediaTruncated says when it cut the rest), so use this to reach the others — say the reference images a person just uploaded to a long project. Pages: pass the answer's next as offset for more. Matches another chat thread made and hasn't placed are hidden from this chat; heldByOtherChats counts them, so never call such a file missing. Read-only: it changes nothing in the project or the account.
find_media
Find where a video's picture sits inside its frame: the part that changes over time, apart from letterbox bars or the app a screen recording shows it in — a phone recording of an editing app has its picture across the middle, with buttons and a timeline around it. Reads frames spread over the source (or from/to) and returns `picture`, the box as centre and size in frame fractions, its `aspect`, and `active`, the share of the box that moved. The box is kept on the source: detect_cuts, sample_color, track_element, suggest_font and compare_to_source read inside it from then on, and the x, y, w, h they take and return are fractions of it, so they land on the cut's frame as they are. detect_cuts finds it on its first read of a source. Pass `box` to set it yourself, or "full" for the whole frame, when the one found is off. It overwrites an existing value; the same call again gives the same result.
find_picture
Extract the video frame at a time (default: the playhead — what the user is looking at) as a still clip and insert it into the timeline. Default insert position is index 0, making it the first thing viewers see (a cover/hook frame). It can move, overwrite or delete what the project already holds.
freeze_frame
Generate an AI image from a text prompt (Donkey's hosted image model). Use for B-roll, cover frames, or backgrounds the user doesn't have footage for; when the user asks you to write or improve the prompt itself, put it in chat and wait for them to ask for the image. reference_asset_ids attaches project media the render should draw from (the user's attached references, a clip to restyle) — the prompt is recomposed around them; an audio reference contributes what it carries (its speech transcribed, its sound described) to that recomposed prompt. Returns when the image has landed. The image previews as a card in this chat, where the user can expand it, drag it onto the timeline, or file it into Media or the Library from its "…" menu; pass add_to_timeline:true (or an index) only when they asked for it in the cut. Needs the user signed in to Donkey (spends their credits). It can move, overwrite or delete what the project already holds.
generate_image
Generate a music track from a text prompt (Donkey's hosted music model, Gemini/Lyria) — a full song with sung vocals, or an instrumental bed. Describe mood, genre, instruments, and tempo. By default it renders an instrumental bed (instrumental:true); pass instrumental:false for a full song, where the model writes and sings its own lyrics — or include your own with [Verse]/[Chorus] tags and a singer description in the prompt. length "clip" is ~30s (default), "song" a longer ~2-minute track. reference_asset_ids matches a track to the user's own media ("a song that matches this audio", "score the tone of this video"): pass the project asset ids — an audio track to emulate, or video/images whose mood to carry — and a multimodal pass folds a description of that sound into the prompt (the model itself never hears the audio, so always pass the reference rather than describing it yourself). When you match an audio reference that has singing, pass instrumental:false so the new track sings too. When the user asks you to write or refine the lyrics or brief itself, put it in chat and wait for them to ask for the music. It RETURNS once the track has landed and previews as a playable card in this chat; pass add_to_timeline:true (or a `start`) to drop it on the soundtrack when the user asked for it in the cut. For "background music for this video", read the timeline (videoTrack, project duration) to fit the mood and length, keep it instrumental so any speech stays on top, and set those clips' `duck` so the bed dips under them. This is SUNG music — a spoken narration is voiceover_generate. Needs the user signed in to Donkey (spends their credits). It adds new items and leaves every existing one where it was.
generate_music
Read a project asset's file name, kind, readable fileSize (KB, MB, GB), exact sizeBytes, duration in seconds, and pixel dimensions. Present fileSize in replies; include exact bytes only when asked. Use this for file-size questions when sizeBytes is absent from the media snapshot. Reads file metadata across browser, Mac, and cloud storage. Read-only: it changes nothing in the project or the account.
get_asset_info
Group the selected timeline items, including video, audio, text, shapes, captions and transitions. Use select with additive:true to build the selection first. New items start ungrouped. Selecting any group member selects the whole group; drag a member to move the group. It can move, overwrite or delete what the project already holds.
group_items
Bring footage into a cloud project: files the user attached to the chat (files), or links (urls) — TikTok, YouTube, Instagram, an X post, a web page, or a direct video/audio/image link. Every file lands as a project asset with an assetId for add_clip. Free; the bytes use the account's cloud storage. A long download can outlast this call — then the answer carries a job to finish with get_job_status. audio_only keeps just the soundtrack of a link.
import_media
Move an item into a new row before a displayed row in its own timeline band, like dropping between rows. Display rows count from the top starting at 0; the row count inserts after the last row. Empty source rows collapse. Timing stays fixed and the edit is undoable. It can move, overwrite or delete what the project already holds.
insert_item_row
Read a project's full editor state — media assets with ids, durations, transcripts and notes; the video tracks with clip ids, trims and gaps; soundtrack, titles, captions, aspect. Call it before editing and after an edit you want to verify. Free.
inspect_project
Copy a Library asset into the project; pass share_link for an accessible shared Library asset (it appears in `media` and previews as a card in this chat). This is the import step "library"-scope attachments need before editor tools can touch them. For one file inside a shared snippet, pass its snippet id and template_file. Shared linked files copy into your Library and return their usable id (fontId for fonts). Your own linked files return their existing id from the registry. Pass add_to_timeline:true (or start/index) only when the user asked for it in the cut: video/image land on track 0, audio on the soundtrack. It can move, overwrite or delete what the project already holds.
library_add
Cloud Library uploads accept original video and audio files. The cloud prepares playable media automatically and retains the original for download. List the shared Library — reusable media saved across projects: folders (nested; a folder's parentId names the folder it sits in), assets (video/audio/image, the account's own font files, and its LUT files — .cube/.3dl, offered to every clip as "lut:<key>" via set_color_lut), and snippets (saved arrangements of clips, overlays, titles, and captions; their kind is "template"). An asset with `origin` "inspiration" is a reference the user saved from their iOS app to the Inspiration folder. Library items live outside the project: library_add imports an asset, template_add re-materializes a snippet. Answers a page of `items` (assets and snippets, each with its kind) with `total` and, when more remain, `next` to pass back as offset. To find a named asset, pass words of its name as query ("computer desk raw" finds computer-desk-raw); folder narrows to a folder and the folders inside it. Stock sound effects are not in the Library: use stock_search. Read-only: it changes nothing in the project or the account.
library_list
Organize the shared Library. Folders nest: create_folder makes one at the root or inside parent_id, rename_folder renames, move_folder files a folder under another (omit parent_id for the root; never into itself or a folder inside it), delete_folder deletes one with everything in it — its folders and every item and note they hold — permanently; an inspiration item in it leaves the phone too. move_asset files an asset or snippet into a folder (omit folder_id for the root), rename_asset renames a file (any file kind — video, audio, image, font, LUT — and a font or LUT keeps its new name in its menu) and rename_template a snippet; delete_asset removes a file and delete_template a snippet. Deletes are permanent — projects keep their own copies, but delete only what the user explicitly asked to remove. Deleting an asset with origin "inspiration" takes it off the user's phone as well. It can move, overwrite or delete what the project already holds.
library_organize
Donkey Cut ChatGPT Plugin FAQ
How the directory, categories and Discoverability Score work.
Read the methodologyHow do I improve Donkey Cut's ChatGPT Plugin discoverability?
The levers are the listing surface agents actually read: names, descriptions, keywords, tool metadata, and registry health. Which lever matters depends on where discovery breaks, which is what continuous measurement shows.
Where is this profile measured?
This profile uses the geography attached to the latest public registry snapshot: US. Locale tags are intentionally omitted.