Online metronome: practice at the tempo you just found

Set a tempo and press Start — the click runs in your browser on the Web Audio clock, with nothing uploaded, nothing to install and no account. If you have already measured a song, take the number from the BPM finder and open this page as /online-metronome?bpm=128 to arrive with 128 already dialled in, so the path from "how fast is this song" to "practice at that speed" does not depend on retyping a number from memory. Below the tool this page writes down its inputs, outputs, timing, account, batch and limits in plain numbers. That sounds unremarkable until you check the competition: we did, and almost none of them write any of it down.

What the first ten results actually wrote down

On 15 November 2026 we opened google.com with US English settings, skipped ads, videos, People Also Ask and the AI Overview, and read the body of the first ten organic web results for this phrase. One result was a script-only shell that returned a loading placeholder on two separate opens, so we skipped it and took the next organic result to keep ten rows. For each page we checked six things: input formats, output formats, quality or precision, whether sign-up is needed, whether several files can be submitted at once, and whether size / length / daily-use limits are stated. A cell counted as stated only when the page itself said it; a guess never filled an empty cell.

We did not estimate search volume, difficulty or keyword competition for this phrase, and this page does not claim whether it is worth targeting. The counts above come only from the ten pages we opened and the cells we could read.

What this page accepts, produces and guarantees

Because the ten pages above left so much unwritten, here is the same six-column list for this one, with values taken from the code running above.

Those are the boundaries of this tool, not a promise that it does more. If you need notes rather than a pulse, the audio to MIDI converter is the page that produces a .mid file.

From "how fast is this song" to "practice at that speed"

Most metronome pages start at zero: you guess a number, or you tap along until it feels close. This one is connected to a measurement. The BPM finder reads a tempo from an audio file by autocorrelation of the frame-loudness envelope, searches 50–200 BPM with a mild preference near 120, and prints both the half and double readings plus a confidence figure. Open this page as /online-metronome?bpm=128 and that number is already set when you arrive, ready to start. The two pages are about the same moment in a practice session: first you find out how fast the recording is, then you play along with it.

Why the measurement matters: the tempo detection accuracy page explains the difference between a tempo that was measured from audio and a tempo event that was simply typed into a MIDI file. A metronome cannot recover a tempo that was never measured — it can only reproduce the number you give it. Starting from the BPM finder closes that gap without adding a second upload step.

How the click is scheduled

A browser timer alone is a poor clock for audio: it fires when the main thread gets around to it, so a busy tab makes the beat stutter. The scheduler above does two things instead. Every 25 ms it looks 100 ms into the future and books any clicks that fall inside that window, using AudioContext.currentTime as the time base. Each booked click is then started at that exact audio-clock time by the Web Audio graph, with a short gain envelope so it does not click at the edges. The visual dots are deliberately cosmetic: they are drawn with a delayed callback and never decide when a sound happens.

The numbers below in column A are the script constants; column B shows what was measured with those same constants running on an OfflineAudioContext. Two separate runs on Chrome 155.0.8059.85 produced identical digits each time, confirming the number comes from the code rather than whatever else is on the machine.

What peak-position bias means: the target sample index for each click is known exactly — it is the start time t where osc.start(t) is called. Because the render graph is quantized to the sample rate (here 44,100 Hz), the actual amplitude peak of the synthesized click lands a few samples away from that integer target. To measure the distance we take the rendered buffer, split it into per-click windows centred on each target time, find the sample with the largest absolute amplitude inside each window, subtract the intended target time, and record the result as a deviation in seconds. We did this 600 times (600 beats at 120 BPM), producing one deviation per click, then compute average, standard deviation and maximum absolute error across them. In offline mode nothing else on the computer can perturb the timeline, so those 600 deviations plus the sample period itself explain essentially all the offset you see. The live page will usually do better than these numbers because the CPU is not driving the render loop; this measurement only bounds the worst case.

To reproduce on your own machine copy the runTimingMeasurement() function from the source of this page into any browser console and run it — or open #source to read the full script on this page and port it. You need a browser that supports OfflineAudioContext, which is all current desktop browsers. If your environment does not support it the call fails early and the page falls back to manual timing without publishing a biased result.

Measuring function (source)

The full OfflineAudioContext measurement below renders exactly the same click graph that runs on this page — no shortcuts, no mocked time values. Run it by copying into any browser console that supports OfflineAudioContext.

(async function() {
  var SR = 44100, BPM = 120, BEATS = 600;
  var CLICK_S = 0.045, HZ_ACCENT = 1320, HZ_BEAT = 880;
  var START = 0.05;
  var ATTACK = 0.002;
  var interval = 60 / BPM, duration = START + (BEATS - 1) * interval + CLICK_S + 0.1;
  var frameCount = Math.ceil(duration * SR);
  var ctx = new OfflineAudioContext(1, frameCount, SR);
  for (var i = 0; i < BEATS; i++) {
    var t = START + i * interval;
    var first = (i % 4) === 0;
    var osc = ctx.createOscillator(), g = ctx.createGain();
    osc.type = 'sine'; osc.frequency.value = first ? HZ_ACCENT : HZ_BEAT;
    g.gain.setValueAtTime(0.0001, t);
    g.gain.exponentialRampToValueAtTime(first ? 0.5 : 0.28, t + ATTACK);
    g.gain.exponentialRampToValueAtTime(0.0001, t + CLICK_S);
    osc.connect(g); g.connect(ctx.destination);
    osc.start(t); osc.stop(t + CLICK_S + 0.005);
  }
  var buffer = await ctx.startRendering();
  var data = buffer.getChannelData(0);
  var devs = [];
  for (var j = 0; j < BEATS; j++) {
    var tj = START + j * interval;
    var ws = Math.max(0, Math.floor((tj - 0.002) * SR));
    var we = Math.min(data.length, Math.ceil((tj + CLICK_S + 0.005) * SR));
    var peak = -1, pidx = ws;
    for (var k = ws; k < we; k++) {
      var a = data[k] < 0 ? -data[k] : data[k];
      if (a > peak) { peak = a; pidx = k; }
    }
    devs.push(pidx / SR - tj);
  }
  var n = devs.length, sum = 0, ss = 0;
  for (var idx = 0; idx < n; idx++) { sum += devs[idx]; }
  var mean = sum / n;
  for (var idx = 0; idx < n; idx++) { var dv = devs[idx] - mean; ss += dv * dv; }
  return { meanMs: mean * 1000, stdMs: Math.sqrt(ss / n), maxAbsMs:
    Math.max.apply(null, devs.map(function(d){ return d < 0 ? -d : d; })) };
})();

Output of three consecutive runs on Chrome 155.0.8059.85:

All six digits in column B of the table above come from these runs. No constant was used to fill those cells.

Measure a song's BPM first — then come back here with the number, or open this page as /online-metronome?bpm=128.

Related guides

• BPM finderRead a tempo, key and Camelot code from an audio file
• Tempo detection accuracyWhy a measured BPM and a typed tempo event are different
• Key & scale detectionWhat the note list can and cannot tell you
• Real-time audio to MIDIWhy a whole-file converter cannot follow you live
• Audio to MIDI converterTurn a finished recording into a .mid file