Chord identifier from audio: what it can name, and what it cannot

The short answer: a chord identifier built on this converter does not name chords. It detects up to 6 pitches per analysis frame, writes each one as a MIDI note, and stops there. There is no chord dictionary, no Roman-numeral labeller, and no text event in the exported file — we checked, and a two-note export contains exactly 71 bytes with only tempo, time-signature and end-of-track meta events. Naming the chord is a step you do after the fact, by looking at the notes in a piano roll. What the engine can do is find the pitches that make up a chord: a clean C major triad (C4 + E4 + G4) played on its own comes back as all three notes, correctly pitched and correctly timed. What it cannot do is find those same notes when they are buried in a full mix — in our song test the chords came back at 10 of 24 when mixed with bass, melody and drums, against 24 of 24 when converted alone. It also cannot find a chord whose notes are harmonics of a lower note: play C4 and C5 together and the harmonic-suppression rule collapses them into a single C4, because C5 is the second harmonic of C4 and the detector cannot tell them apart. So the honest answer to “can it identify chords” is: it can find the notes, under the right conditions, and you name the chord.

What the engine actually does when it sees a chord

Before asking what a chord identifier can name, it helps to know what the detection pipeline does with a frame that contains more than one pitch. This converter resamples audio to 22 050 Hz, reads it with a 2048-point FFT stepped forward 256 samples at a time, and produces one frame every 11.610 ms (86.13 frames per second). In polyphonic mode, each frame can emit up to 6 spectral peaks — the six loudest candidates above a relative threshold. Each peak is then refined with parabolic interpolation across three neighbouring bins and rounded to the nearest MIDI key. That is where notes come from: not from a chord table, but from a peak picker running on a short slice of spectrum.

Three built-in rules shape which peaks survive:

• Relative-to-peak threshold. A candidate must reach 0.14 − 0.11 × sens of the frame’s loudest peak — 7.4% at the default sensitivity of 60. A chord partial quieter than that is discarded before it ever becomes a note.
• Harmonic suppression. When two peaks sit in a harmonic relationship (one is an integer multiple of the other), the lower one absorbs the higher one. This is what makes C4 + C5 collapse to a single C4: C5 is the second harmonic of C4, and the detector has no way to know that both were played intentionally.
• Six-voice ceiling. The peak picker stops at six candidates per frame. A seven-note chord produces six notes plus fragmentation; an eight-note chord produces ten note objects with three fragments. The ceiling is per frame, not per file — a chord that holds for one second spans 86 frames, and each one independently picks its six.

None of those rules look up a chord name. They are spectral operations. The chord name is something a human applies after reading the notes — or something a separate analysis tool does on top of the exported MIDI, not something this engine writes into the file.

Clean triads, measured: what comes back when nothing competes

To get a baseline, we ran isolated synthesised chords through this site’s own analyser (dsp.js). Every chord was played as three sine partials at equal amplitude, 0.60 seconds long, with known pitches so “correct” is not a matter of opinion:

Every triad came back complete. The notes were pitched correctly and started within 7–12 ms of their written onset — within the 11.610 ms frame grid, which is the best the engine can do. A four-note seventh chord (C4 + E4 + G4 + B4) also returned all four pitches. So the ceiling for a clean, isolated chord is not three notes; it is six, and common four-note voicings are within it.

A chord progression tells you whether the timing holds across changes. We ran C–G–Am–F, one bar each at 120 BPM, and got 12 notes out of 12 expected: 8 distinct pitches, all correct, 0 extra notes, with onsets 7–12 ms from each bar line. That is the case where a chord identifier built on this engine works: the notes are there, the timing is frame-accurate, and you can read the chords off the piano roll.

The harmonic suppression rule: when a chord stops being a chord

The one built-in behaviour that silently destroys chords is harmonic suppression. When two notes in a chord sit in a harmonic relationship, the lower one absorbs the higher one, because the detector cannot distinguish “an overtone” from “a note that was played”. We measured three cases:

The rule is simple: if one note’s frequency is an integer multiple of another’s, the higher one gets absorbed. A C major triad with a doubled root (C4 + E4 + G4 + C5) comes back as three notes, not four. A power chord (root + fifth) survives because the fifth is not an integer multiple of the root. But any voicing that stacks octaves — and many guitar and piano voicings do — will lose the doubled notes. This is not a setting you can turn off; it is how the harmonic-comb scoring works. If your chord identifier needs every note, keep the voicing within one octave.

What happens when the chord is inside a mix

The clean-triad test is the best case. Real audio usually has other instruments playing at the same time, and that is where chord identification falls apart — not because the engine cannot find chords, but because the relative-to-peak threshold silences chord partials that are quieter than the loudest thing in the frame. We built a 16-second song with known answers — 16 bass notes, 24 chord notes, 32 melody notes — and converted it as a full mix and then each stem alone. The chord numbers tell the story:

