AudacityMCP
AudacityMCP is an MCP server that gives AI assistants full control over Audacity through 131 tools for effects, cleanup, mastering, transcription, editing, and project management — all running locally without cloud processing or API keys.
Audio Effects Apply reverb, echo, phaser, wahwah, distortion, tremolo, pitch/tempo/speed changes, EQ curves, high/low-pass filters, bass & treble, PaulStretch, AutoDuck, NotchFilter, VocalReduction, fades, crossfades, reverse/invert, repair, sliding stretch, and clip fix.
Cleanup & Mastering Pipelines (One-Click)
Nine automated pipelines: auto_analyze_audio, auto_cleanup_audio, auto_cleanup_podcast, auto_audiobook_mastering (ACX compliant), auto_cleanup_interview, auto_cleanup_vocal, auto_cleanup_live, auto_master_music (genre-tuned), and auto_lofi_effect. Monitor running pipelines with check_pipeline_status. Includes noise reduction, click removal, silence truncation, compression, limiting, and LUFS normalization.
Core Audio Editing Cut, copy, paste, delete, split (in-place or to new track), split cut/delete, join, trim, silence, and duplicate audio.
Audio Generation Generate tones (sine, square, sawtooth), noise (white, pink, brownian), chirps (frequency sweeps), DTMF tones, and rhythm tracks.
Project & File Management Create, open, save, save-as, and close projects; import audio (WAV, MP3, OGG, FLAC, etc.) and MIDI; export audio in multiple formats; export labels; edit project metadata.
Track Management Add mono/stereo tracks, remove tracks, mix & render, mute/solo, pan, volume, resample, align, and convert stereo to mono.
Selection & Navigation Select all/none, by time region, by track, or by clip; snap to zero crossings; move cursor to specific times or track/project start/end.
Analysis Analyze contrast (WCAG), detect clipping, plot frequency spectrum, find beats, label sound regions, and export raw sample data.
Labels Add labels at cursor or time ranges, create labels at regular intervals, get/import/export labels.
Transport & Playback Play, stop, pause, record, play specific regions, and get current playback position.
Transcription (Experimental) Offline transcription via faster-whisper supporting 99+ languages and 5 model sizes. Transcribe full audio or selections; export as SRT, VTT, or plain text; auto-add Audacity labels at spoken segment timestamps.
Allows AI assistants to control Audacity for audio editing, cleanup, mastering, and transcription through 99 tools spanning effects, project management, and automated pipelines via a local named pipe interface.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@AudacityMCP Clean up this podcast recording and master it for Spotify"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
AudacityMCP connects any MCP-compatible AI assistant to Audacity, giving it full control over audio editing through 144 tools spanning effects, cleanup, mastering, transcription, and more. Talk to your AI assistant and it edits your audio in real-time.
No cloud. No API keys for audio processing. Everything runs locally through Audacity's named pipe interface.
If this is useful to you, a star helps other people find it — that's the whole marketing budget for this project. Want to help keep it maintained? Click the Sponsor badge up top.
Demo

