Bragproof

← Reports

@mthines/reaper-mcp

Starts with no setup0.98.0npm

Installed, started with no arguments, no environment and no input, and listed its tools. Run 2026-11-16.

Needs to start: nothing
Returns a result when called with no setup: 0 of 5 tools tried
Contacts while installing and starting: nothing

190tools listed
0hosts contacted
2files written
0.5 sto start
320dependencies

Its tool definitions changed since version 0.83.2. If you approved the earlier ones, read them again.

What it contacted

Nothing besides the npm registry it was installed from. Watched from outside its sandbox while it was installed and started with no input. Its tools may still contact things when called.

Starting it

npx -y @mthines/reaper-mcp@0.98.0

Installing a package runs its code. Use a sandbox for anything you have not read.

Calling its tools

5 tools that take no input and look read-only were called once with nothing. 0 returned a result.

get_project_infoNo usable answer tool reported an error: Error: Bridge not running: no REAPER settings in /tmp/.config/REAPER: REAPER is not installed there or has never been started. Start REA
get_render_settingsNo usable answer tool reported an error: Error: Bridge not running: no REAPER settings in /tmp/.config/REAPER: REAPER is not installed there or has never been started. Start REA
get_project_settingsNo usable answer tool reported an error: Error: Bridge not running: no REAPER settings in /tmp/.config/REAPER: REAPER is not installed there or has never been started. Start REA
list_tracksNo usable answer tool reported an error: Error: Bridge not running: no REAPER settings in /tmp/.config/REAPER: REAPER is not installed there or has never been started. Start REA
get_transport_stateNo usable answer tool reported an error: Error: Bridge not running: no REAPER settings in /tmp/.config/REAPER: REAPER is not installed there or has never been started. Start REA

During the calls it contacted nothing it had not already contacted.

Only tools whose names read like looking something up, with no required input, are tried, five at most. Tools that need input, and anything that sounds like it changes or sends something, are not called.

What its tools tell an agent

In the tool descriptions, nothing that talks about the user, other tools or private files, or uses hidden characters.

Found by simple pattern rules in each tool's description (up to 3,000 characters), quoted as written. Parameter descriptions are not scanned. A clean result is not a safety review.

Tools

