VidLet

Edit video by asking: auto-captions, jump cuts, narrated Shorts, GIFs, voiceover, YouTube upload.

Connector by vidlet.appOfficial · Domain verified by the MCP Registry

IndexedLicense unknownLocal (stdio)

Install

Works with Claude Code, Codex, VS Code, Cursor, Windsurf, Claude Desktop. Read the repository before you give any tool access to your data.

npx agentmarket install connector/vidlet-app-vidlet

Asks which of your tools to add it to (Claude Code, Codex, Cursor, VS Code, Windsurf, Gemini CLI, Claude Desktop) and shows the change first. See https://agentmart.dev/cli.

Get the weekly diff

The weekly diff: one email a week with new agent tools, notable updates and grade changes, plus security alerts for tools you follow. Double opt-in, one-click unsubscribe.

About

Edit video by asking: auto-captions, jump cuts, narrated Shorts, GIFs, voiceover, YouTube upload.

Reviews

Write a review

No reviews yet. Installed it? Reviews come from verified installers only. How reviews work

Permissions

What this server can do and what it asks for, from its tool list and install config. Checked Oct 25, 2026.

Runs code on install

Its package runs an install script (such as npm postinstall or setup.py code) as soon as you install it, before any tool is called. Read the script first.

Tools: 9 read · 12 write · 0 delete · 12 not yet classified
Secrets: None asked for
Install scripts: Runs code on install
Runs as: Node.js package

Tools by what they do 33

Read from the source code; the running server may list different tools.

Read 9 · Look things up without changing anything.

convert_to_gif
convert_voice
extract_audio
list_capabilities
mask_sensitive
preview_music
preview_short
probe_video
validate_project

Write 12 · Create, change, send or run things.

add_music
add_voiceover_to_project
create_demo
create_og_intro
create_og_outro
create_project
create_short
create_showcase_cards
create_timelapse_short
setup_recording
setup_youtube_test
upload_to_youtube

Not yet classified 12 · We could not tell from the name and description.

auto_jump_cut
compress_video
connect_youtube
generate_captions
generate_short
generate_voiceover
open_in_editor
render_project
rotate_youtube_test
speed_up_video
tighten_project
trim_video

Files it touches

Any path the agent passes to its tools

Tools (33)

Read from the source code; the running server may differ. Descriptions are the server’s own words; hidden characters are shown as [U+…].