Compatibility: AudacityMCP works with Audacity 3.x. Audacity 4 removed
mod-script-pipe— the scripting interface this server drives — and ships no replacement, so AudacityMCP cannot control Audacity 4.Running Audacity 4? There is a companion project: Audacity4-MCP — 159 tools over a TCP JSON-RPC bridge, covering editing, selection, labels, destructive and realtime effects, and live VST3 parameter control.
It is early alpha, and worth being clear about the setup: because Audacity 4 has no remote-control interface yet, it needs a companion fork of Audacity 4 built from source (Visual Studio, Qt 6.10, CMake, Ninja). That puts it in developer territory for now rather than general use. Audacity's maintainers have confirmed an official command and MCP interface is planned once their internal migration completes; when that lands, the fork should no longer be necessary.
Works With
AudacityMCP works with any AI client that supports the Model Context Protocol:
Claude Desktop — Anthropic's desktop app
Claude Code — CLI agent
Cursor — AI code editor with MCP support
Any other MCP-compatible client
Quick Start
1. Get AudacityMCP
Option A: Click the green Code button above → Download ZIP → extract to a folder
Option B: Clone with git:
git clone https://github.com/xDarkzx/Audacity-MCP.git2. Run the installer (sets up everything else automatically)
Windows: either double-click install.bat in File Explorer, or — if you're already in a terminal from the git clone step above — just keep going in the same PowerShell/Command Prompt window:
cd Audacity-MCP
.\install.batmacOS / Linux:
cd Audacity-MCP
bash install.shThe installer does 3 things: installs
audacity-mcpfrom this local folder (the one you just downloaded/cloned — no PyPI or GitHub fetch involved), enables mod-script-pipe in Audacity, and configures Claude Desktop — no manual JSON editing needed. It asks for confirmation before touching either config file, explains exactly what it's about to do first, and always backs up an existing file before changing it. Want to see everything it would do without changing anything? Add--dry-run:.\install.bat --dry-run/bash install.sh --dry-run.Note:
install.bat/install.shmust be run from inside this folder — they only install the code sitting right next to them, they don't download anything themselves.
If you're not using Claude Desktop, install manually with pip install audacity-mcp-server and add to your client's MCP config:
{
"mcpServers": {
"audacity": {
"command": "audacity-mcp"
}
}
}Check your client's MCP documentation for the config file location.
Client can't find/run
audacity-mcp? GUI apps don't always see the same PATH a terminal does. Runpython -c "import sysconfig; print(sysconfig.get_path('scripts'))"and use the full path it prints (plus\audacity-mcp.exeon Windows or/audacity-mcpon macOS/Linux) as"command"instead of the bare name.
No install.bat/install.sh, nothing touching your system automatically — three steps, all done by hand:
Enable mod-script-pipe in Audacity: Edit → Preferences (Windows/Linux) or Audacity → Preferences (macOS) → Modules → set
mod-script-pipeto Enabled → OK → restart Audacity.Install the package: open a terminal (Command Prompt/PowerShell on Windows, Terminal on macOS/Linux) and run
pip install audacity-mcp-server— a normal PyPI install, no repo clone needed.Configure Claude Desktop: open Claude Desktop → Settings (gear icon) → Developer tab → Edit Config — this opens
claude_desktop_config.jsonin a text editor. Add this inside the"mcpServers"block, keeping any other servers you already have:{ "mcpServers": { "audacity": { "command": "audacity-mcp" } } }Save the file and fully restart Claude Desktop (quit from the system tray, not just close the window).
That's the entire install — see the Installation Guide for the same steps with more detail and per-OS notes.
"audacity"doesn't show up as a tool after restarting? The"command": "audacity-mcp"above only works if that command is on the same PATH Claude Desktop itself uses, which isn't always the case (especially if Claude Desktop was already open when you installed Python). If it doesn't connect, run this in a terminal to find the real install location:python -c "import sysconfig; print(sysconfig.get_path('scripts'))"— then replace"audacity-mcp"above with the full path it prints plus\audacity-mcp.exe(Windows, remember to double every backslash:\\) or/audacity-mcp(macOS/Linux).
3. Start editing
Open Audacity, load some audio, then talk to your AI:
"Clean up this podcast recording"
"Master this track for Spotify, it's EDM"
"Transcribe this and add labels at each sentence"
"Add reverb with a large room, then export as FLAC"Audacity must be open first. AudacityMCP communicates through Audacity's named pipe — it can't launch Audacity for you.
See the full Installation Guide for detailed setup on all platforms and MCP clients.
Related MCP server: AI Sound MCP Server
Why AudacityMCP?
Without AudacityMCP: You manually navigate menus, tweak effect parameters by ear, apply effects one at a time, look up ACX specs, and repeat until it sounds right.
With AudacityMCP: You describe what you want in plain English and the AI handles the rest — picking the right effects, setting industry-standard parameters, and chaining operations together.
Manual Audacity | With AudacityMCP | |
Podcast cleanup | 5+ steps across different menus, guessing compressor settings | "Clean up this podcast" — one sentence |
Music mastering | Research genre-appropriate EQ/compression, apply each manually | "Master this for Spotify, it's hip-hop" — genre-tuned presets |
Noise removal | Effect → Noise Reduction → Get Profile → select all → apply | "Remove the background noise" — automatic profiling |
Batch operations | Repetitive menu navigation for each operation | Describe the full chain and watch it happen |
Transcription | Export audio, use external tool, import results back | "Transcribe this and add labels" — stays in Audacity |
Learning curve | Know which effects exist and what parameters to use | Just describe the result you want |
AudacityMCP is especially useful for:
Podcasters who want consistent, professional sound without audio engineering knowledge
Musicians who need quick mastering with genre-appropriate settings
Content creators working with interviews, voiceovers, or field recordings
Anyone who'd rather describe what they want than click through menus
What Can It Do?
You: "Clean up this podcast recording"
AI: Runs auto_cleanup_podcast → HPF 80Hz → noise reduction → compression → safe loudness check
You: "Master this track for Spotify, it's EDM"
AI: Runs auto_master_music style=edm → HPF 30Hz → click removal → compression 2.5:1 → bass +2dB → loudness check
You: "This is a noisy live recording, fix it up"
AI: Runs auto_cleanup_live → HPF 100Hz → click removal → noise reduction 18dB → compression 5:1
You: "Transcribe this interview and add labels"
AI: Runs transcribe_to_labels → faster-whisper transcription → Audacity labels at each timestamp
You: "Add reverb to the vocals, then export as FLAC"
AI: select region → reverb effect → export to FLACFeatures
144 Tools Across 11 Categories
Category | Tools | Highlights |
Effects | 30 | Reverb, echo, pitch shift, tempo change, EQ, phaser, distortion, paulstretch, HPF/LPF, bass & treble, tremolo, wahwah |
Cleanup & Mastering | 18 | Noise reduction, compressor, limiter, 9 one-click pipelines, analysis tool |
Editing | 13 | Cut, copy, paste, split, join, trim, silence, duplicate, undo, redo |
Project | 12 | New, open, save, import/export (WAV, MP3, FLAC, OGG, AIFF) |
Track | 15 | Add mono/stereo, remove, set properties, mix & render, mute/solo, pan, volume |
Selection | 12 | Select all/none/region/tracks, zero crossing, cursor positioning |
Transport | 7 | Play, stop, pause, record, play region, get position |
Analysis | 6 | Contrast, clipping detection, spectrum, beat finder, sound labeling |
Generation | 5 | Tone, noise, chirp, DTMF, rhythm track |
Transcription (Experimental) | 7 | Full/selection transcribe, to labels, to SRT/VTT/TXT, model preload |
Labels | 19 | List/find/edit/delete, delete one labeled take's audio by index, batch add, cut/delete/silence labeled regions, marker export (simple/cue/Podlove), per-segment audio export, import/export |
Pipelines
AudacityMCP includes 9 one-click pipelines for common audio tasks. Each pipeline is designed to be safe for badly recorded audio — it will never boost your audio dangerously. Pipelines clean up and improve your audio, then you can manually adjust loudness afterward if needed.
How Pipelines Work
You tell the AI what you want (e.g. "clean up this podcast")
The AI picks the right pipeline and starts it
The pipeline runs in the background — you get a
job_idbackPoll with
check_pipeline_statusevery 15-30 seconds to monitor progressWhen done, a popup appears in Audacity
Safety rule: Pipelines only reduce peaks if they're too hot. They never boost loudness. If you want to hit a specific LUFS target (e.g. -14 for Spotify), ask the AI to run
loudness_normalizeafter you've checked the results look good.
Pipeline Reference
auto_analyze_audio — Analyze before processing
Measures your audio and recommends the best pipeline. Run this first if you're not sure what to do.
You: "Analyze this audio"
→ Returns: peak level, noise floor, clipping status, recommended pipelineauto_cleanup_audio — Safe cleanup only
Cleans up noise and artifacts without changing loudness at all. Use when levels are already fine.
You: "Just clean up the noise, don't change the volume"
→ DC offset removal → HPF 80Hz → noise reduction → click removal (optional)auto_cleanup_podcast — Podcast / voiceover
Professional broadcast processing for spoken word.
You: "Clean up this podcast recording"
→ DC offset → HPF 80Hz → noise reduction 12dB → compression 3:1 → safe loudness checkauto_audiobook_mastering — Audiobook (ACX/Audible)
Targets ACX requirements for audiobook distribution.
You: "Master this for ACX / Audible"
→ DC offset → HPF 80Hz → noise reduction 12dB → compression 2.5:1 → safe loudness check → peak cap -3dBauto_cleanup_interview — Interview / dialogue
Light touch for conversations — preserves natural dynamics.
You: "Clean up this interview recording"
→ DC offset → HPF 80Hz → noise reduction 8dB → compression 2.5:1 → safe loudness checkauto_cleanup_vocal — Singing / studio vocal
Tuned for vocal recordings with presence EQ for clarity.
You: "Process this vocal recording"
→ DC offset → HPF 100Hz → noise reduction 10dB → compression 3:1 → presence EQ (+3dB treble, -1dB bass) → safe loudness checkauto_cleanup_live — Live / field / noisy recording
Aggressive cleanup for noisy environments. First 0.5s must be ambient noise for profiling.
You: "This is a noisy live recording, clean it up"
→ DC offset → HPF 100Hz → click removal → noise reduction 18dB → compression 5:1 → safe loudness checkauto_master_music — Music mastering
Genre-tuned mastering with 6 presets: edm, hiphop, rock, pop, classical, acoustic.
You: "Master this hip-hop track"
→ HPF 30Hz → click removal → compression 2:1 → bass +3dB treble +1dB → safe loudness check
You: "Master this for a classical album"
→ HPF 30Hz → click removal → compression 1.3:1 (very gentle) → no EQ → safe loudness checkPreset | HPF | Compression | Bass EQ | Treble EQ |
EDM | 30 Hz | 2.5:1 / 80ms | +2 dB | +1 dB |
Hip-Hop | 30 Hz | 2:1 / 100ms | +3 dB | +1 dB |
Rock | 40 Hz | 2:1 / 100ms | 0 dB | +1 dB |
Pop | 35 Hz | 2:1 / 80ms | +1 dB | +1.5 dB |
Classical | 30 Hz | 1.3:1 / 200ms | 0 dB | 0 dB |
Acoustic | 30 Hz | 1.5:1 / 150ms | 0 dB | 0 dB |
auto_lofi_effect — Creative lo-fi / vintage
Apply a warm, vintage lo-fi sound. Presets: light, medium, heavy.
You: "Give this a lo-fi vibe"
→ HPF → LPF (muffled highs) → bass/treble warmth → compression 2:1 → safe loudness checkAfter a Pipeline: Adjusting Loudness
Pipelines intentionally leave loudness alone (they only reduce if peaks are clipping). To hit a streaming target:
You: "Now normalize this to -14 LUFS for Spotify"
→ AI uses loudness_normalize tool with lufs_level=-14
You: "Normalize to -16 LUFS for podcast"
→ AI uses loudness_normalize tool with lufs_level=-16Why not do this automatically? LUFS normalization can boost quiet/badly recorded audio by 10-20 dB, which blows it out. By separating cleanup from loudness, you get to check the results before the final loudness step.
Local Transcription (Experimental)
This feature is experimental and requires separate setup. Everything else works without it.
Powered by faster-whisper — runs entirely offline, your audio never leaves your machine:
5 model sizes:
tiny,base,small,medium,large-v3Transcribe full audio or just a selection
Export as SRT, VTT, or plain text subtitles
Auto-add Audacity labels at each spoken segment
Language detection or specify 99+ languages
Setup required before first use: See Transcription Setup for installation steps.
Want GPU acceleration (10-20x faster)? Run audacity-mcp-setup-gpu — or download setup_gpu.bat/setup_gpu.sh and double-click/run it if you'd rather not use a terminal. Detects your GPU, installs what's needed, and verifies it actually works. NVIDIA GPUs only (AMD/Intel graphics and macOS aren't supported by the transcription backend at all — any NVIDIA card works, GeForce isn't a requirement, just having an NVIDIA GPU is). No NVIDIA GPU? CPU works fine, just slower on long files.
Script says it worked but transcription is still slow/on CPU? That means Claude Desktop is launching
audacity-mcpfrom a different Python than the one the script just verified — see the fix (a manual config edit, five minutes).
What's New — v0.1.3
32 new tools (99 → 131), pipeline tuning fixes, and live-tested against Audacity.
New effects: Reverse, Invert, Repair, AutoDuck, NotchFilter, VocalReduction, AdjustableFade, StudioFadeOut, CrossfadeClips, CrossfadeTracks, ClipFix, SlidingStretch, Tremolo
New editing: Split (in place), SplitCut, SplitDelete, Disjoin + renamed old split →
edit_split_newNew tracks: StereoToMono, MixAndRenderToNew, MuteAll, UnmuteAll, Resample, AlignEndToEnd, AddLabelTrack
New selection: CursorToTrackStart/End, CursorToProjectStart/End, SelectCursorToTrackEnd
New project: EditMetadata, ImportMIDI
New labels: RegularIntervalLabels
Pipeline fixes: ACX peak cap -3.0→-3.5dB, live NR 18→12dB, podcast comp 10ms/1s→30ms/200ms, interview release 1s→200ms
Bug fix:
effect_repairnow uses long timeout (Audacity shows popup on invalid selection)Validation: Added missing range checks on AutoDuck, VocalReduction, SlidingStretch, Resample
Troubleshooting
mod-script-pipe Not Enabled
The installer enables this automatically, but if it didn't work (e.g. Audacity was never opened before), enable it manually:
Open Audacity
Go to Edit → Preferences (Windows/Linux) or Audacity → Preferences (macOS)
Click Modules in the left sidebar
Set
mod-script-pipeto EnabledClick OK and restart Audacity
Connection Issues
Problem | Fix |
"Pipe not found" | Open Audacity first. Make sure |
"Pipe timeout" | Audacity is busy. Wait and retry — the late reply is drained in the background and the next command waits for it (or reports "still busy"). Some effects take minutes on long files. |
Connection works once then fails | The pipe disconnected (Audacity crash or restart). Just try again — AudacityMCP auto-reconnects. |
"Access denied" (Windows) | Audacity and your AI client must run as the same user. Don't mix admin and non-admin. |
Pipeline Issues
Problem | Fix |
Pipeline blows out / clips the audio | This shouldn't happen anymore — pipelines only reduce peaks, never boost. If it does, undo (Ctrl+Z) and report the issue. |
"A pipeline is already running" | Only one pipeline can run at a time. Use |
Pipeline finishes but audio is too quiet | That's by design — pipelines don't boost. Ask the AI: "Normalize to -14 LUFS" after checking results. |
Noise reduction sounds metallic/warbled | The first 0.5 seconds of your track must be pure silence/room noise for profiling. If it's not, trim to add silence or use |
Pipeline step failed (in warnings) | Individual steps can fail without stopping the pipeline. Check the |
Audio Quality Tips
Want | Do This |
Remove background noise | Make sure the first 0.5s of your track is pure room tone (no speech/music). The pipeline uses this to build a noise profile. |
Fix clipping | Run |
Hit -14 LUFS for Spotify | Run a cleanup pipeline first, check the results look good, then ask the AI to apply |
Hit -16 LUFS for podcast | Same approach — cleanup first, LUFS second. |
ACX audiobook compliance | Use |
Quick cleanup without changing volume | Use |
General Issues
Problem | Fix |
"No module named faster_whisper" | Run |
Model download fails | Check internet and retry. Models cache locally after first download. |
Pipes missing in /tmp (macOS/Linux) | Check Audacity is running and mod-script-pipe is enabled. Check Audacity's console for errors. |
Using Snap or Flatpak Audacity on Linux | Both sandbox |
Installer says "Audacity config not found" but Audacity definitely runs | If you're running a portable Audacity (a |
| Claude Desktop installed via the Microsoft Store redirects its config into an isolated per-package folder — older |
Architecture
┌──────────────┐ stdio ┌──────────────┐ named pipe ┌──────────────┐
│ MCP Client │◄──────────────►│ AudacityMCP │◄──────────────►│ Audacity │
│(AI assistant)│ (JSON-RPC) │ FastMCP │ (commands) │ │
└──────────────┘ └──────────────┘ └──────────────┘
│
├── audacity_mcp/main.py (entry point)
├── audacity_mcp/audacity_client.py (pipe I/O)
├── audacity_mcp/tool_registry.py (auto-loader)
└── audacity_mcp/tools/ (11 modules)Key Design Decisions
Named pipes, not TCP — Direct IPC to Audacity's
mod-script-pipe. No network exposure, no port conflicts.Zero
exec/eval— Every operation maps to a static handler with input validation. No arbitrary code execution.Cross-platform — Windows uses Win32 API via ctypes, Unix uses standard file I/O.
Async throughout — All tool handlers are
async. Blocking pipe I/O runs in an executor pool with configurable timeouts.Safe pipelines — Pipelines measure audio before making loudness decisions. They only reduce, never boost.
Dynamic tool registration — Drop a module in
audacity_mcp/tools/, export aregister(mcp)function, and it's automatically discovered.
Project Structure
AudacityMCP/
├── audacity_mcp/
│ ├── main.py # FastMCP server entry point
│ ├── audacity_client.py # Cross-platform named pipe client
│ ├── tool_registry.py # Auto-discovers and registers tool modules
│ └── tools/
│ ├── analysis_tools.py # Audio analysis (contrast, spectrum, beats)
│ ├── cleanup_tools.py # Noise reduction, mastering, 9 pipelines
│ ├── edit_tools.py # Cut, copy, paste, split, join, trim
│ ├── effects_tools.py # Reverb, echo, pitch, EQ, filters
│ ├── generate_tools.py # Tone, noise, chirp, DTMF generation
│ ├── label_tools.py # Label management
│ ├── project_tools.py # Project/file operations
│ ├── selection_tools.py # Selection and cursor control
│ ├── track_tools.py # Track management
│ ├── transcription_tools.py # Whisper-based transcription
│ └── transport_tools.py # Playback and recording control
├── audacity_mcp_shared/
│ ├── constants.py # Pipe paths, timeouts, allowed formats
│ ├── error_codes.py # Typed error codes (pipe/command/validation)
│ └── pipe_protocol.py # Command formatting and response parsing
├── tests/ # 60 tests
├── docs/
│ ├── INSTALLATION.md # Detailed setup guide
│ └── TOOLS.md # Complete tool reference
└── pyproject.tomlDevelopment
# Install dev dependencies
pip install -e ".[dev]"
# Run tests
pytest tests/ -x -q
# Run lint (real bugs + security patterns, not style/formatting)
ruff check .Adding New Tools
Create a module in
audacity_mcp/tools/(or add to an existing one)Export a
register(mcp: FastMCP)functionDefine your tools with
@mcp.tool()decoratorsThat's it — the tool registry auto-discovers it on startup
# audacity_mcp/tools/my_tools.py
from mcp.server.fastmcp import FastMCP
from audacity_mcp_shared.error_codes import AudacityMCPError, ErrorCode
def register(mcp: FastMCP):
from audacity_mcp.main import client
@mcp.tool()
async def my_custom_effect(intensity: float = 0.5) -> dict:
"""Apply my custom effect to the selected audio."""
if not 0 <= intensity <= 1:
raise AudacityMCPError(ErrorCode.VALUE_OUT_OF_RANGE, "intensity must be 0-1")
return await client.execute_long("MyEffect", Intensity=intensity)See CONTRIBUTING.md for full guidelines.
Community
Turning this into a tool every Audacity user reaches for takes more than one person. If you're using AudacityMCP — even just trying it out — come join the Discord: share what you built, report what's broken, suggest what's missing, or just hang out with other people doing AI-driven audio editing. Communities grow one person telling another this exists, so if you know someone who'd get value out of this, send them the link.
Support
If AudacityMCP has saved you time or helped with your audio projects, consider sponsoring:
Your support helps keep this project maintained and free for everyone.
Hiring / Consulting
Need a custom MCP server, a native plugin/IPC integration, or a local AI pipeline built for your product? This repo and its sibling projects — Reaper-MCP, SongForge-MCP — are public, working examples of exactly that. Open to contract work: dkstudiosnz@gmail.com.
Documentation
Installation Guide — Detailed setup for Windows, macOS, Linux
Tool Reference — Complete reference for all 144 tools with parameters and ranges
Transcript-Based Editing — Workflow guide for podcasts, interviews, and lectures (label-driven editing)
Contributing — How to add tools and contribute
Changelog — Version history and release notes
Acknowledgments
Thanks to the following for reported bugs, ideas, and feedback that improved this project:
@Harsha-Jay-S — diagnosed the
effect_change_pitch/effect_change_speedbug (#15) with measured proof against real Audacity, pinpointing the exact root cause.
License
Apache License 2.0 — see LICENSE for details.
Built by Daniel Hodgetts • 𝕏 @daehonz1
Available Tools
144 toolsanalyze_beat_finderA
Find beats in the selected audio and add labels at beat positions.
Args: thres_val: Beat detection threshold (0-100, lower = more sensitive). Default: 65
Inputs: thres_val.
analyze_contrastA
Analyze the contrast between foreground and background audio. Select a region first. Useful for checking accessibility compliance (WCAG).
Inputs: no named parameters.
analyze_find_clippingA
Find clipping in the selected audio and create labels at clipped regions.
Args: duty_cycle_start: Min number of consecutive clipped samples to detect (1-1000, default 3) duty_cycle_end: Min number of consecutive non-clipped samples to end a region (1-1000, default 3)
Inputs: duty_cycle_end, duty_cycle_start.
analyze_label_soundsA
Automatically label regions of sound separated by silence.
A good starting point for segmenting a long recording: label every passage of sound, or with label_type="between" label the silences instead so they can be trimmed with label_delete_regions.
measurement, label_type, pre_offset, post_offset and label_text are new and not yet independently live-tested against a running Audacity — verified against the scripting reference and unit tests with mocked responses only. threshold_db/min_silence_duration/min_sound_duration predate this and are unaffected.
Args: threshold_db: Volume threshold to distinguish sound from silence (dB). Default: -30 min_silence_duration: Minimum duration of silence between sounds (seconds). Default: 0.5 min_sound_duration: Minimum duration of a sound region (seconds). Default: 0.1 measurement: How level is measured — peak, avg or rms. Default: peak label_type: What to label — before, after, around or between the sounds. Default: before pre_offset: Seconds to extend each label before the sound starts. Default: 0 post_offset: Seconds to extend each label after the sound ends. Default: 0 label_text: Text for each label. Default: Audacity's own default
Inputs: label_text, label_type, pre_offset, measurement, +4 more.
analyze_plot_spectrumA
Open the Plot Spectrum window for the selected audio. Select a region first.
Inputs: no named parameters.
analyze_sample_data_exportA
Export raw sample data from the selected audio to a text file for analysis.
Args: path: Absolute path for the output file limit: Maximum number of samples to export. Default: 100
Inputs: path (required), limit.
auto_analyze_audioA
Analyze the current audio track and recommend the best pipeline to use. This is SYNCHRONOUS — it returns the analysis directly, no job_id needed.
Returns peak level, estimated noise floor, duration, clipping status, and a recommendation for which auto_ pipeline to use next.
IMPORTANT: Load your audio into Audacity before calling this.
Inputs: no named parameters.
auto_audiobook_masteringA
ONE-CLICK AUDIOBOOK MASTERING: ACX/Audible compliant processing. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: DC offset > HPF 80Hz > noise reduction 12dB > compression 2.5:1 > RMS -20dB > peak cap -3.5dB Meets ACX requirements: RMS -23 to -18 dB, peaks below -3 dB (capped at -3.5 for safety margin), noise floor below -60 dB.
Args: remove_noise: Apply noise reduction using first 0.5s as noise profile. Default: True
IMPORTANT: If remove_noise is True, the first 0.5 seconds should be room tone / silence. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: remove_noise.
auto_cleanup_audioA
SAFE CLEANUP: Remove noise and artifacts WITHOUT changing loudness or dynamics. Use this when audio levels are already good and you just want to clean it up. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: DC offset removal > HPF 80Hz > noise reduction (opt) > click removal (opt) NO compression, NO normalize, NO LUFS. Just clean.
Args: remove_noise: Apply noise reduction using first 0.5s as noise profile. Default: True remove_clicks: Remove clicks/pops (useful for vinyl/old recordings). Default: False
IMPORTANT: If remove_noise is True, the first 0.5 seconds should be room tone / silence. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: remove_noise, remove_clicks.
auto_cleanup_interviewA
ONE-CLICK INTERVIEW CLEANUP: Light-touch processing for dialogue and multiple speakers. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: DC offset > HPF 80Hz > noise reduction 8dB > compression 2.5:1 > safe loudness check. Lighter than podcast — preserves natural conversation dynamics.
Args: remove_noise: Apply noise reduction using first 0.5s as noise profile. Default: True remove_silence: Truncate long silences. Default: False
IMPORTANT: If remove_noise is True, the first 0.5 seconds should be room tone / silence. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: remove_noise, remove_silence.
auto_cleanup_liveA
ONE-CLICK LIVE RECORDING CLEANUP: Aggressive processing for noisy/field recordings. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: DC offset > HPF 100Hz > click removal > noise reduction 12dB > compression 5:1 > safe loudness check. Designed for live performances, field recordings, and noisy environments. Noise reduction is always on at 12dB — max safe level before artifacts appear.
IMPORTANT: The first 0.5 seconds MUST be room tone / ambient noise for noise profiling. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: no named parameters.
auto_cleanup_podcastA
ONE-CLICK PODCAST CLEANUP: Professional broadcast-quality processing. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor. Safe for badly recorded audio — only reduces peaks if too hot, never boosts.
Pipeline: DC offset > HPF 80Hz > NR 12dB > compress 3:1 (30ms attack, 200ms release) > safe loudness check. Optional: noise reduction (on by default), silence truncation (off by default).
After the pipeline finishes, the user can manually apply LUFS normalization using the loudness_normalize tool if they want to hit a specific streaming target.
Args: remove_noise: Apply noise reduction using first 0.5s as noise profile. Default: True remove_silence: Truncate long silences/dead air. Default: False
IMPORTANT: If remove_noise is True, the first 0.5 seconds should be room tone / silence. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: remove_noise, remove_silence.
auto_cleanup_vocalA
ONE-CLICK VOCAL CLEANUP: Professional processing for singing and studio vocals. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: DC offset > HPF 100Hz > noise reduction 10dB > compression 3:1 > presence EQ > safe loudness check. Tuned for singing — presence boost for clarity, higher HPF for plosive removal.
Args: remove_noise: Apply noise reduction using first 0.5s as noise profile. Default: True
IMPORTANT: If remove_noise is True, the first 0.5 seconds should be room tone / silence. DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: remove_noise.
auto_lofi_effectA
CREATIVE LO-FI EFFECT: Apply a vintage/lo-fi sound to your audio. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline: HPF > LPF > bass/treble warmth > compression 2:1 > safe loudness check Creates that warm, muffled, vintage sound by cutting highs and boosting low-mids.
Args: intensity: "light" (subtle warmth), "medium" (classic lo-fi), "heavy" (extreme tape sound). Default: "medium"
DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: intensity.
auto_master_musicA
ONE-CLICK MUSIC MASTERING: Professionally master your music track with genre-tuned settings. Runs in background — returns a job_id immediately. Use check_pipeline_status to monitor.
Pipeline:
High-pass filter (remove sub-rumble)
Click removal (clean artifacts)
Noise reduction (optional, off by default for produced music)
Compression (genre-tuned, mastering-grade, no post-normalize)
Bass/treble sweetening (gentle, genre-tuned)
Safe loudness check (only reduces peaks if too hot, never boosts)
Args: style: Genre preset - "edm", "hiphop", "rock", "acoustic", "pop", "classical". Default: "edm" noise_reduce: Apply gentle noise reduction. Default: False DO NOT call this again if a pipeline is already running — use check_pipeline_status instead.
Inputs: style, noise_reduce.
check_pipeline_statusA
Check the status of a running pipeline. Call this after starting any auto_ pipeline to monitor progress. Poll every 15-30 seconds.
Args: job_id: The job ID returned by any auto_ pipeline tool
Inputs: job_id (required).
check_transcription_statusA
[EXPERIMENTAL] Check the status of a running transcription job. Call this after starting transcribe_audio, transcribe_to_labels, or transcribe_to_file. Poll every 10-15 seconds until status is 'complete' or 'error'.
Args: job_id: The job ID returned when you started the transcription.
Inputs: job_id (required).
click_removalA
Remove clicks and pops from the selected audio (e.g. vinyl recordings).
Args: threshold: Click detection threshold (0-900). Higher = fewer clicks removed. Default: 200 spike_width: Maximum width of a click in samples (0-40). Default: 20
Inputs: threshold, spike_width.
compressorA
Apply dynamic range compression. Evens out volume differences.
For mastering, use ratio 1.5-2:1 with attack > 80ms to preserve transients. For podcasts/voice, use ratio 4-8:1 with use_peak=True for tighter control. Higher ratios (4:1+) and fast attacks are mixing tools, not mastering tools.
WARNING: normalize=True will re-peak your audio to 0 dB after compression, which can make loud audio even louder. Use loudness_normalize() instead for proper LUFS-based loudness control.
Args: threshold_db: Level above which compression starts (dB). Default: -12 noise_floor_db: Level below which audio is not boosted (dB). Default: -40 ratio: Compression ratio (e.g. 2.0 = 2:1). Default: 2.0 attack_time: How fast compressor engages (seconds). Default: 0.2 release_time: How fast compressor releases (seconds). Default: 1.0 normalize: Normalize to 0dB peak after compression. Default: False use_peak: Compress based on peaks instead of RMS (better for voice/podcast). Default: False
Inputs: ratio, use_peak, normalize, attack_time, +3 more.
cursor_set_positionA
Move the cursor to a specific time position.
Args: time: Position in seconds
Inputs: time (required).
cursor_to_project_endA
Move the cursor to the end of the project (last audio).
Inputs: no named parameters.
cursor_to_project_startA
Move the cursor to the start of the project (time 0).
Inputs: no named parameters.
cursor_to_track_endA
Move the cursor to the end of the selected track.
Inputs: no named parameters.
cursor_to_track_startA
Move the cursor to the start of the selected track.
Inputs: no named parameters.
edit_copyA
Copy the selected audio to clipboard. Select a region first.
Inputs: no named parameters.
edit_cutA
Cut the selected audio to clipboard. Select a region first.
Inputs: no named parameters.
edit_deleteA
Delete the selected audio (does not copy to clipboard). Select a region first.
Inputs: no named parameters.
edit_disjoinB
Split the selected audio at detected silences, creating separate clips.
Inputs: no named parameters.
edit_duplicateA
Duplicate the selected audio into a new track.
Inputs: no named parameters.
edit_joinA
Join selected clips into one clip.
Inputs: no named parameters.
edit_pasteA
Paste audio from clipboard at the cursor position.
Inputs: no named parameters.
edit_silenceB
Replace the selected audio with silence.
Inputs: no named parameters.
edit_splitA
Split the clip at the cursor position or selection boundaries (in place, no new track).
Inputs: no named parameters.
edit_split_cutA
Cut the selected audio without closing the gap (leaves silence where audio was).
Inputs: no named parameters.
edit_split_deleteA
Delete the selected audio without closing the gap (leaves silence where audio was).
Inputs: no named parameters.
edit_split_newA
Split the selected audio into a new track at the selection boundaries.
Inputs: no named parameters.
edit_trimA
Trim audio outside the selection (delete everything except selected region).
Inputs: no named parameters.
effect_adjustable_fadeB
Apply an adjustable fade with curve control.
Args: fade_type: 0=fade up (in), 1=fade down (out). Default: 0 curve: Curve shape (0=linear, positive=exponential, negative=logarithmic). Default: 0
Inputs: curve, fade_type.
effect_amplifyA
Amplify the selected audio by a ratio. Select audio first.
Args: ratio: Amplification ratio (e.g. 1.5 = 150%, 0.5 = 50%). Must be > 0. Default: 1.0
Inputs: ratio.
effect_auto_duckA
Auto Duck: automatically reduce volume when audio is detected on another track. Place the control track (e.g. narration) above the track to duck (e.g. music). Select the track to duck before running.
Args: duck_amount_db: How much to reduce volume in dB (-24 to 0). Default: -12 inner_fade_down_len: Inner fade down length in seconds (>= 0). Default: 0 inner_fade_up_len: Inner fade up length in seconds (>= 0). Default: 0 outer_fade_down_len: Outer fade down length in seconds (>= 0). Default: 0.5 outer_fade_up_len: Outer fade up length in seconds (>= 0). Default: 0.5 threshold_db: Threshold for duck trigger in dB (-100 to 0). Default: -30 maximum_pause: Maximum pause between ducking regions in seconds (>= 0). Default: 1.0
Inputs: threshold_db, maximum_pause, duck_amount_db, inner_fade_up_len, +3 more.
effect_bass_and_trebleA
Adjust bass and treble frequencies with a simple tonal shaping tool.
Args: bass: Bass adjustment in dB (-30 to 30). Default: 0 treble: Treble adjustment in dB (-30 to 30). Default: 0 gain: Output gain in dB (-30 to 30). Default: 0
Inputs: bass, gain, treble.
effect_change_pitchA
Change the pitch of the selected audio without changing tempo.
Args: semitones: Number of semitones to shift (negative = lower, positive = higher)
Inputs: semitones.
effect_change_speedA
Change speed of the selected audio (changes both tempo and pitch together).
Args: percent: Percentage change (-99 to 4900, e.g. 100 = double speed)
Inputs: percent.
effect_change_tempoB
Change the tempo of the selected audio without changing pitch.
Args: percent: Percentage change (-95 to 3000, e.g. 50 = 50% faster, -25 = 25% slower)
Inputs: percent.
effect_clip_fixA
Attempt to repair clipped (distorted) audio by reconstructing peaks.
Args: threshold: Clipping threshold as percentage of max amplitude (0-100). Default: 95
Inputs: threshold.
effect_crossfade_clipsA
Crossfade between two adjacent clips on the same track. Select the junction point between two clips first.
Inputs: no named parameters.
effect_crossfade_tracksA
Crossfade between two overlapping tracks. Align the tracks so they overlap, select both, then run this effect.
Inputs: no named parameters.
effect_distortionB
Apply distortion effect to the selected audio.
Args: distortion_type: Type of distortion. Default: "Hard Clipping" threshold_db: Distortion threshold in dB (-100 to 0). Default: -6.0
Inputs: threshold_db, distortion_type.
effect_echoB
Apply echo effect to the selected audio.
Args: delay: Delay time in seconds. Default: 0.5 decay: Decay factor (0-1, lower = faster decay). Default: 0.5
Inputs: decay, delay.
effect_equalizationC
Apply EQ curve to the selected audio.
Args: curve_name: Name of the EQ preset curve. Default: "Default" length: Filter length (odd number, 21-8191). Default: 4001
Inputs: length, curve_name.
effect_fade_inA
Apply a fade-in to the selected audio. Select the region to fade first.
Inputs: no named parameters.
effect_fade_outA
Apply a fade-out to the selected audio. Select the region to fade first.
Inputs: no named parameters.
effect_high_pass_filterA
Apply a high-pass filter to remove low frequencies below the cutoff. Essential as step 1 in mastering chains to remove sub-rumble.
Args: frequency: Cutoff frequency in Hz. Default: 40 (removes sub-bass rumble) rolloff: Rolloff steepness - "dB6" (6 dB/octave) or "dB12" (12 dB/octave). Default: "dB12"
Inputs: rolloff, frequency.
effect_invertA
Invert (flip phase) the selected audio. Useful for phase cancellation.
Inputs: no named parameters.
effect_low_pass_filterB
Apply a low-pass filter to remove high frequencies above the cutoff.
Args: frequency: Cutoff frequency in Hz. Default: 20000 rolloff: Rolloff steepness - "dB6" (6 dB/octave) or "dB12" (12 dB/octave). Default: "dB6"
Inputs: rolloff, frequency.
effect_notch_filterA
Remove a specific frequency (e.g. 50/60Hz hum) with a notch filter.
Args: frequency: Center frequency to remove in Hz. Default: 60 (US mains hum) q: Q factor / sharpness of the notch (0.1-20). Higher = narrower notch. Default: 1.0
Inputs: q, frequency.
effect_paulstretchA
Extreme time-stretch effect (creates ambient/drone textures). Select audio first.
Args: stretch_factor: How much to stretch (1.0 = no change, 10.0 = 10x longer). Default: 10.0 time_resolution: Time resolution in seconds (smaller = better quality, slower). Default: 0.25
Inputs: stretch_factor, time_resolution.
effect_phaserB
Apply phaser effect to the selected audio.
Args: stages: Number of phaser stages (2-24, even only). Default: 2 dry_wet: Dry/wet mix (0=dry, 255=wet). Default: 128 frequency: LFO frequency in Hz (0.01-40). Default: 0.4 phase: LFO start phase in degrees (0-360). Default: 0 depth: Modulation depth (0-255). Default: 100 feedback: Feedback percentage (-100 to 100). Default: 0
Inputs: depth, phase, stages, dry_wet, +2 more.
effect_repairA
Repair a very short damaged section of audio (max 128 samples). Select the damaged region first — must be extremely short. Audacity will show an error popup if the selection is too long.
Inputs: no named parameters.
effect_repeatB
Repeat the selected audio a number of times.
Args: count: Number of times to repeat (1-128). Default: 1
Inputs: count.
effect_reverbB
Apply reverb effect to the selected audio.
Args: room_size: Room size percentage (0-100). Default: 75 pre_delay: Pre-delay in ms (0-200). Default: 10 reverberance: Reverberance percentage (0-100). Default: 50 hf_damping: High frequency damping (0-100). Default: 50 tone_low: Tone low percentage (0-100). Default: 100 tone_high: Tone high percentage (0-100). Default: 100 wet_gain: Wet signal gain in dB. Default: -1.0 dry_gain: Dry signal gain in dB. Default: -1.0 stereo_width: Stereo width (0-100). Default: 100 wet_only: Output only the wet signal. Default: False
Inputs: dry_gain, tone_low, wet_gain, wet_only, +6 more.
effect_reverseA
Reverse the selected audio. Select a region first.
Inputs: no named parameters.
effect_sliding_stretchA
Change tempo and/or pitch gradually across the selection (sliding time stretch).
Args: rate_change_start: Tempo change at start in % (-99 to 3000). Default: 0 rate_change_end: Tempo change at end in % (-99 to 3000). Default: 0 pitch_change_start: Pitch change at start in semitones (-12 to 12). Default: 0 pitch_change_end: Pitch change at end in semitones (-12 to 12). Default: 0
Inputs: rate_change_end, pitch_change_end, rate_change_start, pitch_change_start.
effect_studio_fade_outA
Apply a professional studio-quality fade out to the selected audio. Uses a specially shaped curve that sounds more natural than a linear fade.
Inputs: no named parameters.
effect_tremoloB
Apply tremolo (volume oscillation) effect to the selected audio.
Args: frequency: Tremolo speed in Hz (1-1000). Default: 5 depth: Tremolo depth as percentage (0-100). Default: 40 waveform: 0=Sine, 1=Triangle, 2=Sawtooth, 3=InverseSawtooth, 4=Square. Default: 0
Inputs: depth, waveform, frequency.
effect_vocal_reductionA
Vocal Reduction and Isolation: remove or isolate vocals from a stereo track.
Args: action: 0=Remove Vocals, 1=Isolate Vocals, 2=Remove Vocals (Mono), 3=Isolate Vocals (Mono), 4=Remove Center, 5=Isolate Center. Default: 0 low_cutoff: Low frequency cutoff in Hz. Default: 120 high_cutoff: High frequency cutoff in Hz. Default: 9000 strength: Effect strength (0-50). Default: 1.0
Inputs: action, strength, low_cutoff, high_cutoff.
effect_wahwahC
Apply wahwah effect to the selected audio.
Args: frequency: LFO frequency in Hz (0.1-4.0). Default: 1.5 phase: LFO start phase (0-360). Default: 0 depth: Modulation depth (0-100). Default: 70 resonance: Resonance (0.1-10). Default: 2.5 offset: Frequency offset (0-100). Default: 30
Inputs: depth, phase, offset, frequency, +1 more.
generate_chirpB
Generate a chirp (frequency sweep).
Args: waveform: "Sine", "Square", "Sawtooth", or "Square (no alias)". Default: "Sine" start_freq: Starting frequency in Hz. Default: 440 end_freq: Ending frequency in Hz. Default: 1320 start_amp: Starting amplitude (0-1). Default: 0.8 end_amp: Ending amplitude (0-1). Default: 0.1 duration: Duration in seconds. Default: 1.0
Inputs: end_amp, duration, end_freq, waveform, +2 more.
generate_dtmfA
Generate DTMF (telephone) tones.
Args: sequence: DTMF characters (0-9, A-D, *, #). Default: "0123456789" duty_cycle: Tone vs silence ratio percentage (0-100). Default: 55 amplitude: Amplitude (0-1). Default: 0.8 duration: Total duration in seconds. Default: 1.0
Inputs: duration, sequence, amplitude, duty_cycle.
generate_noiseC
Generate noise.
Args: noise_type: "White", "Pink", or "Brownian". Default: "White" amplitude: Amplitude (0-1). Default: 0.8 duration: Duration in seconds. Default: 1.0
Inputs: duration, amplitude, noise_type.
generate_rhythm_trackB
Generate a click/rhythm track.
Args: tempo: Tempo in BPM (30-300). Default: 120 beats_per_bar: Beats per bar (1-32). Default: 4 number_of_bars: Number of bars to generate (1-1000). Default: 4 rhythm_pattern: "Uniform" or "Swing". Default: "Uniform"
Inputs: tempo, beats_per_bar, number_of_bars, rhythm_pattern.
generate_toneB
Generate a tone signal.
Args: waveform: Wave type - "Sine", "Square", "Sawtooth", or "Square (no alias)". Default: "Sine" frequency: Frequency in Hz (1-20000). Default: 440 amplitude: Amplitude (0-1). Default: 0.8 duration: Duration in seconds. Default: 1.0
Inputs: duration, waveform, amplitude, frequency.
get_default_export_folderA
Get the default folder for exporting audio files. Returns the user's Music folder path. Use this when the user doesn't specify where to save.
Inputs: no named parameters.
get_default_transcription_folderA
Get the default folder for saving transcription files. Returns the user's Documents folder. Call this when the user doesn't specify where to save.
Inputs: no named parameters.
get_noise_profileA
Capture a noise profile from the currently selected audio region. IMPORTANT: Select a region of pure noise (e.g. 0.5-2 seconds of silence/background noise) before calling this. This profile is used by the noise_reduction tool.
How it works: The first call to NoiseReduction without an existing profile captures the selection as the noise profile. The next call applies reduction.
Inputs: no named parameters.
label_addB
Add a label at the current cursor position or selection.
Args: text: Label text. Default: empty
Inputs: text.
label_add_atB
Add a label at a specific time range.
Args: start: Start time in seconds end: End time in seconds text: Label text. Default: empty
Inputs: end (required), start (required), text.
label_add_batchA
Add many labels at once — a whole marker list in one call.
Each item is {"start": seconds, "end": seconds (optional, defaults to start for a point label), "text": string (optional)}. Every item is validated before anything is sent to Audacity, so a bad item fails the whole call rather than leaving a half-written list behind.
Args: labels: List of {"start", "end", "text"} label definitions
Inputs: labels (required).
label_cut_regionsA
Cut the audio under every label to the clipboard, closing the gaps.
Acts on labeled regions within the current selection on the SELECTED AUDIO TRACKS — select the audio tracks and time range first. Because the timeline closes up, the labeled regions collapse rather than surviving unchanged — re-read label_list afterwards to see what remains.
Not yet independently live-tested against a running Audacity, unlike label_delete_regions/label_silence_regions/label_split_regions/ label_join_regions.
Inputs: no named parameters.
label_deleteA
Delete a single label without touching the audio.
Get the index from label_list. Audacity has no scripting command for deleting one label, so this selects the label's own span on its own label track and split-deletes it — audio tracks are never in the selection, and nothing downstream shifts in time.
Other labels on the same track that sit entirely inside the deleted label's span would be removed as collateral, so they are re-added afterwards. A label that only partially overlaps the span may be trimmed to the boundary; check label_list afterwards if labels on that track overlap each other.
To delete a label and the audio under it, use label_delete_audio_at.
Args: index: Flat label index from label_list
Inputs: index (required).
label_delete_audio_atA
Delete the audio under ONE label, picked by index — not label_delete (marker only) or label_delete_regions (every label in the current selection, no index).
This is a custom, composite operation built for podcast/transcript-based editing, not a 1:1 wrapper over a single Audacity scripting command — unlike label_cut_regions/label_delete_regions/label_silence_regions/ label_split_regions/label_join_regions, which each call exactly one Audacity command. Audacity has no "delete this one labeled take" command, so this orchestrates several: SelAllTracks, then SelectTime, then Delete/SplitDelete, then clears the leftover marker.
By default the gap closes and everything after shifts left, exactly as label_delete_regions does. Pass close_gap=False to leave silence of the same length instead, keeping the timeline length and everything after it in place.
All tracks are selected first, so label tracks ripple along with the audio and later labels stay aligned with it.
Deleting the audio does NOT remove the label — it collapses to a zero-length marker sitting where the audio used to be. This tool clears that leftover marker too, matching what clicking a label and pressing Delete does in Audacity: the audio and the label both go. Pass delete_label=False to keep it as a marker of where the cut was made. Use label_delete instead to remove a label without touching any audio.
Args: index: Flat label index from label_list close_gap: Close the gap and shift later audio left. Default: True delete_label: Also remove the label left behind. Default: True
Inputs: index (required), close_gap, delete_label.
label_delete_regionsA
Delete the audio under every label, closing the gaps.
Label every unwanted stretch — bad takes, dead air, noise bursts — then remove them all in one pass. Use label_delete_audio_at for a single label. Acts on labeled regions within the current selection on the SELECTED AUDIO TRACKS — select the audio tracks and time range first. Because the timeline closes up, the labeled regions collapse rather than surviving unchanged — re-read label_list afterwards to see what remains.
Inputs: no named parameters.
label_editA
Edit an existing label's text and/or timing. Only the fields you pass are changed.
Get the index from label_list. Renaming a label is label_edit(index, text="..."); moving one of its boundaries is label_edit(index, start=...).
Args: index: Flat label index from label_list text: New label text. Default: unchanged start: New start time in seconds. Default: unchanged end: New end time in seconds. Default: unchanged
Inputs: index (required), end, text, start.
label_exportB
Export all labels to a text file.
Args: path: Absolute path for the output labels file
Inputs: path (required).
label_export_audio_segmentsA
Export the audio under each label as its own file.
Splits a long recording into per-segment audio files, named "01_Segment_Title.wav" and so on from the label text. ALWAYS tell the user which directory the files will be written to BEFORE calling this. Point labels (zero length) have no audio to export and are skipped. Existing files are never overwritten — they are skipped and reported. This can take a while for many or long segments.
Not yet independently live-tested against a running Audacity — verified against the scripting reference and unit tests with mocked responses only.
Args: directory: Absolute path to the output directory format: Audio format — wav, mp3, ogg, flac, aiff, mp4. Default: wav num_channels: 1 for mono, 2 for stereo. Default: 2
Inputs: directory (required), format, num_channels.
label_export_chaptersA
Export labels as a chapter/marker file.
Turns a label track into a standard marker file — chapter navigation for long-form audio, a track listing for a continuous mix, an index for a lecture or interview recording. Formats: "simple" (HH:MM:SS.mmm Title per line), "cue" (cue sheet), "podlove" (Podlove Simple Chapters JSON). Labels with no text become "Chapter 1", "Chapter 2" and so on.
Not yet independently live-tested against a running Audacity — verified against the scripting reference and unit tests with mocked responses only.
Args: path: Absolute path for the output file (must not already exist) format: Chapter format — simple, cue or podlove. Default: simple
Inputs: path (required), format.
label_findA
Find labels whose text contains a search string (case-insensitive).
Useful for locating a specific marker in a long recording without reading through every label.
Args: query: Text to search for within label text
Inputs: query (required).
label_get_allA
Get all labels in the project as Audacity's raw GetInfo response.
Prefer label_list — it returns the same labels already parsed, with the index each one needs for label_edit and label_delete.
Inputs: no named parameters.
label_importB
Import labels from a text file.
Args: path: Absolute path to the labels text file
Inputs: path (required).
label_join_regionsA
Join the audio clips across every labeled region back together.
The inverse of label_split_regions. Acts on labeled regions within the current selection on the SELECTED AUDIO TRACKS — select the audio tracks and time range first. The labels themselves stay where they are.
Inputs: no named parameters.
label_listA
List every label with its index, timing and text.
Returns labels sorted by Audacity's own flat index, which is what label_edit and label_delete take. Call this first whenever you need to modify a specific label, rather than guessing an index.
Inputs: no named parameters.
label_regular_intervalsB
Create labels at regular time intervals across the selection or project.
Args: interval: Time between labels in seconds. Default: 30 adjust: Adjust interval to fit selection evenly. Default: False label_text: Text for each label (labels will be numbered). Default: empty
Inputs: adjust, interval, label_text.
label_silence_regionsA
Replace the audio under every label with silence, keeping the timeline length.
Use when the material must not get shorter — redacting a name, muting a noise burst in a take that has to stay in sync. Acts on labeled regions within the current selection on the SELECTED AUDIO TRACKS — select the audio tracks and time range first. The labels themselves stay where they are.
Inputs: no named parameters.
label_split_regionsA
Split the audio clips at every label boundary.
Prepares segment boundaries for separate handling without removing anything. Acts on labeled regions within the current selection on the SELECTED AUDIO TRACKS — select the audio tracks and time range first. The labels themselves stay where they are.
Inputs: no named parameters.
limiterB
Apply a limiter to prevent audio from exceeding a threshold. Use after compression.
Default ceiling is -1.0 dB, the industry standard for streaming platforms.
Args: limit_db: Maximum output level (dB). Default: -1.0 hold_ms: Hold time in milliseconds. Default: 10.0 makeup_gain: Apply makeup gain ("Yes" or "No"). Default: "No" limiter_type: "SoftLimit", "HardLimit", "SoftClip", "HardClip". Default: "SoftLimit" gain_left: Input gain for left channel (dB). Default: 0.0 gain_right: Input gain for right channel (dB). Default: 0.0
Inputs: hold_ms, limit_db, gain_left, gain_right, +2 more.
loudness_normalizeA
Normalize audio to a target perceived loudness in LUFS.
DANGER — READ BEFORE USING: This tool can DESTROY audio if used incorrectly. It boosts OR reduces audio to hit the target LUFS. On quiet or poorly recorded audio, it may boost by 20-30 dB, causing severe clipping and distortion that ruins the file.
DO NOT use this tool:
Right after a pipeline (pipelines already handle loudness safely)
On raw/unprocessed audio (clean it up first)
Without first running auto_analyze_audio to check current levels
If the audio peaks below -20 dB (it's too quiet — use normalize first to gently raise levels)
ONLY use this tool when the user EXPLICITLY asks for LUFS normalization AND the audio has already been processed and has healthy levels (peaks between -6 dB and -1 dB).
Targets (only use these values):
-16 LUFS: Podcast, broadcast, Apple Music
-14 LUFS: Spotify, YouTube, most streaming
-11 LUFS: Loud masters (hip-hop/EDM)
Args: lufs_level: Target loudness in LUFS (-50 to -5). Default: -16.0 stereo_independent: Normalize L/R channels independently. Default: False dual_mono: Treat mono as dual-mono for correct LUFS measurement. Default: True
Inputs: dual_mono, lufs_level, stereo_independent.
noise_reductionA
Apply noise reduction to the selected audio. You MUST call get_noise_profile first on a region of pure noise, then select the audio you want to clean, then call this.
WARNING: Values above 20 dB risk audible artifacts (warbling, metallic sound). Use 6-12 dB for gentle cleanup, 12-20 dB for moderate noise. Only exceed 20 dB for extremely noisy recordings where some artifact trade-off is acceptable.
Args: noise_reduction_db: Amount of noise reduction in dB (0-48). Default: 12 sensitivity: How sensitive the detection is (0-24). Default: 6 frequency_smoothing: Number of frequency smoothing bands (0-12). Default: 3
Inputs: sensitivity, noise_reduction_db, frequency_smoothing.
normalizeA
Normalize the selected audio to a target peak level.
WARNING: This boosts OR reduces audio to hit the target. If audio peaks at -30 dB and you normalize to -1 dB, it will BOOST by 29 dB — potentially blowing out the audio. ALWAYS check current audio levels first (use project_get_info) before normalizing.
Guidelines — choose your target based on what comes next:
-3 dB (default): Safe general-purpose level with headroom for further processing
-6 dB: Conservative, good for unknown or problematic audio
-1 dB: ONLY as a final ceiling on already-mastered audio (never on raw audio)
-12 dB or lower: For very quiet audio that needs gentle boosting
Args: peak_level_db: Target peak level in dB (-60 to 0). Default: -3.0 remove_dc: Remove DC offset before normalizing. Default: True stereo_independent: Normalize L/R channels separately (fixes unbalanced recordings). Default: False
Inputs: remove_dc, peak_level_db, stereo_independent.
project_closeB
Close the current Audacity project.
Inputs: no named parameters.
project_edit_metadataA
Open the metadata editor dialog to view/edit track metadata (title, artist, etc.). This opens a modal dialog in Audacity — the command waits until the user closes it.
Inputs: no named parameters.
project_export_audioA
Export the project audio to a file. Format is determined by file extension.
MANDATORY: ALWAYS tell the user where the file will be saved BEFORE exporting. Example: "I'll save your audio to C:\Users\Name\Music\file.mp3"
NEVER save directly to the user's home folder (e.g. ~/file.mp3 or C:\Users\Name\file.mp3). ALWAYS save to a subfolder. If the user doesn't specify a path, call get_default_export_folder to get their Music folder and save there. Acceptable locations:
Music folder: ~/Music/file.mp3
Documents folder: ~/Documents/file.mp3
Desktop: ~/Desktop/file.mp3 NEVER save to the home folder root — this clutters the user's home directory.
Args: path: Absolute path for exported file. Extension determines format (wav, mp3, ogg, flac, aiff). num_channels: Number of channels (1=mono, 2=stereo). Default: 2
Inputs: path (required), num_channels.
project_export_labelsB
Export all labels to a text file.
Args: path: Absolute path for the exported labels file
Inputs: path (required).
project_get_infoB
Get information about the current project.
Args: info_type: Type of info to retrieve. One of: Tracks, Clips, Envelopes, Labels, Boxes, Commands
Inputs: info_type.
project_import_audioA
Import an audio file into the current project. Creates a new track.
Args: path: Absolute path to the audio file (wav, mp3, ogg, flac, etc.)
Inputs: path (required).
project_import_midiA
Import a MIDI file into the current project.
Args: path: Absolute path to the MIDI file (.mid, .midi)
Inputs: path (required).
project_newA
Create a new empty Audacity project.
Inputs: no named parameters.
project_openB
Open an existing Audacity project file (.aup3).
Args: path: Absolute path to the .aup3 project file
Inputs: path (required).
project_saveA
Save the current Audacity project. ONLY call this when the user explicitly asks to save. Do NOT auto-save after effects or pipelines — the user controls when to save.
Inputs: no named parameters.
project_save_asA
Save the current project to a new .aup3 file. ONLY call when user explicitly asks. Do NOT auto-save after effects or pipelines.
Args: path: Absolute path for the new .aup3 file
Inputs: path (required).
select_allA
Select all audio in all tracks. Selects both tracks and time range.
Inputs: no named parameters.
select_clipB
Select the clip under the cursor.
Inputs: no named parameters.
select_cursor_to_track_endA
Select from the current cursor position to the end of the track.
Inputs: no named parameters.
select_noneA
Deselect all audio.
Inputs: no named parameters.
select_regionC
Select a time region in the current track(s). Many effects operate on the selection.
Args: start: Start time in seconds end: End time in seconds
Inputs: end (required), start (required).
select_tracksA
Select one or more tracks by index.
Args: track: Starting track index (0-based) count: Number of tracks to select
Inputs: track (required), count.
select_zero_crossingA
Adjust the current selection boundaries to the nearest zero crossings. Useful before cuts to avoid audible clicks at edit points.
Inputs: no named parameters.
track_add_labelA
Add a new empty label track to the project.
Inputs: no named parameters.
track_add_monoA
Add a new mono audio track to the project.
Inputs: no named parameters.
track_add_stereoA
Add a new stereo audio track to the project.
Inputs: no named parameters.
track_align_end_to_endB
Align selected tracks end-to-end (sequentially). Select the tracks first.
Inputs: no named parameters.
track_get_infoA
Get information about all tracks in the project (names, types, rates, etc.).
Inputs: no named parameters.
track_mix_and_renderA
Mix and render selected tracks into a single track. Select tracks first.
Inputs: no named parameters.
track_mix_and_render_to_newA
Mix and render selected tracks into a new track, keeping the originals. Select tracks first.
Inputs: no named parameters.
track_muteB
Mute or unmute a track.
Args: track: Track index (0-based) mute: True to mute, False to unmute
Inputs: track (required), mute.
track_mute_allA
Mute all tracks in the project.
Inputs: no named parameters.
track_removeA
Remove the currently selected track(s). Select tracks first with track_select.
Inputs: no named parameters.
track_resampleA
Resample the selected track to a new sample rate.
Args: rate: Target sample rate in Hz (e.g. 44100, 48000, 96000). Must be > 0.
Inputs: rate.
track_selectA
Select a track by index. Many operations require selecting a track first.
Args: track: Track index (0-based)
Inputs: track (required).
track_set_propertiesB
Set properties of a track by index.
Args: track: Track index (0-based) name: New track name gain: Track gain in dB (-36 to 36) pan: Track pan (-1.0=left to 1.0=right) mute: Mute the track solo: Solo the track
Inputs: track (required), pan, gain, mute, +2 more.
track_stereo_to_monoA
Convert the selected stereo track to mono. Select the track first.
Inputs: no named parameters.
track_unmute_allA
Unmute all tracks in the project.
Inputs: no named parameters.
transcribe_audioA
[EXPERIMENTAL] Transcribe the entire project audio using faster-whisper (local, offline). Requires separate setup — see installation guide. If this fails, tell the user transcription is experimental and point them to the Transcription Setup docs.
Runs in BACKGROUND — returns a job_id immediately. Use check_transcription_status to monitor progress. Poll every 10-15 seconds.
Do NOT call transcription_set_model first — this handles model loading automatically.
After transcription completes, TELL the user where the transcript was saved or offer to save it. Always tell the user the file location so they can find it.
Language auto-detection can occasionally misidentify the language (background
music, noise, a short/ambiguous clip) and transcribe genuinely-English audio
in the wrong script entirely. If you already know the audio's language from
context, pass language explicitly (e.g. "en") instead of relying on
auto-detect, or set task="translate" to force English output regardless of
the spoken language. If a result comes back in an unexpected language/script,
just retry with THIS SAME tool and the corrected language/task.
Args: model_size: Whisper model - "tiny", "base", "small", "medium", "large-v3". Default: "small" language: ISO language code (e.g. "en", "fr") or None for auto-detect task: "transcribe" or "translate" (translate converts any language to English)
Inputs: task, language, model_size.
transcribe_selectionA
[EXPERIMENTAL] Transcribe only the currently selected audio region. Requires separate setup — see installation guide.
Runs in BACKGROUND — returns a job_id immediately. Use check_transcription_status to monitor progress.
Select a region first, then call this tool.
Language auto-detection can occasionally misidentify the language on a short
or ambiguous clip. If you already know the audio's language, pass language
explicitly (e.g. "en"), or set task="translate" to force English output.
Args: model_size: Whisper model - "tiny", "base", "small", "medium", "large-v3" language: ISO language code or None for auto-detect task: "transcribe" or "translate"
Inputs: task, language, model_size.
transcribe_to_fileA
[EXPERIMENTAL] Transcribe audio and export to a subtitle or text file. Requires separate setup — see installation guide.
ALWAYS tell the user where the file will be saved BEFORE starting. If user doesn't specify a path, call get_default_export_folder to get a real path. NEVER guess paths like /home/user/... — always use absolute Windows paths like C:\Users\Name\Documents\transcript.srt
Runs in BACKGROUND — returns a job_id immediately. Use check_transcription_status to monitor progress.
Language auto-detection can occasionally misidentify the language (background
music, noise, a short/ambiguous clip) and transcribe genuinely-English audio
in the wrong script entirely. If you already know the audio's language from
context, pass language explicitly (e.g. "en"), or set task="translate" to
force English output regardless of the spoken language. Retry with THIS SAME
tool and the corrected language/task — use a new path since an existing file
at the same path is rejected below.
Args: path: Absolute path for the output file (e.g. "C:/Users/You/Documents/transcript.srt") format: Output format - "srt", "vtt", or "txt" model_size: Whisper model - "tiny", "base", "small", "medium", "large-v3" language: ISO language code (e.g. "en") or None for auto-detect task: "transcribe" (spoken language) or "translate" (always English)
Inputs: path (required), task, format, language, +1 more.
transcribe_to_labelsA
[EXPERIMENTAL] Transcribe audio and add Audacity labels at each segment timestamp. Requires separate setup — see installation guide.
Runs in BACKGROUND — returns a job_id immediately. Use check_transcription_status to monitor progress.
Language auto-detection can occasionally misidentify the language (background
music, noise, a short/ambiguous clip) and transcribe genuinely-English audio
in the wrong script entirely. If you already know the audio's language from
context (the user said so, or the labels came back in an unexpected script),
don't guess — pass language explicitly (e.g. "en"), or set task="translate"
to force English output regardless of the spoken language. Retry with THIS
SAME tool and the corrected language/task; there's no need to switch to a
different transcription tool to fix a bad language guess.
If labels from a previous attempt need clearing first: track_select the label track, then track_remove, before re-running this.
Args: model_size: Whisper model - "tiny", "base", "small", "medium", "large-v3" language: ISO language code (e.g. "en") or None for auto-detect task: "transcribe" (labels in the spoken language) or "translate" (labels always in English, regardless of the spoken language)
Inputs: task, language, model_size.
transcription_set_modelA
[EXPERIMENTAL] Pre-download a whisper model. ONLY call this if the user explicitly asks to download or change the model. Do NOT call this before transcribe_audio — transcription tools handle model loading automatically. Requires separate setup — see installation guide.
Runs in BACKGROUND — returns a job_id immediately. Use check_transcription_status to monitor progress.
Model sizes:
tiny: ~75MB (fastest, least accurate)
base: ~150MB (good balance for most use cases)
small: ~500MB (better accuracy, recommended)
medium: ~1.5GB (high accuracy)
large-v3: ~3GB (best accuracy, slowest)
Args: model_size: Model to load - "tiny", "base", "small", "medium", "large-v3"
Inputs: model_size.
transport_get_play_positionA
Get the current playback position in seconds.
Inputs: no named parameters.
transport_pauseB
Toggle pause during playback or recording.
Inputs: no named parameters.
transport_playB
Start playback from the current cursor position.
Inputs: no named parameters.
transport_play_regionB
Play a specific time region.
Args: start: Start time in seconds end: End time in seconds
Inputs: end (required), start (required).
transport_recordB
Start recording on a new track.
Inputs: no named parameters.
transport_set_cursorB
Set the playback cursor position.
Args: time: Position in seconds
Inputs: time (required).
transport_stopA
Stop playback or recording.
Inputs: no named parameters.
truncate_silenceA
Truncate or compress silence in the selected audio. Great for removing dead air.
Args: threshold_db: Volume below this is considered silence (dB). Default: -40 min_duration: Minimum silence duration to act on (seconds). Default: 0.5 truncate_to: Truncate silence to this duration (seconds). Default: 0.3 compress_percent: Compress silence by this percentage (only for Compress action). Default: 50 action: "Truncate" or "Compress". Default: "Truncate"
Inputs: action, truncate_to, min_duration, threshold_db, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 144 tools
Most tools are clearly distinct (project_, track_, label_, effect_ prefixes group by domain). However, there is notable redundancy and overlap: label_delete_audio_at vs label_cut_regions vs label_delete_regions vs label_split_regions vs label_silence_regions all operate on labeled regions with similar purposes. Similarly, cursor_to_track_end and select_cursor_to_track_end, and multiple label export functions (label_export, label_export_audio_segments, project_export_labels) create ambiguity about which to select.
The naming follows a consistent verb_noun or category_verb pattern (project_, track_, label_, effect_, edit_, select_, cursor_, transport_, generate_, auto_). There are a few inconsistencies like 'normalize' and 'compressor' and 'limiter' and 'click_removal' that lack the effect_ prefix used by sibling tools, and 'get_noise_profile'/'noise_reduction' deviate from the pattern, but overall the convention is strong and predictable.
144 tools is an extreme number for an audio editor MCP server. While Audacity is feature-rich, this surface is far beyond what agents can reasonably navigate. Many tools could be consolidated (e.g., the seven separate auto_cleanup_* pipelines, the large effect_* family, and the transcription set). This count will cause selection difficulty and cognitive overload for any agent.
The surface is quite comprehensive, covering project lifecycle (new/open/save/close/import/export), track management, selection, transport, editing, effects, generation, analysis, labeling, noise reduction, pipelines, and transcription. Minor gaps exist (no explicit record control for a specific track, no envelope editing beyond metadata, no undo/redo tools), but overall the domain is well covered for a full audio editing workflow.
Maintenance
Related MCP Connectors
Audio and video tools for your AI assistant: remove noise, enhance voices, transcribe, and more.
Audio for your agent: transcribe, speak, translate, summarise, plus sound effects and music.
Video, audio, and image processing for AI agents: convert, transcribe, upscale - 150+ operations.
Audio AI tools: transcription with speakers, stems, noise removal, MIDI, speech, voices and music.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceEnables LLM-driven audio pipelines by controlling Audacity through mod-script-pipe, allowing generative audio, effects, and export via MCP tool calls.MIT
- FlicenseNot gradedqualityDmaintenanceEnables AI assistants to programmatically edit, analyze, and export audio projects through MCP tools, including multi-track editing, effects, transcription, and semantic search.1-
- AlicenseBqualityCmaintenanceConnects any MCP-compatible AI assistant to Audacity, providing 132 tools for real-time audio editing, cleanup, mastering, and transcription — all running locally without cloud dependencies.100Apache 2.0
- AlicenseAqualityBmaintenanceEnables MCP-compatible AI assistants to control Audacity 4 locally for audio editing, effects, VST3 plugins, and cleanup pipelines via a TCP JSON-RPC bridge, with no cloud or API keys.15629 PyPI5Apache 2.0