To tune an 808 to your song, find the note its sustained tail actually plays, not the note in the filename or the pitch of the punch, then use the sampler’s coarse and fine tune to put that tail on the song’s root before you write the bassline. Down in the 808’s range a semitone is only 2 to 4 Hz, so an 808 that’s 25 or 30 cents off doesn’t sound like a wrong note. It sounds like mud: a low end that never locks with the chords, no matter how much you EQ it.

The beat’s nearly done. Chords are right, the 808 pattern hits, the kick punches. But the low end feels cloudy, like it’s sitting next to the song instead of under it. So you EQ it, compress it, sidechain it, swap the kick. It gets a bit cleaner and never quite right.

A lot of the time that’s tuning, and no amount of EQ fixes a note that’s between two notes.

Why an off-key 808 doesn’t sound wrong

Ears are good at pitch in the middle of the keyboard and bad at it in the bottom octave. Here’s how small the steps are down there, with A4 at 440 Hz:

#!/usr/bin/env python3
"""Bass-register note frequencies (equal temperament, A4 = 440 Hz), how many Hz one semitone and
25 cents are at each note, and how far varispeed (tape-style slowing) moves the pitch of a whole beat."""
import math
NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]
def freq(name, octave): return 440 * 2 ** ((NAMES.index(name) - 9) / 12 + (octave - 4))

print("note   Hz     1 semitone up   25 cents")
for octave in (1,):
    for n in NAMES:
        f = freq(n, octave)
        print(f"{n+str(octave):<5} {f:6.2f}   +{f*(2**(1/12)-1):4.2f} Hz        {f*(2**(25/1200)-1):4.2f} Hz")
print("\nvarispeed  pitch shift")
for s in (0.95, 0.9, 0.85, 0.8, 0.75):
    st = 12 * math.log2(s); whole = round(st); cents = (st - whole) * 100
    print(f"  x{s:<5}   {st:+6.2f} st  = {whole:+d} st {cents:+4.0f} cents")

$ python3 note_math.py
note   Hz     1 semitone up   25 cents
C1     32.70   +1.94 Hz        0.48 Hz
C#1    34.65   +2.06 Hz        0.50 Hz
D1     36.71   +2.18 Hz        0.53 Hz
D#1    38.89   +2.31 Hz        0.57 Hz
E1     41.20   +2.45 Hz        0.60 Hz
F1     43.65   +2.60 Hz        0.63 Hz
F#1    46.25   +2.75 Hz        0.67 Hz
G1     49.00   +2.91 Hz        0.71 Hz
G#1    51.91   +3.09 Hz        0.76 Hz
A1     55.00   +3.27 Hz        0.80 Hz
A#1    58.27   +3.46 Hz        0.85 Hz
B1     61.74   +3.67 Hz        0.90 Hz

varispeed  pitch shift
  x0.95     -0.89 st  = -1 st  +11 cents
  x0.9      -1.82 st  = -2 st  +18 cents
  x0.85     -2.81 st  = -3 st  +19 cents
  x0.8      -3.86 st  = -4 st  +14 cents
  x0.75     -4.98 st  = -5 st   +2 cents

At G1, a whole semitone is 2.9 Hz and a quarter of one is 0.7 Hz. Nobody hears “that 808 is 25 cents sharp” on its own. What you hear is the 808 rubbing against the bass notes in the chords, and its harmonics (the 2nd, 3rd and up, which is most of what a phone plays back) fighting the keys and pads that live in the same range. That rub reads as mud, not as a wrong note. It’s also why a saturated 808 shows bad tuning more than a clean sine one does: you’ve turned up exactly the part that clashes. More on what phones play in why your 808 disappears on phone speakers.

The filename is a guess, and the punch is sharp

Sample packs label 808s by note, and the label is usually where the designer aimed, often before they saturated, pitched or trimmed it. Then there’s the hit itself: most 808s start high and drop fast into the tail. That pitch drop is the punch. A tuner that reads the first 50 milliseconds reports something sharp, and a tuner that reads the whole thing averages the two.

