Audio

audio

_High-level audio manipulations: loading, playback, analysis and editing. 140+ plugins: denoise, dynamics, EQ, filters, effects, reverb, time and pitch, spatial, synthesis, music analysis._

• Any Format — fast wasm codecs, no ffmpeg.
• Non-destructive — virtual edits, infinite undo, instant clone.
• Stream-first — playback/encode during decode, realtime editing.
• Paged — no 2Gb memory limit, open 10Gb+ files.
• Analysis — loudness, spectrum, beats, pitch, chords, key.
• Modular – pluggable ops, tree-shakable.
• CLI — playback, batch processing, scripting, unix pipes, tab completion.
• Cross-platform — browsers, node, deno, bun.

Start Recipes API CLI FAQ Plugins Architecture Comparison RX 12

Start

Node

npm i audio

import audio from 'audio'

let song = audio('song.mp3') song.play() // the speakers, as a page plays it: no ffmpeg, no player to spawn song.pause(); song.seek(60); song.resume()

let voice = audio('voice.wav').trim().normalize('podcast') await voice.save('clean.mp3') let { pass, rules } = await voice.check('podcast') // each rule of Apple's spec, measured

Browser

<script type="module">

import audio from 'https://esm.sh/audio' audio('./song.mp3').trim().normalize().fade(0.5, 2).clip({ at: 60, duration: 30 }).play()

Audio anywhere

import 'audio/polyfill'          // the page's HTMLAudioElement, in Node, Bun and Deno

let song = new Audio('song.mp3') song.onended = () => console.log('done') await song.play() song.currentTime = 30; song.volume = 0.5; song.loop = true

Events, their order, promises and errors as Chromium's own element has them, compared observation by observation (test/polyfill.js). import { Audio } from 'audio/polyfill' leaves the global alone.

CLI

npm i -g audio # or: npx audio …

audio voice.wav trim normalize podcast save clean.mp3 audio clean.mp3 check podcast

Apple Podcasts https://podcasters.apple.com/support/893-audio-requirements

✓ Loudness -16.44 LUFS -17 to -15

✓ True peak -1.18 dBTP ≤ -1

pass

A fail exits 1, so the same line guards a build: Check in CI.

Skill

npx skills add audiojs/audio

MCP

npx add-mcp "npx -y audio --mcp"  # asks which of your agents: Claude Code, Codex, Cursor, Gemini CLI, Kimi Code, Pi, OpenCode, Zed…

Prompt: make ~/Desktop/interview.m4a podcast-ready and tell me the loudness before and after

One agent at a time: claude mcp add audio -- npx -y audio --mcp, qwen mcp add audio npx -y audio --mcp, droid mcp add audio "npx -y audio --mcp".

Playground and agents

npx audio --bridge

audio bridge on http://127.0.0.1:7777

#

key 3e37b8c61acf5b50f010852168f4843d

agents Claude Code, Codex, Pi, Kimi Code

#

In the playground's Agent panel, paste the key, then Connect. It stays the same next time.

Open the playground, every edit of it a line of audio code, and connect it to the bridge with the key (once: the bridge keeps it), and its chat runs an agent of yours, which measures, looks at, edits and plays the sound open there, and finds which edit did what: it measures the sound before and after each, and what each took out; each tab keeps its conversations, each with the agent, and its model, picked under the message. The bridge finds Claude Code, Codex, Pi, Gemini CLI, Qwen Code, Kimi Code, OpenCode, Kilo Code, Cline, Goose, Factory Droid, Cursor, Augment, Kiro and Mistral Vibe on PATH; any other that speaks ACP runs by its command line, --agent "my-agent --acp".

Any MCP agent gets the playground's tools (state, measure, look, edit, select, play, check, …), the running bridge found by itself: npx add-mcp "npx -y audio --mcp --playground".

An agent thinks with the model its own settings name: Pi takes local ones for good from ollama launch pi --config; Claude Code takes any Anthropic-compatible endpoint from the bridge's environment:

ANTHROPIC_BASE_URL=http://localhost:11434 ANTHROPIC_AUTH_TOKEN=ollama ANTHROPIC_API_KEY= ANTHROPIC_MODEL=qwen3-coder npx audio --bridge

Embed

The playground in any page, its script the element's own text: it runs where the reader scrolls to it, plays, takes edits, and opens whole in the playground. Nothing of the reader's is kept.

<script type="module" src="https://audio.js.org/embed.js"></script>

audio('chime.wav') .trim() .normalize(-1)

