Frapea
A video editor in your browser that your AI drives: cuts, captions, multicam, motion titles, export.
| Endpoint | https://app.frapea.com/mcp (streamable-http) |
|---|---|
| Registry version | 0.2.0 |
| Now | 67 tools · grade F (49) · pin ts_c58fb8a9155dd9a6c6fc1613872178a2 · protocol 2025-06-18 |
| First / last listed | 2026-10-24 20:48 UTC / 2026-10-24 20:48 UTC |
| Grade over time | 2026-10-24: F (49), 67 tools |
Is this your server? Own a server? ToolFit hosted watch re-checks it every 24 h ($0.25 per 30 days) or 6 h ($0.60) and sends you an HMAC-signed webhook when its tools or grade change: POST https://api.youraitools.co/toolfit/v1/watch. To opt out, see About & opt-out.
Tools: connect get_projects get_timeline get_media get_transcript create_motion_composition update_motion_composition get_motion_composition list_motion_compositions create_timeline add_clips split_clips remove_clips ripple_delete_ranges set_clip_properties generate_captions manage_effects manage_transitions manage_tracks cut_to_angle move_clips set_active_timeline set_project_settings search_media remove_words remove_silence undo inspect_media inspect_timeline get_problems get_bug_report verify_timeline insert_clips organize_media read_skill await_user_action open_project close_project new_project connect_media_folder trim_clips get_analysis_status request_ai_models start_visual_indexing start_transcription get_job_status list_voiceover_models generate_voiceover search_stock_media download_stock_media search_sounds download_sound add_sfx manage_queue retry_analysis set_keyframes apply_layout track_faces list_face_tracks merge_faces bind_face organize_pool measure_loudness duplicate_timeline add_sample_media open_timeline close_timeline
connect | Pairs you with the user's Frapea browser tab. TWO WAYS ROUND. (1) If they already have Frapea open: ask them for the pairing code (the Connect MCP button) and call this with it. (2) If they do not, or you are not sure: call this with NO arguments and you get back a link — send them the link, then call this again with the code it contains every few seconds until it returns a token (they have to acc params: code |
get_projects | Lists the projects Frapea knows on this machine: id, name, lastOpenedAt, and for a project stored in a folder on disk its `folder` (the directory's name — files you write into its `media/` subfolder join the pool by themselves). Call first to find the projectId every other tool needs. A project the browser has no permission for will surface PERMISSION_REQUIRED when used — relay the returned instru params: token* |
get_timeline | Reads a project's timeline structure: timelines (id, name, fps, resolution) with tracks and clips. THE USER CAN COPY A CLIP'S ID from the editor's right-click menu, so a bare UUID in their message names exactly one clip — call this with NO timelineId to search every timeline and match `clip.id`, rather than guessing from a name. Clips carry id, name, mediaRef, kind, startFrame, endFrame (exclusive params: projectId*, timelineId, token* |
get_media | Lists the project's media library: mediaRef (the id clips use), name, kind (video/audio/image), durationSeconds, resolution, and sceneSamples — timestamps (seconds) where the visual indexer detected distinct moments. sceneSamples is a ready-made shot map: inspect or cut at those times first. Each asset also carries visualIndex and transcript objects: {phase: 'ready'|'pending'|'queued'|'running'|'f params: projectId*, mediaRef, token* |
get_transcript | Returns the word-level speech transcript of one media asset: language and words [{text, startSec, endSec}]. Only assets the user has transcribed have one — NOT_FOUND means ask the user to run Transcribe on the clip in Frapea. Use the timestamps to align cuts with what is being said. params: projectId*, mediaRef*, token* |
create_motion_composition | Creates a MOTION COMPOSITION — an animated graphic (infographic, title, promo end-card, chart…) written as a React TSX component. Read the 'motion' skill (read_skill {topic:'motion'}) for the exact API surface, available fonts/icons and golden examples before writing one. files maps file names to TSX source; the entry must `export default` the component. schema declares the editable props (type st params: projectId*, name*, files*, entry, schema, width, height, fps, durationInFrames, preview, previewProps, previewFrame, token* |
update_motion_composition | Updates a motion composition's TSX files and/or manifest (name, duration, schema…). Same compile-and-test gate as create; files given here MERGE over the existing set. Every clip playing the composition re-renders. preview:true returns one large frame of the result with the reply. params: projectId*, compositionId*, files, name, schema, width, height, fps, durationInFrames, preview, previewProps, previewFrame, token* |
get_motion_composition | Returns a motion composition's manifest and full TSX sources. params: projectId*, compositionId*, token* |
list_motion_compositions | Lists the project's motion compositions: id, mediaRef (for add_clips), name, size, fps, duration and the editable props schema. params: projectId*, token* |
create_timeline | Creates a new timeline in the project and returns its id. Set fps, width and height for the target format (e.g. 1080×1920 @30 for a vertical short). The new timeline starts with one video and one audio track; spare tracks appear automatically as clips land. params: projectId*, name*, fps, width, height, token* |
add_clips | Places media segments on a timeline. Each clip: mediaRef (from get_media, 'timeline:<id>' to NEST another timeline as a clip, 'solid:#rrggbb' , 'motion:<id>' for a MOTION composition (create_motion_composition) for a generated solid-colour matte, 'adjustment:' for an adjustment clip — no picture of its own, its effects/masks/opacity grade everything below it — or 'text:' for a title, restyled via params: projectId*, timelineId*, clips*, token* |
split_clips | Blades clips at a timeline frame. Splits every listed clip (and its linked partner) into two independent clips at atFrame. Frames are in the target timeline's fps. Use with get_timeline to find clip ids first. params: projectId*, timelineId*, clipIds*, atFrame*, token* |
remove_clips | Deletes clips (lift — leaves a gap). Linked partners are NOT removed automatically; pass both ids of a pair to delete it whole. To close the gap too, use ripple_delete_ranges instead. params: projectId*, timelineId*, clipIds*, token* |
ripple_delete_ranges | Extracts [fromFrame, toFrame) on one track and shifts everything after it left to close the gap (sync-locked tracks follow). The go-to tool for tightening a cut or removing a bad take. params: projectId*, timelineId*, trackId*, fromFrame*, toFrame*, token* |
set_clip_properties | Adjusts a clip. Only the provided fields change. Mix: volume (0–2, 1 = unity), fadeInFrames / fadeOutFrames (gain or opacity ramps at the edges). Look: opacity (0–1), blend (normal | multiply | screen | overlay | darken | lighten | color-dodge | color-burn | hard-light | soft-light | difference | exclusion | add), transform, crop and speed. transform.fit picks how the picture meets the frame befor params: projectId*, timelineId*, clipId*, volume, fadeInFrames, fadeOutFrames, opacity, blend, transform, crop, cropSoftness, cropRetain, dynamicZoom, speed, speedRipple, stabilization, denoise, lensDistortion, motionBlur, solidColor, bypass, disabled, speedKeyframes, masks, motion, text, token* |
generate_captions | Generates animated captions from a spoken clip's transcript (the same generator as Frapea's UI): transcript words group into caption text clips over the clip's span, word-timed so the animation follows speech. One undo, and they share a captionGroupId — restyle them all via set_clip_properties with text.wholeCaptionGroup. Needs a transcript (get_transcript tells you). Returns the created clip ids. params: projectId*, timelineId*, clipId*, preset, position, textCase, censorProfanity, maxWordsPerCaption, token* |
manage_effects | Edits a clip's effect stack (ordered, per-effect enable). action: 'add' (type; returns the new effect's id) | 'remove' (effectId) | 'move' (effectId + toIndex — the order IS the render order) | 'toggle' (effectId + enabled) | 'set' (effectId + params patch, clamped to the effect's ranges) | 'curve' (effectId + curve + points). Types: 'colorBasic' (Lumetri Basic Correction-compatible: temperature/t params: projectId*, timelineId*, clipId*, action*, curve, points, type, effectId, toIndex, enabled, params, resource, token* |
manage_transitions | Transitions on a track's cuts OR lone clip edges (a free head/tail takes a single-sided fade from/to nothing; its alignment is forced). action: 'add' (trackId + atFrame = the cut where one clip ends and the next starts, + type; optional durationFrames (default 30, clamped to the clips' source handles), alignment centered|start|end, params) | 'remove' (transitionId) | 'update' (transitionId + any o params: projectId*, timelineId*, trackId*, action*, atFrame, type, transitionId, durationFrames, alignment, params, token* |
manage_tracks | Track operations on a timeline. action: 'mute' | 'unmute' | 'solo' | 'unsolo' (audio only; any solo silences non-solo tracks) | 'hide' | 'show' | 'rename' (needs name) | 'duck' | 'unduck' (audio only: dip this track under speech detected on the other audio tracks — transcript word timings when available, energy VAD otherwise) | 'merge' (needs intoTrackId: moves every clip of trackId onto another t params: projectId*, timelineId*, trackId, action*, name, intoTrackId, token* |
cut_to_angle | MULTICAM angle switch. The angles are ordinary video tracks stacked over each other (sync them beforehand — clips of the same take on V1..Vn); this razors the whole angle stack at `atFrame` and keeps only `chosenTrackId` live from there to the next cut — the other angles' clips are DISABLED, not deleted, so every switch stays re-decidable (cut again with a different angle to change your mind). Lin params: projectId*, timelineId*, atFrame*, chosenTrackId*, angleTrackIds, audioFollowsVideo, token* |
move_clips | Moves clips to new positions (linked partners follow automatically). Each move: clipId, toStartFrame, optional toTrackId (same-kind track). Overwrite semantics — landing on another clip trims it like a drag-drop. params: projectId*, timelineId*, moves*, token* |
set_active_timeline | Sets which timeline the project opens on (and what the user sees if the editor is open), opening its tab if it was closed. Purely a convenience — every tool here takes an explicit timelineId regardless. params: projectId*, timelineId*, token* |
set_project_settings | Updates a timeline's fps / width / height (clips keep their timing; content re-fits) and/or renames it. Only provided fields change. params: projectId*, timelineId*, name, fps, width, height, token* |
search_media | Semantic search over the project's media. Visual scope matches what is IN the picture (describe a shot: 'aerial city at night'); spoken scope matches transcribed speech (exact words, ranked first, with a snippet). Hits: {mediaRef, timeSec (best moment), fromSec, toSec, score, scope}. Requires the user to have downloaded the picture analyzer — otherwise PERMISSION_REQUIRED tells you what to relay. params: projectId*, query*, token* |
remove_words | Text-based editing: cuts the given transcript words OUT of a clip as ripple deletes (everything after each cut shifts left). wordIndices are positions in get_transcript's words array for the clip's media. Contiguous indices merge into single cuts. The go-to tool for removing filler words or tightening an interview. params: projectId*, timelineId*, clipId*, wordIndices*, token* |
remove_silence | Cuts silent gaps inside a clip: any pause between transcribed words longer than minGapSec becomes a ripple delete (a small margin is kept so speech never clips). Typical minGapSec: 0.6 tight, 1.0 balanced, 1.5 loose. params: projectId*, timelineId*, clipId*, minGapSec*, token* |
undo | Reverts the most recent edit THIS agent session made to the project (one step per call; repeat to go further). Cannot revert other tabs' or the user's edits. params: projectId*, token* |
inspect_media | Looks INSIDE a source asset. Returns ONE contact sheet — every requested moment as a labelled cell in a single grid image — plus a per-cell fingerprint. Pass atSec (max 12 timestamps, seconds); combine with get_media's sceneSamples for an instant storyboard of the whole file. Shows the RAW source; use inspect_timeline for the composed cut.
START WITH pixels:false WHEN YOU ARE ONLY CHECKING FOR EMP params: projectId*, mediaRef*, atSec*, pixels, columns, cellHeight, token* |
inspect_timeline | WATCHES the cut. Composites every video layer at each requested frame and returns ONE contact sheet — the frames as labelled cells of a single grid image — plus, per cell, the visibleClipIds that contributed pixels and a fingerprint. Pass frames (timeline frame numbers, max 12). Use it to check an edit: this is the only tool that shows what actually PLAYS, as opposed to what get_timeline says is a params: projectId*, timelineId*, frames*, pixels, columns, cellHeight, token* |
get_problems | What has gone WRONG in the user's editor — renders that failed or stopped, footage that would not decode, chunks that could not be prepared for playback, exports that failed — each with WHERE (the timeline and frames, the source and its own frames, the footage and frame the engine could not decode) and the reason in the engine's own words.
You also hear about new problems for free: every other too params: projectId, includeResolved, detail, token* |
get_bug_report | Prepare a BUG REPORT for the user: it opens in Frapea (Problems → Create bug report) for them to read and save. The report itself is NOT returned to you — it would leave the user's machine before they have seen it. You get a summary: open problems, media counts, and how many of the user's own words remain in composition code. It contains versions, problems with engine details, the project's struct params: projectId*, timelineIds, token* |
verify_timeline | Renders a timeline the way an export does and reports what fails. inspect_timeline shows a few frames through the preview path, which quietly substitutes a nearby picture where a frame cannot be rendered; this renders every motion segment the timeline reads (through every nested timeline) exactly, then composites every frame with every layer (footage decoded), and fails where an export would.
Retu params: projectId*, timelineId*, cancel, token* |
insert_clips | Ripple-inserts media segments: everything at/after atFrame shifts right to make room (clips under the cut split). Same clip shape as add_clips. Use to splice a shot INTO an existing sequence without overwriting. params: projectId*, timelineId*, atFrame*, clips*, token* |
organize_media | Pool file operations. action: 'rename' renames the real file on disk (needs newName; clips referencing the old name go offline). 'delete' UNLINKS the file from the media pool — the real file on disk is NOT touched; clips using it go offline until it is added again. params: projectId*, mediaRef*, action*, newName, token* |
read_skill | Returns Frapea's editing documentation for a topic. With no topic: the editing conventions, how the tools fit together and the current feature surface. MOTION topics: 'motion' is the API surface (imports, fonts, props schema, the parts-board-first golden example) and routes to the rest — read before create_motion_composition; 'motion-examples' (two finished pieces that differ in look); 'motion-cra params: topic, token* |
await_user_action | Waits (up to ~45 s per call) for the user to resolve a pending Frapea prompt — e.g. the folder-permission dialog another tool just opened. The dialog waits for the user in the Frapea tab; the tool that opened it returned what they need to click. Returns {status: 'granted' | 'denied' | 'pending'}: 'pending' means they have not acted yet (call again to keep waiting), 'denied' that they declined. params: actionId*, token* |
open_project | Navigates the user's Frapea tab to a project so they can WATCH the edit live. Not required for editing — every tool works headlessly; use this for show-your-work moments. This reloads the Frapea tab, so an export or render running there stops. params: projectId*, token* |
close_project | Navigates the user's Frapea tab back to the project manager and releases this session's headless runtime for the project. When the tab shows that project it reloads, so an export or render running there stops. params: projectId*, token* |
new_project | Creates a project. By default it is created in the browser's own storage, which needs no permission and no click: the project id comes back immediately and you can start working. The user can turn it into a real folder on their disk whenever they want (Cmd/Ctrl+S, or File → Save to a Folder) without losing anything. Pass storage:'folder' only when the user asked for a folder up front — that needs params: name*, storage, token* |
connect_media_folder | Asks the user to attach a folder of THEIR OWN source footage to the project — opens a dialog in Frapea with a 'Connect folder' button. Only a human can do this (browser security gesture): tell the user IN YOUR REPLY to click it, then call await_user_action with the returned actionId; on 'granted', get_media will list the folder's files. Use when get_media comes back empty and the user has footage params: projectId*, reason*, token* |
trim_clips | Adjusts one edge of a clip (linked A/V partners follow). edge: 'start' trims/extends the in-point, 'end' the out-point. deltaFrames > 0 moves the edge right, < 0 left — e.g. edge 'end', delta -12 shortens the clip by 12 frames. Extending is limited by the source material. params: projectId*, timelineId*, clipId*, edge*, deltaFrames*, token* |
get_analysis_status | How far the project's media analysis has got. Analysis runs BY ITSELF whenever media is connected. Returns percent (0-100) — 100 means nothing is OUTSTANDING, not that everything succeeded: `failed` lists items whose analysis failed (retry_analysis re-runs one) — done/total/pending item counts, runningItem {mediaRef, kind, progress}, etaSeconds (null until something has finished), blockedOnModels, params: projectId*, token* |
request_ai_models | Asks the user to enable Frapea's on-device AI analyzers (picture search, speech). Opens a dialog in every Frapea tab and returns an actionId — tell the user IN YOUR REPLY to confirm it, then call await_user_action and poll get_analysis_status until models are enabled. Call this when get_media reports 'needs-models'. params: projectId*, token* |
start_visual_indexing | Indexes the project's pictures for search_media. Usually not needed: indexing is automatic and this only nudges the queue to re-check now. When the user switched automatic indexing off, this asks for every video and image to be indexed. Returns the same payload as get_analysis_status. params: projectId*, token* |
start_transcription | Transcribes one asset even if automatic transcription is switched off. Speech transcripts otherwise appear on their own. Returns the project's analysis status; poll get_analysis_status, then read get_transcript. params: projectId*, mediaRef*, token* |
get_job_status | Status of a background job started by a job-returning tool (generate_voiceover, verify_timeline, measure_loudness): {state: queued|running|done|failed|cancelled, progress: 0-1, detail, ...result fields such as mediaRef when done; verify_timeline, measure_loudness puts its report in `result`}. Poll every few seconds while state is 'queued' or 'running' (queued = waiting for the analysis master tab, params: jobId*, token* |
list_voiceover_models | The text-to-speech providers Frapea can generate voiceovers with. Returns providers[]: the FREE in-browser models straight from the TTS registry ({id, label, languages, voices: [{id, label, language, gender, grade}], modelAssets, state: {phase: needs-download|downloading|ready|error}}), plus the PREMIUM cloud provider flagged premium: true ({id: 'elevenlabs', label, premium, voices: [{id, label}], params: token* |
generate_voiceover | Generates an AI voiceover from a script — on-device with the free models, or in the cloud with ElevenLabs (the user's own key and credits). The WAV lands in the project's media library as a normal audio asset (with waveform and analysis), the script is stored as asset metadata, and a script-corrected word-level transcript is written so captions work immediately.
Narration is best generated before params: projectId*, text*, provider, voice, language, speed, modelId, voiceSettings, consentActionId, fileName, token* |
search_stock_media | Searches the Pexels stock library (photos or videos) with the user's connected API key. Returns items with id, dimensions, duration (videos), author, thumbnail url, available video qualities, and a `downloaded` flag telling whether the asset is already in the project's media pool. If no key is connected it errors with PERMISSION_REQUIRED, whose message says where the user connects one (Library → G params: projectId*, kind*, query, orientation, size, color, page, token* |
download_stock_media | Downloads one Pexels asset into the project's media pool as a virtual file at the Library root (name `pexels-<id>.jpg|.mp4`). Asynchronous: the first call accepts the download and returns its state; CALL AGAIN with the same arguments to poll — state becomes 'done' with the asset's mediaRef, ready for add_clips. maxHeight picks the best video rendition not exceeding it (default: the best available) params: projectId*, kind*, pexelsId*, maxHeight, token* |
search_sounds | Searches the Freesound library (SFX, ambience, foley) with the user's connected API key. Every item carries what you need to JUDGE the sound without hearing it: the uploader's full description, tags, duration, community rating and download count, format/samplerate, and — when analyzed — AudioCommons descriptors (acAnalysis: ac_loudness LUFS, ac_dynamic_range, ac_tempo, ac_tonality, ac_single_event params: projectId*, query*, minDurationSeconds, maxDurationSeconds, license, sort, page, token* |
download_sound | Downloads one Freesound sound (its HQ MP3 preview, ~128 kbps — plenty for SFX/ambience) into the project's media pool as a virtual file at the Library root (name `freesound-<id>.mp3`). Asynchronous: the first call accepts the download and returns its state; CALL AGAIN with the same arguments to poll — state becomes 'done' with the asset's mediaRef, ready for add_clips onto an audio track. Three fi params: projectId*, soundId*, token* |
add_sfx | Frapea's BUILT-IN sound-effects pack — synthesized, licence-free, no API key, no download wait. Covers common UI and motion sounds; search_sounds is for what the pack does not (ambience, foley, a specific real-world object). Call with no `ids` to get the catalogue: each sound carries what it sounds like AND when to use it. Call with `ids` to copy them into the project's media pool as `sfx-<id>.wav params: projectId*, ids, id, token* |
manage_queue | Full control of the background work queue. action 'list' returns every queued/running item across all projects (analyses, proxies, beats) plus the visible task rows (downloads, voiceover jobs, failures) with a cancellable flag. action 'cancel' stops ONE kind of work for ONE asset — queued or already running (a running visual index stops at the next sample and keeps its checkpoint). The asset then params: action*, projectId, mediaRef, kind, token* |
retry_analysis | Runs ONE analysis of ONE asset again — picture indexing or speech transcription — clearing whatever failure was recorded for it. If the asset already has a finished transcript or index, that result is deleted and rebuilt. Use when get_media shows phase 'failed' and the error looks worth another go, or when you want a fresh result for a file that changed meaning. Returns the project's analysis stat params: projectId*, mediaRef*, kind*, token* |
set_keyframes | Animates one clip property. property: opacity | volume | positionX | positionY | scaleX | scaleY | rotationDeg | pitch | yaw | anchorX | anchorY | cropLeft | cropTop | cropRight | cropBottom | cropSoftness. Keyframes are stamped in SOURCE frames (frames into the media, i.e. timelineFrame - startFrame + trimStartFrame), so they survive moves and trims. action 'set' (default) upserts the given keyfr params: projectId*, timelineId*, clipId*, action, effectId, param, property, keyframes, atSourceFrames, token* |
apply_layout | Arranges clips into a screen layout by writing ordinary transform + crop values (first clipId → first cell). layout: full | side-by-side | top-bottom | pip-top-left | pip-top-right | pip-bottom-left | pip-bottom-right | grid-2x2 | main-sidebar | three-up. mode 'fit' letterboxes each source in its cell, 'cover' fills the cell and crops the overflow (bias 0–1 picks the surviving part; 0.5/0.5 = cent params: projectId*, timelineId*, clipIds*, layout*, mode, bias, token* |
track_faces | Finds every FACE in a video clip and stores one independent path per person — position, size and head rotation (nod/turn/tilt) per frame. Queued, not immediate: poll list_face_tracks until state is 'ready'. Re-running on the same clip REPLACES its previous run and keeps the same trackId, so clips already bound stay bound. A person who leaves the shot and returns much later becomes a SECOND face on params: projectId*, clipId*, name, scoreThreshold, holdSeconds, travelFaces, token* |
list_face_tracks | Lists face-tracking runs and the people each one found: faceId, name, frame range, how many frames it was actually visible for, and how many gaps it has. Sample data is deliberately not returned. Use this to poll a queued run and to pick a faceId for bind_face. params: projectId*, clipId, token* |
merge_faces | Joins two or more faces from one run into a single person — for somebody who walked out of the shot and came back. REFUSED when any two of them appear on the same frame, since they cannot then be one person. The earliest face's id and name survive, so existing bindings keep working, and the time between sightings stays a gap for the clip's gap policy to handle. params: projectId*, trackId*, faceIds*, token* |
bind_face | Makes a clip FOLLOW a tracked face — the way to stick a mask, label or blur onto somebody's head. Movement is relative to where the face was first seen, so the clip keeps the framing it already had and only inherits the motion. Pick what to copy with channels, and what happens while the face is missing with gap. Pass trackId: null to unbind. params: projectId*, clipId*, trackId, faceId, channels, gap, maxGlideSeconds, smooth, token* |
organize_pool | THE MEDIA POOL'S SHAPE — bins (the pool's folders) and what sits in them. Use it to tidy a project: group the footage, the voice-over, the music and the graphics instead of leaving eighty files at the root.
Bins are VIRTUAL and live in the project, not on disk. Moving an item between bins NEVER touches the file or its mediaRef, so it cannot break a clip's link or make the app ask the user to reloc params: projectId*, action*, binId, toBinId, parentBinId, name, itemKeys, token* |
measure_loudness | MEASURE THE MIX — you cannot hear it; this is how you check it. Mixes the timeline's audio offline exactly as an export does (every audio track, nested timelines, fades, volume keyframes, clip audio effects, ducking, mute/solo) and measures it with EBU R128 / ITU-R BS.1770 — the same meter export loudness normalization uses. The mix is measured AS MIXED: an export's loudnessTargetLufs would then s params: projectId*, timelineId*, windowSec, sections, token* |
duplicate_timeline | Copy a timeline under a new name — a backup of the cut before a review round changes it, or a variant to try something on. A DEEP copy: new ids for the timeline, its tracks, clips and transitions; links between clips (A/V pairs, caption groups) are kept, inside the copy. Nested timelines are copied too by default (includeNested), so editing a nest in the original does not change the backup; motion params: projectId*, timelineId*, name, includeNested, token* |
add_sample_media | Frapea's SAMPLE MEDIA, for trying the editor without your own footage: a short talking clip with speech and pauses (for transcripts, captions, removing words or silences), a b-roll shot, a photo and a music bed. No API key, no download from elsewhere. Call with no `ids` to list them; call with `ids` (or `all: true`) to copy them into the project's media pool at the Library root — each result gives params: projectId*, ids, all, token* |
open_timeline | Opens a timeline's TAB in the editor (the user can close tabs to keep the tab row short; a closed timeline is not deleted and every tool works on it as before). By default it does not change what the user is looking at; activate:true also shows it, like set_active_timeline. get_timeline reports `open` per timeline, as last saved. params: projectId*, timelineId*, activate, token* |
close_timeline | Closes a timeline's TAB in the editor — hides it from the tab row, does NOT delete it: it stays in the media pool, and you (or anyone) can still edit, verify, nest and export it. When it was the one shown, the editor shows the next open tab, or none. params: projectId*, timelineId*, token* |
Entries describe changes in tool definitions. They are not statements about a server, its quality or its author. The grade measures how the tool definitions fit model providers (token cost, schema compatibility, confusable names) as scored by the ToolFit engine at the time of the listing. JSON: append .json. Opt-out: how or hello@youraitools.co.