get_project_info
Get current REAPER project info: name, track count, tempo, time signature, sample rate, transport state
undo_project
Undo the last undo point in the REAPER project (any edit, including ones made by these tools) and report its label, plus the next undo/redo labels.
redo_project
Redo the last undone edit in the REAPER project and report its label, plus the next undo/redo labels.
save_project path, overwrite
Save the REAPER project. Without a path, saves it where it already lives. With path (an absolute .rpp file in an existing directory) it writes a copy there: the open project keeps its own path (savedAsCopy: true), so a never-saved project stays unsaved. Never opens a dialog: a never-saved project without path is refused; an existing different file is refused unless overwrite is true.
get_render_settings
Get the project render settings: output directory, file name pattern, format with its bit depth or MP3 bitrate, secondary format, source (master, stems, selected items, region matrix with its rows), bounds (custom/project/time_selection/…), custom start/end, sample rate (0 = project rate), channels, dither and noise shaping, loudness normalization and limiter, embedded metadata, and the target files a render would write.
185 more tools
set_render_settings outputDirectory, filePattern, format, secondaryFormat, source, regionMatrix, bounds, startTime, endTime, sampleRate, channels, bitDepth, mp3Bitrate, dither, noiseShaping, normalize, normalizeTarget, normalizeOnlyTooLoud, limit, limitCeiling, limitTruePeak, metadata, metadataRaw, embedMetadata
Set any of the project render settings; returns them as read back. All fields are validated before any is written, so an invalid request changes nothing. Covers what is rendered (source: master, stems of the selected tracks, master + stems, selected tracks via the master, the selected media items alone or through the master, the region render matrix), the encoding (bit depth, MP3 bitrate, dither), loudness normalization with a limiter, and embedded metadata.
render_project overwrite, tracks, analyze
Render the project with its current render settings (set them with set_render_settings) and return the files written, each measured: duration, integrated LUFS, true peak and sample peak. Synchronous: REAPER is busy until the render finishes, so keep renders short. Refused when a target file already exists (REAPER would ask) unless overwrite is true, when bounds is time_selection with no time selection, and when the format or secondary format is an encoder outside wav/aiff/flac/mp3/ogg/opus (they can open a dialog).
render_versions versions, overwrite, analyze
Render alternate versions in one call (instrumental, a cappella, TV mix, clean): for each version the listed tracks are muted on top of the current mutes, the file pattern gets "-<name>" (or the version's own filePattern), and the project renders with the current settings. Every track, name and target is checked before the first render; mutes and the file pattern are restored afterwards, also when a render fails. Each file comes back measured like render_project.
get_project_settings
Get project settings: path, sample rate and whether it is forced, title, author, notes, repeat (loop playback), and metronome (a global REAPER option).
set_project_settings sampleRate, useProjectSampleRate, title, author, notes, repeat, metronome
Set any of: sampleRate, useProjectSampleRate, title, author, notes, repeat, metronome. Returns the settings as read back. metronome is a global REAPER option (it is not stored in the project and undo does not revert it). Invalid values change nothing.
list_tracks parent, nameContains, compact, offset, limit
List tracks in the current REAPER project with name, index, volume, mute/solo state, and folder structure. In large sessions filter it: parent (a folder track — returns everything inside it), nameContains, compact (index, name, parentIndex, depth, volume, pan, mute, solo, fxCount only), offset/limit. With no params it returns every track as before; with any, it returns { total, offset, returned, hasMore, tracks }.
get_track_properties trackIndex
Get detailed properties of a specific track including volume, pan, mute, solo, and FX chain
set_track_property trackIndex, property, value
Set a track property: volume (dB), pan (-1.0 to 1.0), mute/solo/recordArm/phase (0/1), input (REAPER input index), playOffsetMs (track playback offset in ms, negative = earlier; use with measure_track_alignment)
add_fx trackIndex, fxName, position
Add an FX plugin to a track by name (e.g. "ReaEQ", "JS: Schwa's Spectral Analyzer", "VST: Pro-Q 3")
remove_fx trackIndex, fxIndex
Remove an FX plugin from a track by its index in the FX chain
get_fx_parameters trackIndex, fxIndex, namePattern, changedOnly, offset, limit
List parameters of an FX plugin with current values and ranges. Supports filtering by name pattern, changed-only filter, and pagination. For a quick summary of active EQ bands or compressor settings, use analyze_fx instead.
analyze_fx trackIndex, fxIndex
Analyze an FX plugin and return a compact summary: FX name, preset, and notable (non-default) parameters. For EQ plugins, detects active bands with frequency/gain/Q/shape. For compressors, extracts threshold/ratio/attack/release/makeup. Use this before get_fx_parameters to understand what a plugin is doing without reading 500+ parameters.
set_fx_parameter trackIndex, fxIndex, paramIndex, value
Set a specific FX parameter value (normalized 0.0–1.0 for most plugins; use the parameter maxValue from get_fx_parameters when it is above 1)
set_fx_enabled trackIndex, fxIndex, enabled
Enable or disable (bypass) an FX plugin on a track
set_fx_offline trackIndex, fxIndex, offline
Set an FX plugin online or offline. Offline FX uses no CPU but preserves settings.
read_track_meters trackIndex
Read real-time peak and RMS levels (in dB) for a track. Returns L/R peak and RMS values.
read_track_spectrum trackIndex, fftSize, includeBins
Read the real-time frequency spectrum of a track while audio plays. Auto-inserts the MCP Spectrum Analyzer JSFX if not present. Returns 1/3-octave bands (25 Hz-16 kHz, ~0.5 s smoothed), each with raw `db` and K-weighted `kDb` (the BS.1770 weighting LUFS uses). Judge on `kDb`, never `db` (raw levels overstate the lows and understate 2-5 kHz), and compare a band only with the same band on another track or a reference. Pre-fader (the analyzer sits in the track FX chain); each read is a ~0.5 s snapshot, so read several times. Raw FFT bins only with includeBins.
play
Start playback in REAPER
stop
Stop playback/recording in REAPER
record
Start recording in REAPER. Refused when no track is armed (REAPER would open a dialog that blocks the bridge): arm the target tracks first with set_track_record
get_transport_state
Get current transport state: play/record/pause status, cursor positions, tempo, time signature
set_cursor_position position
Move the edit cursor to a specific position in seconds from project start
list_available_fx category
Enumerate all installed FX plugins in REAPER (VST, VST3, JS, CLAP, AU) with an optional category filter
search_fx query
Search installed FX plugins by name (case-insensitive substring match)
get_fx_preset_list trackIndex, fxIndex
List all available presets for a specific FX plugin on a track. Reads names by loading each preset, then restores the FX state; a MIDI plugin (e.g. ReaControlMIDI) may send each preset's messages while listing. Lists over 256 (generic program slots) are not enumerated (truncated: true).
set_fx_preset trackIndex, fxIndex, presetName
Apply a named preset to an FX plugin on a track
snapshot_save name, description, includeFxParams, maxParamsPerFx, trackIndices, fullChunk, stretchMarkers
Save the current mixer state as a named snapshot. Stored in .reaper-mcp/snapshots/ alongside the project file (falls back to global bridge dir for unsaved projects). By default captures ALL tracks' volumes, pans, mutes, solos, FX bypass/offline states, full FX parameter values, preset names, track names/colors, and send levels. Pass trackIndices to scope the snapshot to specific tracks (e.g. just the master bus for an A/B that never touches other tracks). Pass fullChunk (or rely on its default-on when scoped) to capture exact track state chunks, which faithfully reproduce each plugin's internal state on restore — including plugins whose tone is driven by internal snapshots (e.g. Helix Native) that parameter-value capture cannot reproduce. Pass stretchMarkers to also keep the stretch markers of every audio item on the captured tracks (an alignment or a stretch edit): they are stored on their own, so they come back even where REAPER refuses to apply a track chunk (seen on tracks whose items carry Melodyne take FX). A fullChunk snapshot also holds each track's items (the whole chunk comes back on restore); without fullChunk a snapshot holds no items, only the stretch markers when asked for. Response includes storageLocation, scoped, fullChunk, tracksCaptured, and stretchMarkerItems.
snapshot_restore name, restoreTrackMeta, restoreSendLevels, restoreStretchMarkers
Restore a previously saved mixer snapshot by name. Reads from .reaper-mcp/snapshots/ alongside the project file (falls back to global bridge dir for unsaved projects). For chunk-based snapshots (saved with fullChunk), restores each captured track exactly via its state chunk — reproducing complete FX internal state (incl. plugin internal snapshots like Helix Native) and affecting only the tracks the snapshot captured. For parameter-based snapshots, restores volumes, pans, mutes, solos, FX bypass states, and FX parameters (parameters only when the plugin name matches, to avoid applying wrong values). Stretch markers saved with the snapshot are put back on their items afterwards, also when a track chunk could not be applied (the reply field stretchMarkers counts restored, unchanged and missing items).
snapshot_list
List all saved mixer snapshots for the current project. Reads from .reaper-mcp/snapshots/ alongside the project file (falls back to global bridge dir for unsaved projects). Response includes storageLocation ("project" or "global").
snapshot_delete name
Delete a named mixer snapshot. Removes the snapshot file from .reaper-mcp/snapshots/ alongside the project file (or global bridge dir for unsaved projects). This action is permanent and cannot be undone.
snapshot_edit name, newName, description
Rename a mixer snapshot and/or change its description. The saved mixer state is kept. A new name whose file belongs to another snapshot is refused.
get_track_routing trackIndex
Get sends, receives, and parent/folder information for a track — useful for understanding bus structure
add_send from, to, volume, pan, mute, mode, srcChannel, destChannel
Send one track to another (a bus, a reverb return, or a sidechain input). For a sidechain use mode "pre-fx" and destChannel 3; the destination is widened to 4 channels if needed. Tracks reach the master through their master send (set_track_info masterSend), not through add_send. Returns the new send as get_track_routing reports it.
add_hardware_output track, outputChannel, mono, volume, pan, mute, mode
Route a track straight to an audio interface output (outputChannel is 1-based; mono uses one channel).
set_send track, category, index, volume, pan, mute, mode, srcChannel, destChannel, outputChannel, mono
Change a send, receive or hardware output by its index (as get_track_routing reports it). Only the given fields change.
remove_send track, category, index
Remove a send, receive or hardware output by its index. Removing a receive removes the other track's send.
add_track name, index
Insert a new track (default: at the end). Returns its index, name and GUID.
delete_track track
Delete a track with its items, FX and routing (undoable with Ctrl+Z). The master track cannot be deleted. Later tracks move up one index.
move_track track, toIndex
Move a track to a new 0-based position; the other tracks shift around it. The user's track selection is kept.
set_track_folder track, mode, depth, collapsed
Make a track a folder parent, the last track of a folder, or a normal track; optionally collapse the folder. Folders nest by position: tracks after a folder parent belong to it until a track marked "last".
set_track_info track, name, color, channels, masterSend
Rename, color, set the channel count, or switch the master/parent send of a track. Everything is validated before anything is written.
set_track_group track, group, roles, enable
Put a track in (or take it out of) a REAPER track group with given roles. Roles: volume_lead/follow, vca_lead/follow, pan_lead/follow, mute_lead/follow, solo_lead/follow, recarm_lead/follow, polarity_lead/follow, automode_lead/follow. A VCA: one track vca_lead, the others vca_follow.
read_track_lufs trackIndex, targetLufs
Read ITU-R BS.1770 loudness data for a track. Auto-inserts the MCP LUFS Meter JSFX if not present. Returns integrated, short-term (3s), and momentary (400ms) LUFS plus true inter-sample peak levels. Audio must be playing to accumulate data. The meter sits in the track FX chain, so it reads pre-fader: add the track volume (dB) for its level in the mix. Compare tracks in LU against the mix bus over the same section.
read_track_correlation trackIndex
Read stereo field correlation and M/S analysis for a track. Auto-inserts the MCP Correlation Meter JSFX if not present. Returns correlation coefficient (-1 to +1), stereo width, and mid/side levels. Audio must be playing to accumulate data.
read_track_crest trackIndex
Read crest factor (peak-to-RMS ratio) for a track. Auto-inserts the MCP Crest Factor Meter JSFX if not present. Returns crest factor in dB (higher = more dynamic, lower = over-compressed), peak hold level, and RMS level. Audio must be playing to accumulate data.
measure_tracks trackIndices, metrics, durationSeconds, startPosition, fftSize, stopWhenDone, targetLufs, keepMeters
Play audio and collect analysis measurements (LUFS, crest factor, correlation, spectrum) for one or more tracks in a single call. Handles playback start/stop automatically. LUFS and spectrum (1/3-octave bands) support multi-track; crest/correlation use global gmem and are only reliable for single-track measurement. First call may be slower due to JSFX meter auto-insertion. Readings are pre-fader (meters sit in each track FX chain): add each track volume to compare tracks; a folder/bus reads its children post-fader. Use this to balance tracks in LU and compare spectra on `kDb`. Afterwards it removes the MCP meters on the measured tracks (also ones an earlier call left) unless keepMeters. A meter that received no audio (muted, frozen or silent track, nothing in range) is reported under errors, not as numbers. For whole-song, folder or master numbers without playback, prefer analyze_track_offline.
create_midi_item trackIndex, startPosition, endPosition
Create an empty MIDI item on a track at a given time range (seconds). Use this before inserting notes.
list_midi_items trackIndex
List all MIDI items on a track with position, length, and note/CC counts. ccCount counts CC messages only; channelEventCount and channelEventCounts include pitch bend, program change and pressure events
get_midi_notes trackIndex, itemIndex, offset, limit
Get MIDI notes in a MIDI item. Supports pagination with offset/limit for large items. For a high-level overview of a large MIDI item, use analyze_midi instead. Returns pitch (0-127, 60=C4), velocity (0-127), position and duration in beats from item start.
analyze_midi trackIndex, itemIndex
Analyze a MIDI item and return summary statistics computed in REAPER. Much more efficient than get_midi_notes for large items. Returns per-pitch stats (count, velocity min/max/avg/stddev), velocity histogram, and machine gun detection (consecutive identical velocities). Use this first to understand the MIDI data before reading individual notes.
insert_midi_note trackIndex, itemIndex, pitch, velocity, startPosition, duration, channel
Insert a single MIDI note. Pitch: 0-127 (60=C4/Middle C, 48=C3, 72=C5). Velocity: 1-127 (64=medium, 100=strong, 127=max). Position/duration in beats from item start (1.0=quarter, 0.5=eighth, 0.25=sixteenth).
insert_midi_notes trackIndex, itemIndex, notes
Batch insert multiple MIDI notes in a single call. Pass a native array of note objects. Each note: { pitch, velocity, startPosition, duration, channel? }. Positions/durations in beats from item start (1.0=quarter, 0.5=eighth).
edit_midi_note trackIndex, itemIndex, noteIndex, pitch, velocity, startPosition, duration, channel
Edit an existing MIDI note by index. Only provided fields are changed. Positions/durations in beats from item start.
edit_midi_notes trackIndex, itemIndex, edits
Batch edit multiple MIDI notes in a single call. Much more efficient than calling edit_midi_note repeatedly. Pass a native array of edit objects, each with noteIndex and any fields to change (pitch, velocity, startPosition, duration, channel). Only provided fields are changed.
delete_midi_note trackIndex, itemIndex, noteIndex
Delete a MIDI note by index from a MIDI item
get_midi_cc trackIndex, itemIndex, ccNumber
Get CC (continuous controller) events from a MIDI item. Optionally filter by CC number (e.g. 1=modulation, 7=volume, 10=pan, 11=expression, 64=sustain).
insert_midi_cc trackIndex, itemIndex, ccNumber, value, position, channel
Insert a CC (continuous controller) event. Common CC numbers: 1=modulation, 7=volume, 10=pan, 11=expression, 64=sustain, 74=filter cutoff.
delete_midi_cc trackIndex, itemIndex, ccIndex
Delete a CC event from a MIDI item by the ccIndex get_midi_cc returned. ccIndex counts every channel event (pitch bend, program change and pressure too), so CC indexes can skip numbers; only pass an index get_midi_cc listed
get_midi_item_properties trackIndex, itemIndex
Get detailed properties of a MIDI item including position, length, note count, CC count (CC messages only), channel-event counts by type, mute state, and loop setting
set_midi_item_properties trackIndex, itemIndex, position, length, mute, loopSource
Set MIDI item properties: position (seconds), length (seconds), mute, loop source
send_midi_cc trackIndex, cc, value, channel
Send a MIDI CC (continuous controller) event in real-time to a track's MIDI output. Auto-inserts the MCP MIDI Emitter JSFX if not present. Common CC numbers: 1=modulation, 7=volume, 10=pan, 11=expression, 64=sustain, 74=filter cutoff.
send_midi_pc trackIndex, program, channel, bankMsb, bankLsb
Send a MIDI program change in real-time, optionally preceded by bank select (CC0 MSB + CC32 LSB). Auto-inserts the MCP MIDI Emitter JSFX if not present.
send_midi_note trackIndex, pitch, velocity, channel, durationMs
Send a MIDI note-on in real-time to a track's MIDI output. If durationMs is provided, a note-off is automatically scheduled after that many milliseconds. Auto-inserts the MCP MIDI Emitter JSFX if not present.
list_media_items trackIndex
List all media items on a track with position, length, name, volume, mute state, and whether it is MIDI or audio
get_media_item_properties trackIndex, itemIndex
Get detailed properties of a media item: position, length, volume, fades, play rate, take info, source file
set_media_item_properties trackIndex, itemIndex, position, length, volume, mute, fadeInLength, fadeOutLength, playRate
Set media item properties: position (seconds), length (seconds), volume (dB), mute, fade in/out lengths, play rate
set_media_items_properties items
Batch set properties on multiple media items in a single call. Much more efficient than calling set_media_item_properties repeatedly. Pass a native array of item objects, each with trackIndex, itemIndex, and any properties to change.
split_media_item trackIndex, itemIndex, position
Split a media item at a given position (absolute project time in seconds). Returns info about both resulting items.
delete_media_item trackIndex, itemIndex
Delete a media item from a track
move_media_item trackIndex, itemIndex, newPosition, newTrackIndex
Move a media item to a new position and/or a different track
trim_media_item trackIndex, itemIndex, trimStart, trimEnd
Trim a media item edges. Positive trimStart trims from the beginning (makes item shorter/later). Positive trimEnd trims from the end (makes item shorter). Negative values extend.
add_stretch_marker trackIndex, itemIndex, position, sourcePosition
Add a stretch marker to a media item for time-stretching audio. Position is within the item (seconds from item start). Source position is the corresponding position in the original audio.
get_stretch_markers trackIndex, itemIndex
List all stretch markers in a media item with their positions and source positions
delete_stretch_marker trackIndex, itemIndex, markerIndex
Delete a stretch marker by index from a media item
get_selected_tracks
Get all currently selected tracks in REAPER with their indices and names; a selected master track is listed first as index -1
get_time_selection
Get the current time selection (loop selection) start and end in seconds
set_time_selection start, end
Set the time selection (loop selection) to a start and end position in seconds
set_selected_tracks tracks, mode
Select tracks by 0-based index, exact name, or "{GUID}" — usually before run_action, since most actions act on the selection. Every track is resolved first: an unknown or ambiguous one changes nothing. Returns the selection afterwards.
get_selected_items offset, limit
Get the media items selected right now, as {trackIndex, itemIndex} (the indexes list_media_items and the item tools use) with the track name, position and length in seconds, and mute. Use it when the user says "the selected items", instead of guessing which tracks they mean. Paged: returns {total, hasMore, items}; pass offset to read on.
set_selected_items items, mode
Select media items by track and item index (as list_media_items reports them) — usually before run_action. Every item is resolved first: a missing one changes nothing. Returns the selection afterwards.
get_record_setup all
Recording setup: the global record mode (normal, time_selection auto-punch, selected_items auto-punch) with the punch range, the record path, every armed track (or every track with all) with its input ("In 3/4", "MIDI: all inputs"), monitoring, record mode and input FX count, and the audio and MIDI inputs that exist. Read this before arming or recording.
set_track_record tracks
Arm tracks and set their record input, monitoring (off, on, auto = tape style), record mode and monitor-items, for up to 64 tracks in one undo point. Every track and input is checked first (an input the audio device does not have, an unknown MIDI device): a refused call changes nothing. Returns each track's record state and warnings (a MIDI mode on an audio input, an armed track with no input). Modes: input (default), midi_overdub/midi_replace for MIDI, stereo_out/mono_out to print the track output.
set_record_mode mode, punchStart, punchEnd, recordPath
Set the global record mode: normal, time_selection (auto-punch: records only inside the time selection; give punchStart/punchEnd to set it) or selected_items (auto-punch on the selected items). Optionally the record path (a folder relative to the project, or absolute). All input is checked first; one undo point.
get_track_lanes track
A track's fixed lanes (REAPER 7): whether they are on, each lane's name, whether it plays (exclusive, layered or off) and its items (index, position, length, take name; 100 per lane, then itemsMore). Use before comp_lanes to see which take is on which lane.
set_track_lanes track, fixedLanes, laneCount, names, play
Fixed lanes on a track: turn them on/off, set the lane count, name lanes and choose what plays — one lane alone (play: 2) or several layered (play: [0, 2]). Turning fixed lanes off puts every lane's items on one lane, all playing (the answer warns; undo_project brings the lanes back). A lane count below a lane that has items is refused; every refusal changes nothing. One undo point. REAPER can drop the names of lanes with no items, so name lanes once the takes are on them.
comp_lanes track, ranges, crossfadeMs, name
Comp takes from fixed lanes: give time ranges and the lane to take each from ({ start, end, lane }, seconds, no overlaps); copies of those parts go onto a new lane ("Comp" by default) with crossfades where one range meets the next, and that lane plays alone. The source lanes stay untouched (silent), so another comp or set_track_lanes play can switch back. A range a lane has no audio for is refused with the gap; every refusal changes nothing. One undo point.
list_markers
List all project markers with index, name, position, and color
list_regions
List all project regions with index, name, start/end positions, and color
add_marker position, name, color
Add a project marker at a position in seconds, with optional name and color
add_region start, end, name, color
Add a project region with start/end in seconds, optional name and color
delete_marker markerIndex
Delete a project marker by its marker index number
delete_region regionIndex
Delete a project region by its region index number
edit_marker markerIndex, name, position, color
Rename, move or recolor an existing marker by its marker index number (from list_markers). Unspecified fields keep their values; name "" clears the name. Color is a native color int, stored with REAPER's 0x1000000 "custom color" flag. Unknown markers change nothing.
edit_region regionIndex, name, start, end, color
Rename, move/resize or recolor an existing region by its region index number (from list_regions). Unspecified fields keep their values; end must stay after start. Unknown regions change nothing.
get_tempo_map
Get all tempo and time signature change points in the project (tempo map markers)
add_tempo_marker position, bpm, timeSigNumerator, timeSigDenominator, linear
Add a tempo / time signature marker at a position in seconds. Returns the updated tempo map (same shape as get_tempo_map, plus tempoMarkerCount). One undo point.
edit_tempo_marker index, position, bpm, timeSigNumerator, timeSigDenominator, linear
Edit a tempo marker by its get_tempo_map index (only tempoMarkerCount > 0 maps have real markers). Unspecified fields keep their values. Returns the updated tempo map.
delete_tempo_marker index
Delete a tempo marker by its get_tempo_map index. Returns the updated tempo map.
set_project_tempo bpm
Set the tempo at the project start. With no tempo markers this sets the project BPM; with a marker at 0 it edits that marker; when the first marker is later, it adds a marker at 0 (later markers keep their BPM and their indexes shift by one). Returns the updated tempo map.
get_track_envelopes trackIndex
List all automation envelopes on a track (volume, pan, mute, FX params, sends, etc.) with point and automation item counts. Send envelopes (all named "Send Volume", "Send Pan", ...) carry `send`: the send index and destination track.
get_envelope_points trackIndex, envelopeIndex, automationItemIndex, offset, limit
Get automation points for a track envelope (or one automation item) with pagination. Returns time, raw value, shape, tension per point, plus `db` on volume envelopes.
insert_envelope_point trackIndex, envelopeIndex, automationItemIndex, time, value, db, shape, tension
Insert an automation point on a track envelope (or inside an automation item) at a time in seconds. Give `db` on volume envelopes (Volume, Trim Volume, Send Volume): it is converted with the envelope's own scaling (fader-scaled volume envelopes store 716.2 for 0 dB, not 1.0). `value` is the raw envelope value (pan -1..1, mute 0/1, FX parameter 0..1).
insert_envelope_points trackIndex, envelopeIndex, automationItemIndex, points
Batch insert automation points on a track envelope (or inside an automation item). Much faster than repeated insert_envelope_point calls. Give `db` on volume envelopes (Volume, Trim Volume, Send Volume): it is converted with the envelope's own scaling (fader-scaled volume envelopes store 716.2 for 0 dB, not 1.0). `value` is the raw envelope value (pan -1..1, mute 0/1, FX parameter 0..1).
edit_envelope_points trackIndex, envelopeIndex, automationItemIndex, points
Edit existing automation points by index (from get_envelope_points): move them, change their level, shape or tension. Fields left out keep their value; all edits are validated before any is written. Give `db` on volume envelopes (Volume, Trim Volume, Send Volume): it is converted with the envelope's own scaling (fader-scaled volume envelopes store 716.2 for 0 dB, not 1.0). `value` is the raw envelope value (pan -1..1, mute 0/1, FX parameter 0..1).
delete_envelope_point trackIndex, envelopeIndex, automationItemIndex, pointIndex
Delete one automation point by its index (from get_envelope_points); returns the deleted point
create_track_envelope trackIndex, envelopeName, sendIndex, fxIndex, paramIndex
Create/show an automation envelope on a track. Use envelopeName for built-in envelopes (Volume, Pan, Mute, Width, Trim Volume), sendIndex + envelopeName (Volume, Pan, Mute) for a send's envelope (it appears on the track as "Send Volume" etc. and starts at the send's current value), or fxIndex+paramIndex for FX parameter envelopes. The envelope is made visible and active; an existing one is only shown (`created: false`). The track selection is left as it was.
set_envelope_properties trackIndex, envelopeIndex, active, visible, armed
Set properties (active, visible, armed) on a track envelope. Requires SWS extension for full support.
clear_envelope trackIndex, envelopeIndex, automationItemIndex
Delete ALL automation points from an envelope (or from one automation item's pool), resetting it to its default state
remove_envelope_points trackIndex, envelopeIndex, automationItemIndex, timeStart, timeEnd
Delete automation points in a time range from a track envelope (or automation item). Use to surgically remove a section of automation.
list_automation_items trackIndex, envelopeIndex
List the automation items on an envelope: index, poolId, pool name, position, length, loop, baseline/amplitude and point count. Items with the same poolId share their points.
insert_automation_item trackIndex, envelopeIndex, position, length, poolId, points, captureEnvelope, startOffset, playRate, baseline, amplitude, loop, name
Insert an automation item on an envelope. Without poolId it starts a new pool, filled from `points` (times in seconds from the item start); with the poolId of an existing item (on any track) it adds a pooled instance with the same points, so editing one edits all; pooledWith counts the other instances in the project (use this for repeated sections such as every chorus). captureEnvelope moves the underlying envelope points in the range into the new item instead. Automation items override the underlying envelope where they sit.
set_automation_item trackIndex, envelopeIndex, automationItemIndex, position, length, startOffset, playRate, baseline, amplitude, loop, name
Move, resize or change an automation item: position, length, start offset, play rate, baseline, amplitude, loop, pool name. Points are edited with edit_envelope_points and automationItemIndex.
delete_automation_item trackIndex, envelopeIndex, automationItemIndex, preservePoints
Delete one automation item. Its pool lives on while other instances use it. preservePoints keeps its points on the underlying envelope. Other selections are left as they were.
set_multiple_track_properties tracks
Batch set properties (volume, pan, mute, solo, recordArm, phase, input) on multiple tracks in a single call. Much more efficient than calling set_track_property repeatedly. Pass an array of track update objects, each with trackIndex and any properties to change.
setup_fx_chain trackIndex, plugins
Add multiple FX plugins to a track with optional initial parameter values in a single call. Returns the FX chain indices of added plugins. More efficient than calling add_fx and set_fx_parameter repeatedly.
set_multiple_fx_parameters updates
Batch set parameters across multiple FX plugins, potentially on different tracks, in a single call. Much faster than repeated set_fx_parameter calls. Pass an array of update objects with trackIndex, fxIndex, paramIndex, and value.
run_plan ops, dryRun, idempotencyKey, snapshotBefore, label
Execute a multi-step edit as ONE bridge call in ONE undo block, all-or-nothing. Use instead of many sequential tool calls. Ops run in order: add_track, set_track, add_fx, set_fx_params, add_send, graft_fxchain (copy a source FX chain onto a track; sends are not copied), select_tracks, copy_items / insert_time / remove_time (as the arrange tools), and run_action (any REAPER action — usually after select_tracks; same safety rules as run_action; only run_action ops may follow a run_action). Target tracks by index, exact name, "{GUID}", or a "$ref" that an earlier add_track/add_fx bound with `as`. Every target is resolved before anything is written: an unknown or ambiguous track rejects the whole plan, and a failure mid-apply reverts it. Use dryRun to preview resolution and conflicts. Pass an idempotencyKey so a retried call is not applied twice.
search_actions query, section, limit
Search REAPER's action list (native, SWS/extensions, scripts, and the user's Custom: macros — ~6k actions) inside REAPER. Every query word must appear in the action name or named id (case-insensitive). Returns id, stable namedId, name, toggle state, keyboard shortcuts, and whether it opens a dialog or is always refused, plus the total match count.
get_action action, section
Get one REAPER action: name, ids, toggle state, shortcuts, and its kind. For a Custom: macro, lists the steps it runs by name; for a script, its file path.
run_action action, section, allowDialog
Run one REAPER action (like pressing its shortcut) in an undo block, and return its toggle state afterwards. Most actions work on the current selection: set it first with set_selected_tracks / set_selected_items. Actions that open a dialog (name ends in "...") are refused unless allowDialog is true, because a dialog blocks REAPER until a person closes it. Actions that quit REAPER, close/open/replace the project, or open, close or switch project tabs are always refused. A Custom: macro is refused if any step it runs would be. To combine actions with other edits in one undo step, use run_plan's run_action op.
insert_audio_file trackIndex, filePath, position
Insert an audio file (WAV, AIFF, FLAC, MP3, …) onto a track as a new item at a position. The item is as long as the file. Refused, with nothing changed, when the file does not exist or REAPER cannot read it as audio.
list_takes trackIndex, itemIndex
List the takes of a media item: name, which one is active, MIDI or audio, source file, and take FX count
set_active_take trackIndex, itemIndex, takeIndex
Make one take of a media item the active (playing) take. Returns the item's takes afterwards.
get_take_fx trackIndex, itemIndex, takeIndex, fxIndex, offset, limit
List the FX on a take (its own FX chain, separate from the track FX). With fxIndex, also lists that FX's parameters with values and formatted text (paginate large plugins with offset/limit; the result has paramTotal and hasMore).
add_take_fx trackIndex, itemIndex, takeIndex, fxName
Add an FX to a take's FX chain by name (partial match, like add_fx). Returns the take's FX chain afterwards.
remove_take_fx trackIndex, itemIndex, takeIndex, fxIndex
Remove one FX from a take's FX chain. Returns the take's FX chain afterwards.
set_take_fx_parameter trackIndex, itemIndex, takeIndex, fxIndex, paramIndex, value
Set one parameter of a take FX (same value scale as set_fx_parameter) and return the value REAPER reads back
get_item_appearance trackIndex, itemIndex
Get a media item's color ("#RRGGBB" or "none") and fades: lengths (seconds), shapes (0-6) and curves (-1..1)
set_item_color trackIndex, itemIndex, color
Set a media item's color, or "none" to go back to the track's default. Returns the color and fades REAPER reads back.
set_item_fades trackIndex, itemIndex, fadeInLength, fadeOutLength, fadeInShape, fadeOutShape, fadeInCurve, fadeOutCurve
Set a media item's fade-in/out lengths, shapes and curves; only the fields given change. Shapes: 0 linear, 1 fast start, 2 fast end, 3 fast start (steep), 4 fast end (steep), 5 slow start/end, 6 slow start/end (steep). Returns the color and fades REAPER reads back.
copy_media_items items, times, position, trackIndex, pooled
Copy (duplicate or repeat) media items, keeping their spacing: by default right after the last one, or at `position` and/or on another track. `times` lays copies end to end (e.g. repeat a 4-bar loop 8 times). Copies get fresh GUIDs; MIDI copies get their own data unless `pooled`. One undo point; returns where each copy landed.
insert_time position, length, splitItems
Open empty time at a position across the whole project: every item, marker, region, tempo marker, envelope point and automation item at or after it moves later by `length`; items spanning it are split (unless splitItems: false) and regions spanning it grow. An automation item spanning the position stays where it is (counted in automationItemsSpanning). Independent of REAPER's ripple settings. One undo point; returns what moved.
remove_time start, end
Cut a time range out of the whole project and close the gap: items, markers, tempo markers, envelope points and automation items inside it are deleted, items and automation items crossing an edge lose the part inside it (an automation item spanning the whole cut stays, counted as automationItemsKept), regions shrink, and everything after moves earlier. The tempo in force at the end of the cut is kept. One undo point; returns what was deleted, trimmed and moved.
copy_section regionIndex, start, end, position, insert, envelopes, tracks
Copy a section of the song (a region by list_regions index, or start/end) to another position: the items in it (trimmed to the section) and, by default, its automation (envelope points, plus a pooled copy of each automation item wholly inside the section; items crossing an edge are counted in automationItemsCrossing, not copied), on every track or the given tracks. With `insert`, time is opened at the position first, across the whole project like insert_time, so nothing there is overwritten (e.g. repeat a chorus). One undo point.
process_items operation, items, mode, target
Process audio items: `normalize` sets item gain so each item hits `target` dB (mode peak by default, or true_peak, lufs_i, rms, lufs_m_max, lufs_s_max; non-peak modes need a target), measured over what the item plays; `reverse` toggles each active take's direction (a take already reversed plays forward again); `glue` joins the whole items on each track into one new item, whatever the time selection. MIDI items are refused for normalize/reverse. The selection is kept. One undo point; normalize returns each item's level and gain before and after.
move_fx trackIndex, fxIndex, toTrackIndex, toIndex
Move one FX to another position in its chain, or to another track (with its settings). Returns the chain(s) afterwards.
copy_fx trackIndex, fxIndex, toTrackIndex, toIndex
Copy one FX (with its settings) to another position in its chain or onto another track. Returns the chain(s) afterwards.
rename_fx trackIndex, fxIndex, name
Rename one FX instance as shown in the FX chain (REAPER 6.37+). An empty name restores the plugin's own name.
save_fx_chain trackIndex, name, overwrite
Save a track's whole FX chain (with all settings) as an .RfxChain file in REAPER's FXChains folder, where REAPER's own "Add FX chain" finds it. The name may include subfolders ("Vocals/Lead") but never "..", an absolute path or a drive letter.
load_fx_chain trackIndex, name, mode
Load an .RfxChain file onto a track: appended after its FX (default) or replacing them. Each loaded FX gets a fresh identity. See list_fx_chains for names.
list_fx_chains
List the .RfxChain files in REAPER's FXChains folder (and subfolders), by the name load_fx_chain takes
save_track_template trackIndex, name, includeItems, overwrite
Save a track (name, FX chain, settings) as an .RTrackTemplate in REAPER's TrackTemplates folder. Items are left out unless includeItems is true; receives and folder state are never saved (they depend on the tracks around it). The name may include subfolders but never "..", an absolute path or a drive letter.
insert_track_template name, index
Insert the track(s) from an .RTrackTemplate at a position, each with fresh identities. See list_track_templates for names.
list_track_templates
List the .RTrackTemplate files in REAPER's TrackTemplates folder (and subfolders), by the name insert_track_template takes
list_tool_categories
List all available tool categories with descriptions and tool names. Use this to discover what tools are available without loading every tool schema. Categories: project, tracks, fx, transport, midi, media, arrange, selection, recording, markers, tempo, envelopes, analysis, discovery, snapshots, routing, plan, actions, takes, fx_files, knowledge, plugin_authoring.
enable_tool_category category
Signal that you intend to use tools from a specific category. All tools are already registered and available — this call returns the full list of tools in the category so you know exactly which tool names to use. Use list_tool_categories first to see all available categories.
disable_tool_category category
Signal that you are done using tools from a specific category. This is a semantic hint to help manage your context budget — the tools remain registered but you can use this to indicate you no longer need them in the current workflow.
analyze_track_aesthetics trackIndex, startTime, endTime, durationSeconds, normalizeLufs
Analyze the perceptual aesthetic quality of a track's audio using Meta's Audiobox Aesthetics model (CC-BY 4.0). Bounces the track to a temp WAV file (post-FX, post-fader) and runs 4-axis perceptual quality scoring: Production Quality (PQ), Production Complexity (PC), Content Enjoyment (CE), Content Usefulness (CU). Returns scores 0-10. The clip is normalized to normalizeLufs (default -18 LUFS) before scoring, so level differences between versions do not bias the scores (CE rises with level; PQ barely moves). PQ (and partly CU) judge mix changes; PC and CE mostly follow the arrangement, so only compare the same time range. Measured noise: re-rendering the same 30 s clip moves PQ by ~0.05, a 10 s clip by ~0.4; treat smaller differences as no change. Requires the Python sidecar (run in a terminal: reaper-mcp setup-sidecar).
analyze_track_offline trackIndex, startTime, endTime, durationSeconds, sectionSeconds, referencePath, referenceStartTime, referenceEndTime
Render a track (or the master, -1) once and analyze it offline — no playback needed, works on folder tracks. Returns integrated LUFS (BS.1770 gated), loudness range (LRA), true peak (dBTP), sample peak, crest factor, per-section loudness, band balance (sub..brilliance as share of energy), resonance hints (narrow peaks above the local spectrum) and sibilance hints (5-10 kHz spikes with times). With referencePath, also the loudness difference and tonal-balance difference (bands and third octaves, level offset removed) against that file. Use this for whole-song and mastering numbers (up to 900 s). Requires the Python sidecar.
analyze_audio_file path, startTime, endTime, sectionSeconds, referencePath, referenceStartTime, referenceEndTime
Analyze an audio file on disk (a reference track, a bounce, a stem) the same way as analyze_track_offline: integrated LUFS, LRA, true peak, crest, per-section loudness, band balance, resonance and sibilance hints, and an optional comparison against another file. Does not touch REAPER. Requires the Python sidecar.
measure_track_alignment referenceTrack, trackIndex, startTime, durationSeconds, maxLagMs
Measure the time offset and polarity of one track against a reference track (e.g. snare bottom vs snare top, kick sub vs kick in, overheads vs snare) by rendering both over the same range and cross-correlating them. A positive delayMs means the track arrives later than the reference, as both play now (the current playback offset and polarity are included). To align it, set_track_property playOffsetMs = suggestedPlayOffsetMs and phase = suggestedPhase (1 = inverted) on that track — absolute values that already account for the current settings, so re-measuring an aligned track suggests what it already has. Renders are post-FX (plugin latency is compensated). Pick a range where both tracks play the same hits; below correlation 0.3 no suggestion is made. Requires the Python sidecar.
verify_edit trackIndex, referenceTrack, referencePath, startTime, durationSeconds, expect, timeScale, maxLagMs
Check the result of an edit you just made, since you cannot hear it: compare the edited track with the audio from before the edit and get a verdict per check. Both sides are rendered (after track FX, pan and fader), so FX and fader edits show. Compensated null: the delay (ms, + = later), gain (dB) and polarity between the two are estimated and removed, and the residual left (dB below the reference) says whether anything else changed (noise, a splice, a different waveform, a swapped stereo channel; it is relative to referenceRmsDb, so with a quiet reference the rounding noise of a 16-bit bounce can set it). Discontinuity: the largest sample-to-sample jump on any channel against the reference's own, with where it happens and which channel (a click or hard splice). Use expect 'identical' (default) for edits that should leave the sound alone apart from level, delay and polarity (alignment, gain, split, crossfade): the residual is judged ok/warn/fail. Use "changed" for EQ, compression and the like: the residual is reported without a verdict. Set timeScale to the playback rate when the edit changed the timing (1.1 = the edit is 10% shorter): the waveform null is then skipped and the click check runs with three warn-only character checks against the reference warped through that rate: pitch drift in cents (skipped for unpitched material), tone (long-term spectrum distance in dB, line 1.5 dB, provisional) and transients (smeared attacks). When the pitch moved by what the speed change alone causes (a plain speed change, pitch follows speed), pitch and tone are reported as info, not warned; a pitch move the speed does not explain still warns. Slow-downs below 0.9 also get a dropout check (the deepest dip of the edited loudness under the original, warn from 12 dB, provisional): bigger slow-downs stretch audible artifacts into a vocal that the other checks do not hear, so listen to those either way. The reference is another track (e.g. a copy you kept) or an audio file of the same range from before the edit (a bounce), not an undo. Keep a reference track unmuted so it renders. The tone check misses a phase vocoder's smearing and the transient check is blind on drums. A passing result is evidence, not a replacement for listening. Requires the Python sidecar.
detect_transients trackIndex, path, filePosition, startTime, endTime, band, sensitivity, minGapMs, minStrength, bands, sectionSeconds, offset, limit
Find the transients (hits/onsets) in a track (read from its own items, before track FX and pan, without a render; the master is rendered) or an audio file on disk: each hit's time in project seconds, strength (0..1, relative to the loudest hits), dominant band (low = kick/bass, mid = snare/vocals/keys, high = hats/cymbals) and peakDb, plus a tempo estimate, hit counts per band and, with sectionSeconds, how busy each part is. Hits are paginated (offset/limit). Use it to sync lighting, video cuts, markers or MIDI to a song; create_transient_automation writes the hits as envelope pulses directly. A file is read as-is (no stretch markers or play rate): for an item warped to the grid, pass its track instead. Requires the Python sidecar.
create_transient_automation trackIndex, path, filePosition, startTime, endTime, band, sensitivity, minGapMs, minStrength, bands, targetTrack, envelopeIndex, baseValue, peakValue, scaleByStrength, attackMs, holdMs, decayMs, decayCurve, replaceExisting, dryRun
Detect the transients of a track (its own audio, before FX and pan) or audio file (same options as detect_transients) and write one pulse per hit onto an existing envelope of a target track — e.g. a lighting/DMX plugin parameter that should flash on every kick. Each pulse rises from baseValue to the hit level (peakValue, scaled by strength unless scaleByStrength is false) over attackMs, holds holdMs, and falls back over decayMs; a hit before the previous pulse has ended cuts it short. Values are raw envelope values (FX parameters 0..1, Pan -1..1). Create the envelope first with create_track_envelope (it returns envelopeIndex). By default the envelope's points in the range are replaced (replaceExisting). dryRun returns the points without writing. Use bands/minStrength/minGapMs to choose what the lights follow (e.g. bands ["low"], minStrength 0.6 for the kick accents). Requires the Python sidecar.
analyze_loudness_curve trackIndex, path, startTime, endTime, targetLufs, toleranceLu
Loudness over time of a track (or the master, -1) or an audio file: short-term (3 s) and momentary (400 ms) LUFS as curves (at most 240 points each, every point the loudest moment of its slice), integrated LUFS, true peak, LRA, PLR (true peak minus integrated), the loudest and quietest 3 s windows, and with targetLufs the spans whose short-term loudness goes over target + toleranceLu. Use it to see where a master gets too loud or a section drops away, before and after a change. Rendered once, no playback. Requires the Python sidecar.
analyze_stereo_bands trackIndex, path, startTime, endTime
Stereo correlation per frequency band (low <120 Hz, lowMid 120-500 Hz, mid 0.5-2 kHz, high 2-8 kHz, air >8 kHz) of a track, the master (-1) or a stereo file: overall and worst correlation (+1 mono, 0 wide, below 0 cancels in mono), the share of time out of phase, side-to-mid level (dB, width), a short correlation series per band, and flags for a wide or out-of-phase low end or any band that cancels in mono. Rendered once, no playback. Requires the Python sidecar.
measure_masking tracks, startTime, durationSeconds
Find where 2-8 tracks compete for the same frequencies: renders each track over the same range (post-FX) and compares their K-weighted third-octave levels (40 Hz-16 kHz). A band scores high when both tracks are loud there and within a few dB of each other. Returns every pair's overall score with its worst bands, and the top conflicts (score >= 0.2) with a suggestion: which track to cut around which frequency (the one the band matters less to). Pick a section where they all play (max 60 s). Requires the Python sidecar.
separate_stems trackIndex, path, startTime, endTime, model, stems, outDir, insertTracks, filePosition
Split a track (rendered post-FX, -1 = master) or an audio file into stems with Demucs: htdemucs gives drums, bass, other, vocals; htdemucs_6s adds guitar and piano. Writes one 32-bit float WAV per stem to outDir (default: a new folder under the project's Stems folder) and returns each stem's path, LUFS and peak. With insertTracks, adds them as tracks under a new folder in one undo point, lined up with the source (a track: after it, at startTime; a file: at filePosition + startTime); the folder starts muted, since the stems sum back to the source. Slow: about real time on a CPU, several times faster on Apple silicon or CUDA (max 600 s per call). Needs `reaper-mcp setup-sidecar --with-separation` (which downloads htdemucs; the first htdemucs_6s call downloads its ~80 MB weights).
set_automation_mode tracks, mode, globalOverride
Set the automation mode of tracks (trim/read, read, touch, write, latch, latch_preview) and/or REAPER's global automation override ("none" clears it, "bypass" turns all automation off). Returns each track's mode before and after. Write/latch/touch record fader moves while playing.
get_fx_param_modulation trackIndex, fxIndex, paramIndex
Read FX parameter modulation (REAPER 6.37+): LFO, audio control signal (sidechain follower) and parameter link, with the baseline. Without paramIndex, lists only the modulated parameters of the FX.
set_fx_param_modulation trackIndex, fxIndex, paramIndex, enabled, baseline, lfo, audio, link
Modulate an FX parameter (REAPER 6.37+): an LFO, an audio control signal (the parameter follows a channel's level, e.g. a sidechain on 3/4), and/or a link to another FX parameter on the same track. Only the fields given change; enabled:false turns all modulation of the parameter off. One undo point; the state before is returned.
get_fx_pins trackIndex, fxIndex
Read an FX's pin mappings: each input and output pin and the track channels (1-based) it connects to, plus the track's channel count. Pins 3/4 of a compressor are its sidechain input.
set_fx_pins trackIndex, fxIndex, inputs, outputs, trackChannels
Connect FX pins to track channels (1-based, up to 64). Give a channel list per pin ([[1],[2],[3],[4]]) or only the pins to change ([{pin: 2, channels: [3]}, {pin: 3, channels: [4]}] routes a sidechain on 3/4). The track is widened to the highest channel used; trackChannels sets it explicitly. All validated before any write; one undo point.
list_monitoring_fx
List the monitoring FX chain (on the master, heard only in your monitors, never rendered — room correction, a reference meter, a mono check). Global to REAPER, not saved in the project.
add_monitoring_fx fxName, params
Add an FX to the monitoring chain (heard in the monitors, never rendered), with optional normalized parameters.
set_monitoring_fx fxIndex, enabled, offline, params
Bypass, set offline, or set normalized parameters of a monitoring FX by index (from list_monitoring_fx).
remove_monitoring_fx fxIndex
Remove a monitoring FX by index (from list_monitoring_fx).
freeze_tracks tracks, mode
Freeze tracks: render them (pre-fader) to stereo, mono or multichannel and take their items and online FX out until unfrozen, to free CPU. Blocks REAPER while it renders (a few seconds per minute of audio). The track selection is put back. Not the master.
unfreeze_tracks tracks
Unfreeze tracks: restore the items and FX a freeze took out (one freeze layer per call). Refuses a track that is not frozen.
apply_fx_to_items items, mode
Render in place: apply the track and take FX to items as a new active take (stereo, mono or multichannel). The old take stays, so the render can be switched back with set_active_take. Blocks REAPER while it renders. The item selection is put back.
add_stretch_markers trackIndex, itemIndex, markers
Add many stretch markers to an audio item in one call and one undo point. position is seconds from the item start; sourcePosition (seconds in the source) pins the audio at that spot to the new position, which stretches the audio around it.
edit_stretch_markers trackIndex, itemIndex, edits
Edit existing stretch markers of an audio item in one call and one undo point: move a marker (position, seconds from the item start), change which source time it pins (sourcePosition) and its slope (-1..1, the curve of the stretch after it). Markers are named by index, in position order. position is in item seconds, as this tool and add_stretch_markers report them; get_stretch_markers lists raw take positions, which equal item seconds only at play rate 1 (divide by the play rate otherwise). Only the fields given change. Every edit is checked first: a marker moved out of order (position or source), onto another marker, outside the item, or a repeated index refuses the whole call and changes nothing.
quantize_audio trackIndex, itemIndex, grid, strength, window, swing, sensitivity, minGapMs, minStrength
Quantize an audio item to the grid with stretch markers: finds the hits in the item's source (sidecar), puts a marker on each and moves it toward the nearest grid line (strength, window and swing as quantize_midi). The item keeps its length (anchors at both ends); the item's existing stretch markers are replaced. Returns the timing offset before and after (avg/max ms). Requires the sidecar.
align_audio_to_guide guide, doubles, strength, maxShiftMs, protectConsonants, consonantMs, dryRun, sensitivity, minGapMs, minStrength
Align doubles (a second take, a harmony, a stack) to a guide item with stretch markers, the way VocalSync does: finds the hits (onsets) in the guide and in each double (sidecar), pairs them in order within maxShiftMs, and puts a stretch marker on each hit of the double so it lands on the guide's. Audio between hits is stretched; anchors at both ends keep each double's length. strength < 1 moves hits only part of the way. protectConsonants moves high-band hits (s, t, k, sh) as a block, so the stretch lands in the vowel after them instead of smearing the consonant. dryRun returns the planned moves and writes nothing. Each double's existing stretch markers are replaced; a guide that has stretch markers is refused (its hits would not sit where its source says). Returns, per double, the timing offset before and after (avg/max ms against the guide). Works on the items' source files (take FX are ignored). Requires the sidecar. Not pitch correction.
quantize_midi trackIndex, itemIndex, notes, pitchMin, pitchMax, channel, grid, strength, swing, window, lengths
Quantize the notes of a MIDI item to the project grid (beats, not the item start): grid in beats (1 = quarter, 0.5 = 8th, 0.25 = 16th, 1/3 = 8th triplet), strength 0..1 (partial moves keep feel), swing 0..0.9 (pushes every second grid line later), window 0..1 (only notes within that fraction of half the gap to the next line move; with swing the gaps are uneven, so the reach is (1 + swing) times half a step), lengths "keep" (default, notes move whole) or "quantize" (ends snap too). Acts on all notes or a selection (indexes, pitch range, channel). One undo point; a refused call changes nothing. Returns how many notes moved and the average and largest shift in beats.
transform_midi trackIndex, itemIndex, notes, pitchMin, pitchMax, channel, transpose, velocity, humanize, length
Transform the notes of a MIDI item in one undo point: transpose (semitones, refused if any note would leave 0-127), velocity (set, scale, add, then clamp to min/max), humanize (random timing in beats and velocity, reproducible with seed), length (set in beats, scale, or legato = each note runs to the next selected note on its channel). Acts on all notes or a selection (indexes, pitch range, channel). Returns how many notes it acted on, velocities before/after and the humanize seed.
import_midi_file path, trackIndex, newTracks, position
Import a Standard MIDI File (.mid/.midi, type 0 or 1, up to 5 MB and 20000 notes) as MIDI items, without REAPER's import dialog: notes and controllers of every file track merged into one item on trackIndex, or with newTracks each file track on a new track named after it, inserted at trackIndex. Placed at position (seconds) on the project grid; the file's tempo is reported, not applied (set it with set_project_tempo). Pitch bend, program changes, aftertouch and sysex are not imported; file.notImported counts them. One undo point.
detect_key trackIndex, path, itemIndex, source, startTime, endTime
Detect the musical key (e.g. "A minor") of a track or an audio file: from a track's MIDI notes (note time weighted by velocity, drums on channel 10 ignored) or, for audio, from its chroma (Python sidecar; a track is read from its own items, before FX and pan, without a render). Returns the key, confidence 0..1 (how far it stands out from the next candidate that is not its relative key, scaled down for a flat profile and by how well the key fits — its correlation), the relative key, the top 3 alternatives with their correlation, and the 12-bin chroma (C first). Use it before writing parts, choosing a pitch-correction scale or a harmonizer key.
detect_chords trackIndex, path, itemIndex, source, per, engine, startTime, endTime, bpm, beatsPerBar, windowSeconds, offset, limit
Detect the chords of a track, one media item or an audio file, one per bar (default) or beat: from MIDI notes (drums on channel 10 ignored; the lowest held note gives slash chords like C/E) or from audio (Python sidecar chroma; a track is read from its own items, before FX and pan). Track bars and beats follow the project tempo map; a file uses `bpm` (bar 1 at startTime) or fixed windows. Returns the key, the progression ("Am F C G"), and chord spans (equal neighbours merged): start/end seconds, bar.beat, chord, root, quality (maj, min, 7, maj7, m7, sus2, sus4, dim, aug; the model also dim7, m7b5, 6, m6, 9, maj9, m9, mMaj7, 5, 11, 13), roman numeral in the key, bassMidi (a MIDI note for a bass line, E1-D#2) and a 0..1 fit; "N" = no chord. Paginated (offset/limit). Audio uses the chord model (lv-chordia, slash chords and sevenths from a full mix) when installed (setup-sidecar --with-chords), else chroma templates; `engine` picks. Use it before writing a bass line or other parts to existing guitars, keys or vocals.
transcribe_voice_sketch path, startTime, endTime, mode, bpm, grid, pitchMin, pitchMax, minNoteMs, tempoChangeThreshold, arrange, bars, key, outputPath, soundfontPath, offset, limit
Compose an editable musical draft from humming, singing, beatboxing, or a mixture. Local Python sidecar, no model download. Returns stable rounded BPM, sustained tempo changes, tentative key, separate monophonic melody and GM drum notes, repeated 4/4 drum patterns, and original file times. Timing snaps to a shared grid (default sixteenths); pitches snap to semitones, NOT to a guessed key. By default arrange:true adds a proposed intro/verse/chorus/outro, a kick/snare/hat groove using detected kick positions and hat accents, chord accompaniment, bass locked to the kicks, and the repeated detected melody. Those backing parts and sections are GENERATED, not recovered from the recording. No true audio source separation. arrange:false exports only the detected melody/percussion. key overrides accompaniment only, never retunes the melody. Experimental: drum labels and octaves need review; speech is not removed. Use startTime/endTime to isolate music. No REAPER changes. outputPath writes the FULL score as a type-1 .mid with tempo map and GM instruments. With soundfontPath also renders a sampled mix and separate 32-bit WAV instrument stems into <outputPath without .mid>-stems/. This optional preview needs the FluidSynth shared library and a user-supplied GM .sf2; no audio device or REAPER needed. Then use import_midi_file(newTracks:true) and assign instruments. That importer skips GM programs and does NOT apply the file tempo: use set_project_tempo/add_tempo_marker separately, or REAPER native MIDI import. Summary-first: note arrays default to 100 events per part; limit:0 returns only summaries. Export is never paginated. At most 120 seconds input, 64 bars output, 240 seconds for previews. Requires setup-sidecar (core only is enough).
list_builtin_knowledge kind, tags, query, limit
List the built-in (read-only, curated) mix knowledge: plugin records and mixing lessons. Without query: summaries (key, tags, preview) — filter plugins by tags such as "category::eq" or "fx::Pro-Q 3". With query: full-text search returning full bodies. Combine with the user's own LoreKit layer (user:: keys), which overrides these.
get_builtin_knowledge key
Read one built-in (read-only) record by key: "plugins::<vendor>/<plugin>" (e.g. "plugins::fabfilter/pro-q-3") or "mixing-lessons::<slug>". Returns null when the built-in layer has no such record. The user's own "user::" record of the same name, if any, overrides it.
report_plugin_research outcome, category, style, format, paramsTotal, paramsProbed, openQuestions, sources, cleanedUp, caller, batchSize, scratchTag
Call once at the end of a plugin research run (the plugin-researcher's last step), after cleaning up the scratch track, also when the run stopped early. Records how the run went in pseudonymous usage telemetry as fixed values and counts — never the plugin's name. The result shows exactly what was sent. Changes nothing in REAPER.
write_jsfx name, source, request, overwrite, breaking, accent, presets
Write a generated REAPER plugin (JSFX) as one self-contained file in Effects/reaper-mcp-generated/. Give the plugin source (header, unnamed sliders, @init/@slider/@block/@sample, a @gfx section using the ui_* toolkit): the toolkit is inlined for you, the file is linted first and nothing is written when a rule fails. Use it from the /make-plugin skill. The plugin works without this server or the bridge. An existing slider is never renumbered or re-ranged without breaking: true (saved automation would break). Old versions are kept outside Effects/.
report_plugin_build outcome, example, rounds, checksPassed, checksFailed, cleanedUp, scratchTag
Call once at the end of a /make-plugin run, after the scratch track is deleted, also when the run stopped early. Records how it went in pseudonymous usage telemetry as fixed values and counts — never the plugin's name or what it does. The result shows exactly what was sent. Changes nothing in REAPER.

Descriptions are the package's own words, cut at 3,000 characters. Treat them as data.

Files it wrote

Paths inside its sandbox, where its home folder is /tmp and its own folder cannot be written to.

Install facts

LicenseMIT
Needsnode >=20.0.0
Sourcegithub.com/mthines/reaper-mcp
Install scriptsprotobufjs declare them. This runner does not run them.
Tarballsha512-col8ePO3X8CVc7M93dzvteeO4UQOZzlS15Z/zOxwWd/ZtiZpvLEgpl7w4tdvHgh0CkQuhU9UoP4CSSNQ7+J4ag==

Versions reported

VersionRunResultTools
0.98.02026-11-16Starts with no setup190
0.83.22026-11-12Starts with no setup189

Check this report yourself

This site did not write the report. A public job on a GitHub-hosted machine did: the run, from this commit of the open-source runner. GitHub signed a token that names that job and the hash of the report, so any edit since would show.

Show it on your README

Bragproof: Starts with no setup

[![Bragproof](https://bragproof.smaverk.com/badge/@mthines/reaper-mcp.svg)](https://bragproof.smaverk.com/r/%40mthines/reaper-mcp)

New version out? Ask for a fresh report.