add_music
Lay a music bed onto a video that is ALREADY rendered, ducked under any speech it has. The video stream is copied rather than re-encoded, so this takes seconds - use it whenever only the music needs to change, instead of re-running generate_short and redoing the cut, grade, narration and captions. Never overwrites the input; writes "<name>_scored.mp4" beside it unless output_path says otherwise.
add_voiceover_to_project
Generate narration audio (free Edge TTS, or a locally cloned voice via clone_ref) for a .vidlet project and register it as a ducking voice-track clip at 0s. Text defaults to the project's subtitle text. Writes the mp3 plus a NEW .vidlet beside the original — never overwrites either.
auto_jump_cut
Auto-edit: cut silence and add alternating punch-in zoom. Never overwrites input; default output is "<name>_jumpcut.<ext>" in a VidLet/ subfolder, numbered if that already exists.
compress_video
Re-encode with H.264 to shrink file size. Never overwrites input; default output is "<name>_compressed.<ext>" in a VidLet/ subfolder, numbered if that already exists.
connect_youtube
Connect VidLet to a YouTube channel (first-time setup or reconnect). Opens the Google consent page via the vidlet.app OAuth broker - no Google client or API keys needed on this machine - and stores the refresh token in ~/.config/vidlet/youtube.json (owner-only permissions). Publishing is a VidLet Pro feature: a free account gets an upgrade link instead of a connection. Pass check_only to report connection state without opening a browser.
convert_to_gif
Convert to an optimized (palette-generated) GIF. Never overwrites input; default output is "<name>.gif" in a VidLet/ subfolder, numbered if that already exists.
convert_voice
Re-voice existing audio: keeps the words, timing and delivery, replaces the voice with the one in reference_audio. Runs an ONNX OpenVoice v2 converter locally (MIT, ~125MB, no PyTorch) in a single forward pass, so it is fast enough to use per clip. Pass many pairs to convert a whole narration in one go: the models and the target voice are loaded once, which is most of the cost. Never overwrites an input.
create_demo
The quiet-creator pipeline for SILENT screen recordings: trims idle spans (motion-based), a vision model watches keyframes, an LLM writes the narration, TTS speaks it (or a cloned voice via clone_ref), and it outputs the full narrated 16:9 demo plus a 9:16 Short. The calling model does the writing when no GROQ_API_KEY is set. Never overwrites existing files.
create_og_intro
Render a link's Open Graph card as an opening clip: fade in, hold, fade out. Reads og:image/og:title/og:description off the page, then composes for the frame it is given - a card that already fits fills it, and a landscape card going into a 9:16 Short is RECOMPOSED (artwork cropped large, the page title re-set underneath at a readable size) rather than letterboxed. Pass `match_video` to inherit a recording's exact frame size. Feed the result to generate_short or create_timelapse_short as `intro`: it plays whole at natural speed and the narration still starts at frame zero, so the voice runs ov…
create_og_outro
Render a link's closing card: its icon, name and tagline on black, fading in, WITH the closing line spoken over it ("Try it for free at <domain>." by default). Unlike the intro this clip carries its own audio, so it can be appended, re-ordered or dropped without re-timing the narration - pass it to generate_short as `outro` and it plays after the footage. Icon, name and tagline all come off the page; override the spoken line with `say` and the tagline with `tagline`. PASS THE SAME language/gender the Short uses - this clip is synthesised separately, so a mismatch makes the video change speaker…
create_project
Create a .vidlet project file (the open CC0 layered-edit JSON format) from a story source: .srt/.vtt subtitles become timed cues, .txt/.md is treated as a script, and a QuickPeek-style .json plan ({url?, steps:[...]}) turns step captions into sequentially timed cues. Registers video/music media by relative path + sha256 and writes the project beside the source, never overwriting. When `voice` or `video_path` are omitted the project is still written and the result contains a `questions` array: relay each question to the user VERBATIM with its options, collect their answers, then call create_pro…
create_short
Turn a full landscape video into a 9:16 YouTube Short: whisper.cpp transcribes locally, AI picks the most engaging moments (the calling model does the writing when no GROQ_API_KEY is set), and the crop follows the on-screen action/cursor via motion tracking. Writes a "<output>.segments.json" sidecar for manual crop/time tweaks. Never overwrites input.
create_showcase_cards
PRESET: both the opening and closing card for an app showcase, from ONE url. Everything is read off that page - og:image for the opening card, the site's favicon for the closing icon, og:site_name for the name, og:title minus the name for the tagline, and the host for the domain - so showcasing a different app means changing the url and nothing else. Both fade in and out; the closing card carries its own spoken sign-off. Pick `format`: "short" for 1080x1920, "landscape" for 1920x1080, or "source" to match the recording. Hand the two returned paths to generate_short as `intro` and `outro`.
create_timelapse_short
Turn a long screen recording into a fast 9:16 Short: static stretches are cut (per-pixel motion, so a moving cursor still counts as activity), what is left is sped up, the frame is padded to 1080x1920 over a blurred copy of itself, and a progress bar + real source-time readout are burned on. Original audio is dropped (at these speeds it is noise) and replaced with a bundled CC0 music bed. Every setting has a working default: calling this with just `path` produces a finished, scored Short. Never overwrites input; default output is "<name>_timelapse.mp4" in a VidLet/ subfolder, numbered if that …
extract_audio
Pull the audio track out to its own file. Never overwrites input; default output is "<name>.<format>" in a VidLet/ subfolder, numbered if that already exists.

Show 18 more tools

