Mains hum isn’t just a 60 Hz tone (50 Hz in Europe and much of the world). It’s a buzz with harmonics at 120, 180, 240 Hz and up, and in our test two-thirds of its energy sat above the fundamental. That’s why a high-pass filter barely helps. Find the exact hum frequency, put a narrow notch on it and on each harmonic you can see, and the hum drops a long way while the voice hardly changes.

You bring up the vocal or the DI guitar on its own and there it is: a low drone under everything, louder in the gaps. The reflex is a high-pass filter. You sweep it up to 80, then 100, then 150 Hz, and the hum is somehow still there, just thinner and more nasal. Meanwhile the voice is starting to sound small.

That isn’t you doing it wrong. It’s what hum is made of.

Hum is a buzz, not a tone

Wall power alternates at 60 Hz in North America and parts of South America and Asia, and at 50 Hz across Europe, the UK, Africa, Australia and most of Asia. Japan has both, depending on the region. When that leaks into a recording through a ground loop, a cheap power brick or a single-coil pickup, it rarely arrives as a clean sine. It comes in distorted, with harmonics at every multiple: 120, 180, 240, 300 Hz and up. The odd ones are often stronger, which is why it sounds like a buzz rather than a low note.

Those harmonics land right in the range where vocals, guitars and snares live. A high-pass at 80 Hz only takes the fundamental. Everything above stays.

We wrote hum_check.py to put numbers on it. It builds a synthetic hum with 15 harmonics up to 900 Hz (falling 3 dB per harmonic, odd ones 6 dB hotter) and a separate sung A3, 220 Hz with vibrato. Every fix here is a plain filter, so the script runs the hum and the voice through each one on their own and reports how much of each is left.

#!/usr/bin/env python3
"""How much hum does each fix remove, and how much of the take does it cost?
  python3 hum_check.py [mains_hz]
Builds a synthetic mains hum (fundamental plus harmonics up to 900 Hz, falling 3 dB per harmonic,
odd harmonics 6 dB hotter: a buzz, not a pure tone) and a separate synthetic sung note (A3, 220 Hz,
with vibrato). Every fix is a linear filter, so we run hum and voice through it separately and
report what's left of each, in dB relative to before the fix.
"""
import sys
import numpy as np
from scipy import signal

SR, DUR = 48000, 4.0
MAINS = float(sys.argv[1]) if len(sys.argv) > 1 else 60.0
t = np.arange(int(SR * DUR)) / SR