So measure the tail. This script finds the lowest strong peak between 150 ms and 1 s and, if you give it a key, tells you the coarse and fine tune that put it on the nearest root:

#!/usr/bin/env python3
"""Find the real note of an 808 (or any bass one-shot) from its tail, and the sampler tuning that puts it
on a target note. Usage: python3 find_808_note.py 808.wav [target note, e.g. F or A#]"""
import sys, wave, math, numpy as np
NAMES = ["C", "C#", "D", "D#", "E", "F", "F#", "G", "G#", "A", "A#", "B"]

def load(path):
    with wave.open(path) as w:
        sr, ch, sw = w.getframerate(), w.getnchannels(), w.getsampwidth()
        x = np.frombuffer(w.readframes(w.getnframes()), {2: "<i2", 4: "<i4"}[sw]).astype(float)
    return x.reshape(-1, ch).mean(axis=1) / (2 ** (8 * sw - 1)), sr

def lowest_peak(seg, sr, lo=25, hi=250):
    n = 1 << 20                                             # heavy zero-padding for fine bins
    spec = np.abs(np.fft.rfft(seg * np.hanning(len(seg)), n)); fr = np.fft.rfftfreq(n, 1 / sr)
    band = (fr >= lo) & (fr <= hi); s, f = spec[band], fr[band]
    pk = [i for i in range(1, len(s) - 1) if s[i] > s[i-1] and s[i] >= s[i+1] and s[i] > s.max() / 4]
    i = pk[0]                                               # lowest peak within 12 dB of the strongest
    a, b, c = np.log(s[i-1:i+2]); d = 0.5 * (a - c) / (a - 2 * b + c)
    return f[i] + d * (f[1] - f[0])

def note_of(hz):
    m = 69 + 12 * math.log2(hz / 440); k = round(m)
    return f"{NAMES[k % 12]}{k // 12 - 1}", (m - k) * 100, k

x, sr = load(sys.argv[1])
print("pitch over the first 300 ms (the punch glides down):")
for ms in range(0, 300, 60):
    a = int(sr * ms / 1000); hz = lowest_peak(x[a:a + int(sr * 0.06)], sr)
    print(f"  {ms:3d}-{ms+60:3d} ms  ≈ {hz:5.1f} Hz")
tail = x[int(sr * 0.15):int(sr * 1.0)]
hz = lowest_peak(tail, sr); name, cents, k = note_of(hz)
print(f"tail (150-1000 ms): {hz:.2f} Hz = {name} {cents:+.0f} cents")
if len(sys.argv) > 2:
    t = NAMES.index(sys.argv[2].upper())
    best = min((12 * o + t + 12 for o in range(0, 4)), key=lambda m: abs(m - (69 + 12 * math.log2(hz / 440))))
    shift = best - (69 + 12 * math.log2(hz / 440)); coarse = round(shift); fine = (shift - coarse) * 100
    print(f"to land on {NAMES[t]}{best // 12 - 1} ({440 * 2 ** ((best - 69) / 12):.2f} Hz): "
          f"coarse {coarse:+d} st, fine {fine:+.0f} cents")

We ran it on a synthetic 808 named the way a pack would name it, 808_Fsharp.wav, built so its tail sits at 47.0 Hz, for a song in F:

$ python3 find_808_note.py 808_Fsharp.wav F
pitch over the first 300 ms (the punch glides down):
    0- 60 ms  ≈  66.5 Hz
   60-120 ms  ≈  47.8 Hz
  120-180 ms  ≈  47.0 Hz
  180-240 ms  ≈  47.0 Hz
  240-300 ms  ≈  47.0 Hz
tail (150-1000 ms): 47.00 Hz = F#1 +28 cents
to land on F1 (43.65 Hz): coarse -1 st, fine -28 cents