What it shows, the frame takes as one JSON: the element's ui attribute, with these attributes over it, each a key of it. panel: code (default), edits (its steps, each with its settings) or none; display: wave or spec; controls: the parts shown, each in its own place: over the picture sound (its name, a menu of its ways in: a file, a take, a sample), link and name (the way to the playground), ruler (the time row; left out, none: the big time says it), look (a band's dropdown of how it draws); in the bar play record loop clock history message heard, a level (level, or what it reads: peak rms loudness), rate channels depth before, view (a switch: the waveform, the spectrogram), open and save (a file of the reader's in; the result out, in the format picked from its menu) — without it, all but sound, view, open and save; ops: edits a press away, one button after the history, a menu of them with their values, as trim normalize(-1) stretch(1.25) reverse (a call's own arguments, or the defaults the menus write); background: the ground it sits on and fades into, a CSS colour, or page, the page's own under the element (the element reads it; a frame can't); height in px. A sound named by its path from the site's root (audio('/sounds/take.mp3')) is that site's file. The shows until the frame comes, and where scripts don't run. Every key, zoom and overshoot too: playground/README.md.

Recipes

Clean up

// master a raw take

let a = audio('raw-take.wav') a.trim(-30).normalize('podcast').fade(0.3, 0.5) await a.save('clean.wav')

// full restoration chain via ecosystem plugins (see API › Plugins) a.gate(-45).dehum().deesser().compressor({ threshold: -18 }).limiter({ ceiling: -1 })

// cut 2:00–2:15, smooth the splice a.remove({ at: 120, duration: 15 }).fade(0.1, { at: 120 })

// find clipped blocks let clips = await a.stat('clipping')

// does it pass? each rule of the spec, measured let { pass, rules } = await a.check('podcast') // acx, podcast, spotify, broadcast, netflix

Master & deliver

// master a song to a reference track: its tone (mid and side), width and loudness, under -1 dBTP

audio('mix.wav').master(await audio('reference.wav')).save('master.wav')

// audiobook chapter for ACX: RMS -23..-18 dB, peaks under -3 dB, floor under -60 dB, room tone at each end, 44.1 kHz let ch = audio('chapter-01.wav') .highpass(80).omlsa({ gMin: -12 }).compressor({ threshold: -24, ratio: 2.5 }) .normalize(-20, 'rms', { ceiling: -3.5 }) .trim().pad(1.5, 2).roomtone() // room tone, not digital silence .resample(44100) console.log(await ch.check('acx')) // passed 10 of 10 real narrations (.work/pro.md) await ch.save('chapter-01.mp3', { bitrate: 192 })

// tighten pauses in a talking-head video, then hand the cuts to the video editor let talk = audio('talk.mp4').shrink(0.3) await talk.save('talk.m4a') // the sound, cut await talk.save('talk.edl') // the same cuts for the picture (Premiere, Resolve)

Compose

// podcast montage

let ep = audio([intro, interview.trim().normalize('podcast'), outro], { crossfade: 0.5 }) await ep.save('episode.mp3')

// voiceover over music music.gain(-12).mix(voice, { at: 2 })

// ringtone: the chorus + fades audio('song.mp3').crop({ at: 45, duration: 30 }).fade(0.5, 2).normalize().save('ringtone.mp3')

// split an audiobook into chapters let [ch1, ch2, ch3] = audio('audiobook.mp3').split(1800, 3600)

// glitch: stutter + reverse let v = a.clip({ at: 1, duration: 0.25 }) audio([v, v, v, v]).reverse({ at: 0.25, duration: 0.25 })

Analyze

// waveform bars — and progressively, as it decodes

let [mins, peaks] = await a.stat(['min', 'max'], { bins: canvas.width }) a.on('data', ({ delta }) => appendBars(delta.max[0], delta.min[0]))

// features for ML let mfcc = await a.stat('cepstrum', { bins: 13 }) let [loud, rms] = await a.stat(['loudness', 'rms'])

// notes, chords, key let notes = await a.stat('notes') // [{time, duration, freq, midi, note, clarity}] let chords = await a.stat('chords') // [{time, duration, label, root, quality, confidence}] let key = await a.stat('key') // {tonic, mode, label, confidence}

Record & generate

// mic take

let a = audio() a.record() // …later a.stop() a.trim().normalize()

// tone — any t => sample function let tone = audio.from(t => Math.sin(440 * Math.PI * 2 * t), { duration: 2 })

// sonify data let s = audio.from(t => Math.sin((200 + data[t / 0.2 | 0]) * Math.PI * 2 * t) * 0.5, { duration: data.length * 0.2 })

Automate

a.gain(t => -12 * (0.5 + 0.5 * Math.cos(t * Math.PI * 4)))  // 2Hz tremolo in dB

a.lowpass(t => 400 + 4000 * t) // filter sweep a.pan({ t: [0, 2, 4], v: [-1, 1, -1] }) // curve L→R→L over 4s, serializable music.ducker({ key: voice }) // sidechain (plugin)

Stream & persist

// stream to network — encode/playback during decode

for await (let chunk of audio('2hour-mix.flac').highpass(40)) socket.send(chunk[0].buffer)

// serialize edits, restore later let json = JSON.stringify(a) // { source, edits, ... } let b = audio(JSON.parse(json)) // re-decode + replay edits

API

Create

| Method                         | Description