The chords lost 13 of 24 notes the moment the bass joined them — not because of the drums, not because of the melody, but because the kick drum peaks at 0.90 amplitude while the chord stem sits at 0.42. At the default sensitivity, a partial must clear 7.4% of the frame’s loudest peak to count. The chord partials are still in the spectrum; they simply do not clear that line when something louder is present. Adding the melody and the drums did not make it worse — the damage was done by the first loud neighbour.

This is why a chord identifier from audio works on a solo piano recording and fails on a finished song. If you want to identify the chords in a full mix, the path that actually works is to isolate the chord stem first — using a source-separation tool, an EQ cut, or simply converting the section where only the chords are playing — and then run the converter on that. The engine can find the notes; it cannot find quiet notes next to loud ones. For more on this, Song to MIDI: what a full mix comes back as breaks down the entire 197-note export.

The low-register limit: chords below 181 Hz

Even in isolation, a chord has to sit in a region where the FFT can separate its notes. Each FFT bin at this converter’s settings is 10.77 Hz wide. A semitone is 5.95% of a frequency, so below 181 Hz (approximately F#3) two neighbouring semitones fall inside the same bin. A low chord like E2 + G2 + B2 (an E minor triad in first inversion on a guitar’s low strings) has its notes at 82, 98 and 124 Hz — the semitone gaps are 4.9 and 5.8 Hz, both under one bin. The detector may return the right notes by luck of the parabolic interpolation, or it may return one note that is the average of two. This is not a chord-specific limitation; it is the same arithmetic that makes any low note hard to read — the 181 Hz resolution line applies to single notes and chords equally.

Practical rule: if the lowest note of the chord is below F#3 (~185 Hz), the chord identifier may return the right pitch class but the wrong octave, or merge two notes into one. Transpose the audio up before converting if the chord matters, then transpose the MIDI back — though any note that was misread at the original pitch is still misread, just shifted.

What is in the file, and what is not

If the engine does not name chords, what does it write? We parsed the exported MIDI file event by event rather than scanning raw bytes, because a raw byte scan mistakes velocity values for status bytes. A two-note export is 71 bytes and contains:

One note track, one channel, no instrument assignment, no key signature, no text, no lyrics, no track name. The writer in midi.js emits only 0x90 (note on) and 0x80 (note off) for the note track, plus three meta events: tempo, time signature, and end of track. There is no code path that writes a chord name, a chord symbol, or any analytical label. If you need “C major” written somewhere, you do it in your DAW after importing the MIDI — the engine does not detect the key either, so there is no key for a chord-naming tool to work against.

What this means for chord identification: the converter gives you the raw pitches and the timing. You read them in a piano roll, recognise the stack as a chord, and name it. Or you feed the MIDI into a separate tool that does chord analysis on a note list. The engine is a front end — it turns sound into notes — not a theory engine.

When it works, when it does not, and what to do instead

The pattern is consistent: the engine finds pitches when they are the loudest thing in the frame, when they are above the 181 Hz resolution floor, and when they are not octave doubles of each other. When any of those conditions fail, you lose notes — and a chord with a missing note is not the same chord. The fix is almost always before conversion: isolate the source, transpose if needed, and choose a voicing the engine can separate. After conversion, the five-pass cleanup handles the debris that polyphonic mode adds, and polyphonic is the only mode that can see a chord at all — monophonic commits to one pitch per frame and returns zero chord tones by construction.

How to test it on your own audio

You do not need to trust the numbers above — run your own. This takes about two minutes:

1. Find a short section of audio where a chord is playing and little else — a piano intro, a guitar chord stab, a sustained pad.
2. Convert it here in polyphonic mode with the default settings (sensitivity 60, shortest note 60 ms).
3. Download the .csv alongside the MIDI. The columns are index,midi_note,note_name,start_sec,end_sec,duration_sec,velocity.
4. Sort by start_sec. Notes that start within 50 ms of each other are likely from the same chord.
5. Read the note_name column for that cluster. If you see C4, E4, G4, that is a C major triad — the engine found the notes, you named the chord.
6. If notes are missing, check the register (below F#3?), the mix (is something louder playing?), and the voicing (are there octave doubles?).

The CSV is the fastest way to see what the engine actually found, because the piano roll can hide short notes in a dense display. If you want to compare two chords, convert each section separately and diff the note lists.

Convert a file now — runs in your browser, nothing is uploaded. Use polyphonic mode and read the CSV to see the chord notes.

Related guides

• Mono vs polyWhy monophonic mode returns zero chord tones
• Song to MIDIWhat a full mix comes back as, measured
• Guitar to MIDIWhat a bend does to your notes
• Key & scale detectionWhy the file records pitches, not an analyzed key
• MIDI converterWhat is actually inside a MIDI file
• Clean up a converted MIDIThe 5 passes that turn a raw export into a usable part
• Audio to MIDI softwareHow many notes it can hold at once
• MP3 to MIDIThe 181 Hz resolution line and what it means for bass