The punch reads around 66 Hz and the pitch settles by about 120 ms. The tail is F#1 plus 28 cents, so the “F#” sample really sits about a quarter of the way to G. Drop it a semitone for F and it’s still 28 cents sharp on every note of the bassline. Put −28 cents in fine tune as well, and it lands on F1 at 43.65 Hz.

Treat the result as a starting point. A heavily distorted 808 can have a 2nd harmonic louder than its fundamental, and the script takes the lowest strong peak to stay clear of that, but your ears get the final word.

Tuning it in the sampler

1. Fix the cents first. Put the fine-tune number on the sample so it plays a true note. Here that’s −28 cents, so the F# sample is really F#.
2. Tell the sampler the root. Set the root key to the note the sample now plays (F#1). Then pressing F plays F, and every note you program after that is in tune.
3. Check it against something you trust. Hold the song’s root on a piano or a sine an octave or two up and play a long 808 under it. A slow wobble or beating means you’re close but not there. Nudge fine tune until it goes still.
4. Measure with glide off. Portamento and pitch envelopes move the note on purpose. Tune the dry one-shot, then add the slides back.
5. Then the kick. A kick with a strong low note can clash with the 808 too. We go through that in your kick and 808 are arguing in the same chair.

Which octave, and when the chords move

The roots in the table run from 32.70 Hz (C1) to 61.74 Hz (B1). Small speakers and many earbuds give back very little near the bottom of that range, so songs in C, C# or D often put the 808 an octave up (C2 is 65.41 Hz, double C1) or lean on saturation so the harmonics carry it. Keys from E to B keep the root between 41 and 62 Hz, which hits hard on a big system and still has harmonics small speakers can play.

Then follow the chords. If the progression moves from F minor to D-flat and the 808 keeps holding F across the change, the low end turns sour, and it isn’t tuning at all. Move the 808 to the new root, or shorten it so it’s gone before the chord changes.

Slowed and screwed beats change key too

Slowing a beat tape-style drops everything together, so the beat stays in tune with itself. It just doesn’t land neatly on a new key. From the bottom of the script output above: 0.8x is 3.86 semitones down, four semitones plus 14 cents. A beat in A minor slowed to 0.8 sits 14 cents sharp of F minor. Only 0.75x comes out close to a whole step (five semitones, plus 2 cents).

That matters the moment you add something new on top. A fresh 808, a vocal or a keys part should be tuned to the slowed beat, not to the original key. If you’re slowing things down in the ScrewAI demo, run the slowed bounce through the script with the new key and take its cents number. Why slowing a beat is a different job from shifting its pitch is covered in resampling, pitch shifting and tempo change.

Genre notes

• Trap and drill. The 808 is the bassline, so tuning is the bassline. Slides should start and land on notes in key, with the landing held long enough to be heard as a note.
• R&B and pop. The 808 sits under bigger chords. Follow the chord roots and keep notes short enough to clear each change.
• Boom bap and sample-based beats. Records aren’t always at A440, so a sample can sit between keys. Measure the bass note in the sample, then tune the 808 to the sample, not to a chart.
• House and techno. The sub and the kick both carry pitch. Tune the kick’s low note to the root or the fifth, and the sub to the root.

How do I find what key my 808 is in?

Measure the sustained tail, not the attack. Read it with a tuner or a spectrum analyzer from about 150 ms in, or run a short script that finds the lowest strong peak. The note in the filename is often off by a quarter semitone or more.

Why does my 808 sound muddy even on the right note?

It’s probably a few cents off. In the bottom octave a semitone is only 2 to 4 Hz, so 25 cents off is under a hertz. You won’t hear a wrong note, but its harmonics clash with the chords and the low end sounds cloudy.

Should the 808 follow the root or just stay in key?

Usually the root of each chord. A long 808 held across a chord change clashes even when it’s perfectly tuned, so move it or shorten it.

Does slowing a beat change its key?

Yes. Tape-style slowing lowers the pitch by 12 × log2(speed) semitones. At 0.8x that’s 3.86 semitones, so the beat lands 14 cents sharp of a key four semitones down. Tune anything new to the slowed beat.