def hum(f0):
    x = np.zeros_like(t)
    for k in range(1, int(900 // f0) + 1):
        gain_db = -3.0 * (k - 1) + (6.0 if k % 2 else 0.0)
        x += 10 ** (gain_db / 20) * np.sin(2 * np.pi * k * f0 * t + 0.7 * k)
    return x

def voice():
    f = 220 * 2 ** ((0.35 * np.sin(2 * np.pi * 5.5 * t)) / 12)        # ±35 cent vibrato
    ph = 2 * np.pi * np.cumsum(f) / SR
    return sum((1 / k) * np.sin(k * ph) for k in range(1, 25))

def db(x, ref): return 10 * np.log10(np.mean(x ** 2) / np.mean(ref ** 2) + 1e-30)

def notch_chain(freqs, q):
    def run(x):
        for fc in freqs:
            b, a = signal.iirnotch(fc, q, SR)
            x = signal.filtfilt(b, a, x)
        return x
    return run

def highpass(fc, order):
    sos = signal.butter(order, fc, "highpass", fs=SR, output="sos")
    return lambda x: signal.sosfilt(sos, x)

H, V = hum(MAINS), voice()
harm = [MAINS * k for k in range(1, int(900 // MAINS) + 1)]
fixes = [
    ("high-pass 80 Hz, 24 dB/oct", highpass(80, 4)),
    ("high-pass 150 Hz, 24 dB/oct", highpass(150, 4)),
    (f"one notch at {MAINS:g} Hz, Q 30", notch_chain([MAINS], 30)),
    (f"notches {MAINS:g}-{harm[3]:g} Hz (4), Q 30", notch_chain(harm[:4], 30)),
    (f"notches {MAINS:g}-{harm[-1]:g} Hz ({len(harm)}), Q 30", notch_chain(harm, 30)),
    (f"notches {MAINS:g}-{harm[-1]:g} Hz ({len(harm)}), Q 8", notch_chain(harm, 8)),
    (f"wrong mains: notches at 50 Hz multiples, Q 30", notch_chain([50 * k for k in range(1, 19)], 30)),
]
skip = slice(SR // 2, -SR // 2)                                       # ignore filter edges
above = sum(10 ** ((-3.0 * (k - 1) + (6.0 if k % 2 else 0.0)) / 10) for k in range(2, len(harm) + 1))
total = above + 1.0
print(f"Mains {MAINS:g} Hz hum, {len(harm)} harmonics to {harm[-1]:g} Hz; "
      f"{100 * above / total:.0f}% of the hum's energy is above the fundamental.")
print(f"{'fix':44s} {'hum left':>9s} {'voice change':>13s}")
for name, f in fixes:
    print(f"{name:44s} {db(f(H)[skip], H[skip]):8.1f}  {db(f(V)[skip], V[skip]):11.2f} dB")

$ python3 hum_check.py
Mains 60 Hz hum, 15 harmonics to 900 Hz; 67% of the hum's energy is above the fundamental.
fix                                           hum left  voice change
high-pass 80 Hz, 24 dB/oct                       -4.1        -0.00 dB
high-pass 150 Hz, 24 dB/oct                      -6.4        -0.12 dB
one notch at 60 Hz, Q 30                         -4.8        -0.00 dB
notches 60-240 Hz (4), Q 30                     -12.0        -0.25 dB
notches 60-900 Hz (15), Q 30                    -50.5        -1.01 dB
notches 60-900 Hz (15), Q 8                    -130.5        -5.44 dB
wrong mains: notches at 50 Hz multiples, Q 30     -0.4        -1.34 dB

Reading the numbers

Two-thirds of the hum isn’t at 60 Hz. That one line explains the rest. Removing the fundamental perfectly can only ever take about 4.8 dB off, which is what a single notch at 60 Hz does, and the 80 Hz high-pass lands nearby at 4.1 dB. Pushing the high-pass to 150 Hz only gets 6.4 dB, because the loud odd harmonics at 180 and 300 Hz are still there.

Notching the harmonics is what works. Four narrow notches (60 to 240 Hz) take 12 dB off. Notching all 15 harmonics up to 900 Hz takes 50.5 dB off, which turns an obvious buzz into nothing you’ll hear in a mix, and the voice changes by about 1 dB.

That 1 dB has a reason. The note’s third harmonic is 660 Hz, which is exactly 11 × 60. When a sung note lands on a hum harmonic, that notch takes a bite out of the note too. Narrow notches keep that bite small. Wide ones don’t: the same 15 notches at Q 8 wipe out the hum completely but take 5.4 dB out of the voice, which you’ll hear as a hollow, phasey tone.

The wrong mains frequency does nothing useful. Notches on 50 Hz multiples moved our 60 Hz hum by 0.4 dB and still cost the voice 1.3 dB. Measure first. Don’t assume.

Real hum drifts a little and real voices move around more than one note, so read these as a model, not a promise. The pattern holds though: the harmonics carry the hum, and narrow beats wide.

How to do it in your session

1. Find a gap with only hum. Loop a second or two before the first word, or between lines, and open a spectrum analyzer on it.
2. Read the spacing. Hum shows up as a row of evenly spaced spikes. If they’re 60 Hz apart, it’s 60 Hz mains. If they’re 50 apart, it’s 50. Zoom in on the lowest one to get the exact frequency, since it can sit at 59.9 or 60.1.
3. Notch the fundamental and every harmonic that pokes up. Use a narrow bell cut, Q 20 to 40, as deep as it needs to be. Work up the row until the spikes stop rising above the noise. That’s often somewhere between 300 Hz and 1 kHz.
4. Keep the high-pass for what it’s good at. A gentle high-pass under the voice still cleans up rumble. It just isn’t a hum fix. Rumble you can’t hear is eating your limiter covers that side.
5. If the hum is quiet, stop there. If it’s loud, a dedicated de-hum plugin does the same comb of notches but follows the hum as it drifts. Whatever you use, solo the vocal, then listen in the full mix. That’s the version people hear.

Check what you lost

Bounce the vocal before and after, and flip between them level-matched in an A/B such as CoProducer’s. Listen to the words, not the gaps. The gaps will obviously be better. What you’re checking is that sustained notes don’t sound hollow. If one note goes thin, it’s probably sitting on a harmonic. Narrow that notch, or automate it shallower through that phrase.

Fix it at the source next time

Notches clean up a take you can’t redo. If you can redo it, ten minutes of troubleshooting beats an hour of EQ. Plug the interface, computer and amp into the same power strip. Use a DI box with a ground lift for keyboards and laptops. Keep audio cables away from power bricks. Turn single-coil guitars to face away from the monitor or the computer. Unplugging the laptop charger is a classic quick test: if the buzz stops, you’ve found it.

And clean it on the track, not the master. A hum on one vocal track is easy to notch on that track. Once it’s summed with a bass and an 808 that also live around 60 to 180 Hz, every notch on the master cuts the music too. If the gaps still sound noisy after the hum is gone, why quiet masters bring the noise up with them is the next read.

Why doesn’t a high-pass filter remove hum?

Because most of the hum isn’t at 60 or 50 Hz. It’s in the harmonics above. In our test two-thirds of the hum’s energy sat above the fundamental, so an 80 Hz high-pass only removed 4.1 dB and a 150 Hz one only 6.4 dB.

Is hum 50 Hz or 60 Hz?

It matches the local wall power: 60 Hz in North America and some of South America and Asia, 50 Hz in Europe, the UK, Africa, Australia and most of Asia. Check a spectrum analyzer. The spikes will be spaced 50 or 60 Hz apart.

What Q should a hum notch be?

Narrow, roughly Q 20 to 40. In our test 15 notches at Q 30 removed 50.5 dB of hum and changed the voice by about 1 dB. The same notches at Q 8 removed all the hum but took 5.4 dB from the voice.

Should I remove hum on the master?

Avoid it if you can. Bass and 808s share the same range, so notches on the master cut the music too. Fix the individual track that has the hum.