generate_captions
Auto-transcribe locally with whisper.cpp (English only) and burn styled captions in. Never overwrites input; default output is "<name>_captioned.<ext>" in a VidLet/ subfolder beside the source, numbered (-1, -2, ...) if that already exists. Also saves the transcript as a "<name>_captioned.vidlet" project: amend captions by editing it (or via the returned edit_url on vidlet.app) and calling render_project — no re-transcription.
generate_short
One call from raw files to a finished YouTube Short. Give it the attached files (videos in story order; optionally .srt/.vtt captions, a .txt/.md narration script, and/or a music audio file) and it: denoises voiced clips, cuts long pauses, drops duplicate retakes, stitches, speeds the result to fit under 59s, matches contrast across clips, frames 9:16, writes and speaks the narration, burns karaoke captions timed to that voice, and mixes a ducked music bed. The output is named after its content, not the source timestamp, and the result carries a `url` (file://) - always surface that url to the…
generate_voiceover
Generate narration audio from a script. Default engine is free Edge neural TTS (no API key, no install). Pass clone_ref (a ~10s voice recording) to speak in that voice, locally. The engine is chosen from the hardware unless clone_engine names one: on a CPU that is kokoro+openvoice, which synthesises with Kokoro (Apache-2.0) and converts the timbre with an ONNX OpenVoice v2 (MIT) in one pass - about 125MB, no PyTorch. On a CUDA machine Chatterbox and dots.tts are available and sound better, and both need PyTorch plus a Python that supports it. Optionally mixes the narration over video_path, aut…
list_capabilities
List every tool this server offers with a one-line description. Cheap discovery, no file I/O.
mask_sensitive
Scan a video for sensitive information on screen (card numbers validated by Luhn, emails, phone numbers, IBANs, SSNs, API keys, street addresses, postcodes) and cover each with a pixel mosaic. Detection needs tesseract installed; without it the tool reports that clearly instead of silently masking nothing. `regions` always works regardless, for areas you pick yourself. Use dry_run to see what WOULD be covered before writing a video. Never overwrites the input.
open_in_editor
Open a .vidlet project in the vidlet.app browser editor (the project JSON travels in the URL hash, never sent to a server). Small projects auto-open; larger ones return manual steps instead, because OS launchers cap URL length. Writes no files.
preview_music
Render short audible samples of the bundled CC0 beds, at the level a Short actually mixes them, so a bed can be picked by ear instead of by label. Returns a file:// url per mood - offer them to the user, then pass their choice as generate_short's `music`. Writes small mp3s; touches no video.
preview_short
Render a FAST, low-quality draft of the Short so the edit can be approved before paying for the real thing. Identical pipeline - same cuts, speed, narration, caption timing and intro - but a 360x640 canvas, the fastest encoder, no music and no sensitive-data scan. It also warms the analysis cache, so approving it and calling generate_short with the same inputs skips re-analysing the footage entirely. Use this whenever the user is iterating on narration or timing; show them the returned url and ask whether to render it properly.
probe_video
Read-only: duration, resolution, fps, codec, bitrate, audio presence, file size. Writes nothing.
render_project
Render a .vidlet project to MP4 with native ffmpeg (NVENC when available): main-track cuts with background gaps, overlays, burned subtitles, and a full audio mixdown with narration ducking. Never overwrites input; default output is "<name>.mp4" in a VidLet/ subfolder beside the project, numbered if that already exists.
rotate_youtube_test
Advance the A/B test on an uploaded Short: snapshot the stats for the variant that was live, swap to the next title, thumbnail and description (videos.update + thumbnails.set), and report views-per-hour per variant with a winner once every variant has enough exposure. Cycles a, b, c, a. Rotate roughly daily; apply the winner permanently once the gap holds. Pass status_only to read the standings without rotating.
setup_recording
Set up a screen-recording session on vidlet.app: opens the browser with the given script preloaded into the teleprompter (an always-on-top floating window, excluded from the capture). The user then clicks "Open prompter" and "Record screen" — browser security requires those two clicks. Writes no files.
setup_youtube_test
Set up (or repair) a proper A/B test on a Short that is ALREADY published - three variants, each with its own title, thumbnail and description. Use this to add a third variant to a two-way test, to give variants their own descriptions, to fix a test started with the wrong tags or category, or to start a test on a video uploaded without one (pass video_id). First call reports the live video, the current test and what is missing from it, extracts thumbnail candidates and fetches real trending titles, and writes NOTHING. Only a re-call with confirm: true rewrites the sidecar and puts variant A on…
speed_up_video
Change playback speed. Audio keeps its pitch via chained atempo, so speech stays natural up to about 2x; past that treat the audio as texture (or mute it). Never overwrites input; default output is "<name>_speedup.<ext>" in a VidLet/ subfolder, numbered if that already exists.
tighten_project
Cut the dead tail off a .vidlet: the footage that keeps playing after the last spoken word, with the closing card slid up to meet it. Content-aligned narration puts the final line on the last moment it describes, which is typically three quarters of the way through the footage, so a Short can otherwise end on several seconds of silent screen recording. Writes a NEW project; render it with render_project. Nothing is re-analysed - the transcript, narration audio and caption timing are untouched.
trim_video
Cut a video to a start/end time range (fast stream copy). Never overwrites input; default output is "<name>_trimmed.<ext>" in a VidLet/ subfolder, numbered if that already exists.
upload_to_youtube
Publish a finished Short to the connected YouTube channel - with a human approval gate. First call: verifies the connection (returns a connect question if there is none), then generates three title variants (graded by a virality scorer), hashtags with real view counts from trending videos, and three thumbnail candidates from the video plus a fourth built from the Open Graph card of the first link, and returns it all as a `questions` round WITHOUT uploading. Relay the proposal verbatim for approval; the user picks two of the three titles and thumbs as the A/B pair. Only a re-call with confirm: …
validate_project
Read-only: parse a .vidlet project against the v1 format spec and check that its media files exist (sha256 mismatches are warnings). Returns {valid, schema_version, errors, warnings, missing_media}. Writes nothing.

Signals

Last release: Sep 29, 2026 (29 days ago)

Details

Registry name: app.vidlet/vidlet
Version: 1.2.2
Auth: No auth
Packages: npm @spark-apps/vidlet
License: License unknown
Website: vidlet.app
First seen: Oct 24, 2026
Last checked: Oct 24, 2026
Source: Official MCP Registry

Cite this page

VidLet MCP server. Agent Mart. https://agentmart.dev/connectors/vidlet-app-vidlet (last updated 2026-10-24)