NoiseLog: A Sound Meter App for Noisy Neighbors

When I complained about noise to my building manager, they asked for evidence. “It’s loud” wasn’t enough. They wanted dates, times, and decibel readings. So I built an app that gives you all three — and generates a report you can actually hand to someone.

The Noise Complaint Trap

Here’s how noise complaints typically go: you’re frustrated, you call the landlord or the city, they say “we’ll look into it,” nothing happens. Why? Because verbal complaints carry almost zero weight. Without documentation — specific dates, times, duration, and measured intensity — you’re just another person saying “it’s too loud.”

Professional sound level meters cost $200+. An acoustic engineering assessment starts at $500. Most people just suffer in silence (pun intended) or escalate to a confrontation. Neither is a great outcome.

Your Phone Microphone Is Good Enough

Modern smartphone microphones are surprisingly capable. They won’t match a calibrated Type I sound meter, but for documenting noise levels in the 40–100 dB range — which covers everything from a loud TV to construction equipment — they’re more than adequate. Courts and housing authorities don’t require laboratory-grade measurements; they require consistent, timestamped records.

NoiseLog uses your phone’s microphone to capture ambient sound, processes it through a standard A-weighted decibel calculation, and displays the result in real time.

Three Screens, One Workflow

Sound Meter. A live dB reading with a 60-second rolling chart. Color bands show you whether the noise level is safe (green), moderate (yellow), loud (orange), or harmful (red, 85+ dB). The day limit indicator shows if you’ve been exposed to noise above safe thresholds.

Incidents. One tap logs the current noise level with a timestamp. “Tuesday, 11:47 PM, 78 dB.” Over a few days or weeks, you build a pattern. “This happens every weeknight between 11 PM and 2 AM, averaging 72 dB.” That’s not a complaint — that’s evidence.

Report. Generate a formatted summary of all logged incidents. Dates, times, decibel readings, in a clean layout you can screenshot, print, or share. Hand it to your landlord, attach it to a noise ordinance complaint, or bring it to a mediator. Structured data is harder to ignore than “my neighbor is loud.”

Beyond Neighbors

Noise complaints are the obvious use case, but people have found others:

• Workplace safety — OSHA requires hearing protection above 85 dB. NoiseLog helps document whether your factory floor or machine shop meets standards
• Event planning — check if your venue stays within local noise ordinance limits during rehearsals
• Parenting — curiosity check: how loud is that toy your kid loves? (Often shockingly loud)
• Musicians — monitor rehearsal room levels to protect hearing
• Real estate — measure ambient noise levels in a potential apartment before signing a lease

Free vs. Pro

The free version is fully functional — real-time metering, incident logging, reports. The only friction is a short video ad when you start a measurement session. The Pro subscription ($1.99/month) removes ads, unlocks unlimited incident storage, and enables detailed CSV export for anyone who needs to submit formal documentation.

How Decibel Measurement Works in the Browser

NoiseLog’s core measurement engine runs entirely in the browser using the Web Audio API. No server, no uploads, no third-party SDKs touching your microphone data. Here’s the signal chain that turns raw microphone input into a decibel reading:

// Web Audio API: microphone to dB meter
async function initMeter() {
  const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
  const audioCtx = new AudioContext();
  const source = audioCtx.createMediaStreamSource(stream);
  const analyser = audioCtx.createAnalyser();
  analyser.fftSize = 2048;
  source.connect(analyser);

  const buffer = new Float32Array(analyser.fftSize);

  function calculateDB() {
    analyser.getFloatTimeDomainData(buffer);

    // RMS (Root Mean Square) calculation
    let sumSquares = 0;
    for (let i = 0; i < buffer.length; i++) {
      sumSquares += buffer[i] * buffer[i];
    }
    const rms = Math.sqrt(sumSquares / buffer.length);

    // Convert RMS to decibels
    const db = 20 * Math.log10(Math.max(rms, 1e-10));

    // A-weighting approximation for human-perceived loudness
    // Boosts mid-frequencies (1-6 kHz) where human hearing is most sensitive
    const aWeighted = applyAWeighting(db, analyser, buffer);

    return {
      raw: db.toFixed(1),
      aWeighted: aWeighted.toFixed(1),
      rms: rms
    };
  }

  // A-weighting filter approximation
  function applyAWeighting(dbValue, analyser, timeDomain) {
    const freqData = new Float32Array(analyser.frequencyBinCount);
    analyser.getFloatFrequencyData(freqData);
    const nyquist = audioCtx.sampleRate / 2;
    let weightedSum = 0;
    let totalEnergy = 0;

    for (let i = 0; i < freqData.length; i++) {
      const freq = (i / freqData.length) * nyquist;
      const energy = Math.pow(10, freqData[i] / 10);
      // Simplified A-weighting curve
      const weight = aWeightCoeff(freq);
      weightedSum += energy * weight;
      totalEnergy += energy;
    }

    const correction = totalEnergy > 0
      ? 10 * Math.log10(weightedSum / totalEnergy)
      : 0;
    return dbValue + correction;
  }

  function aWeightCoeff(f) {
    // IEC 61672 A-weighting approximation
    const f2 = f * f;
    const num = 1.4866e8 * f2 * f2;
    const den = (f2 + 424.36) * Math.sqrt((f2 + 11599.29) *
      (f2 + 544496.41)) * (f2 + 148693636);
    const ra = num / den;
    return ra * ra * 1.9997;
  }

  // Update loop at 30fps
  setInterval(() => {
    const reading = calculateDB();
    updateDisplay(reading);
    logToHistory(reading);
  }, 33);
}

The key steps: getUserMedia grabs the microphone stream, the AnalyserNode provides raw audio samples, and then it’s just math. RMS gives you the average energy in the signal, and the log10 conversion maps it to the decibel scale humans are used to. The A-weighting filter is critical — without it, you’d measure low-frequency rumble (like HVAC systems) at the same level as a conversation, which isn’t how humans perceive loudness.

Calibration and Accuracy

Let’s be honest: your phone microphone is not a professional SPL meter. It has a limited dynamic range, nonlinear frequency response, and automatic gain control that most browsers can’t fully disable. But here’s the thing — for the purpose of documenting noise complaints, it doesn’t need to be perfect. It needs to be consistent and timestamped.

I calibrated NoiseLog against a UNI-T UT353 mini sound level meter (about $30 on most electronics sites) in my apartment. The process was straightforward: play pink noise at a known level, read both meters simultaneously, and calculate the offset. Here’s what I found across different volume levels:

• 40–50 dB (quiet room): Phone read 2–4 dB lower than the SPL meter. Microphone sensitivity drops off at very low levels.
• 50–70 dB (conversation to loud TV): Within ±2 dB. This is the sweet spot where phone microphones are most accurate.
• 70–85 dB (loud music, vacuum cleaner): Within ±3 dB. Still reliable enough for evidence.
• 85+ dB (harmful levels): Phone microphone begins to clip. Readings plateau around 90–95 dB regardless of actual level. If you’re measuring construction noise, the phone underreports.

For the 50–85 dB range — which covers virtually every noise complaint scenario (loud neighbors, barking dogs, late-night parties) — a typical smartphone accuracy of ±3 dB is more than adequate. Housing authorities and mediators aren’t looking for laboratory precision. They’re looking for a pattern: repeated measurements at specific times showing levels above the local ordinance threshold.

NoiseLog includes a calibration offset setting so you can adjust readings if you do have access to a reference meter. The code is simple:

// Calibration offset stored in user settings
const CALIBRATION_KEY = 'noiselog_calibration';

function getCalibratedDB(rawDB) {
  const offset = parseFloat(
    localStorage.getItem(CALIBRATION_KEY) || '0'
  );
  return rawDB + offset;
}

// User measures a known source, enters the reference value
function calibrate(measuredDB, referenceDB) {
  const offset = referenceDB - measuredDB;
  localStorage.setItem(CALIBRATION_KEY, offset.toString());
  console.log(
    'Calibration offset set to ' + offset.toFixed(1) + ' dB'
  );
}

One calibration session with a known reference point improves accuracy significantly. Even without calibration, the relative measurements are consistent — if NoiseLog says tonight is 8 dB louder than last night, that’s a real difference regardless of the absolute number.

From Side Project to Noise Complaint Evidence

My upstairs neighbor’s subwoofer was the reason this app exists. Every night between 11 PM and 1 AM, bass-heavy music would vibrate through the ceiling. I asked politely. I left a note. I called the building manager, who asked: “Can you document the dates and times? Do you have any readings?”

I didn’t. So I built NoiseLog over a weekend, and for the next three weeks, I logged every incident. Tap the button when it starts, tap again when it stops. The app records the timestamp, peak dB, average dB, and duration automatically.

After 21 days, I generated a report showing 18 incidents, all between 10:45 PM and 1:30 AM, averaging 68 dB with peaks hitting 76 dB. For context, most local noise ordinances set the nighttime limit at 50–55 dB for residential areas. My data showed consistent, documented violations — not a one-time complaint.

The building manager took it seriously because structured data is harder to dismiss than “my neighbor is loud.” They issued a formal warning, and the late-night subwoofer sessions stopped within a week. No confrontation, no escalation, just data.

What I learned about noise ordinances along the way: they vary wildly by municipality, but almost all of them distinguish between daytime and nighttime limits, and most set the residential nighttime threshold between 45 and 55 dB measured at the property line. Some jurisdictions use C-weighting (which captures bass better than A-weighting), and some require measurements from inside the affected unit. Check your local code before relying on any specific number.

The most important lesson: time-series logging matters more than peak readings. A single 80 dB spike could be a dropped pan — it means nothing. But 18 data points showing sustained 65+ dB levels between 11 PM and 1 AM over three weeks? That’s a pattern, and patterns are what enforcement agencies act on. That’s why NoiseLog emphasizes incident logging over instantaneous measurements — the real value is in the history, not the number on screen right now.

More From the App Factory

NoiseLog is part of our collection of free browser and mobile tools built to solve real problems. If you like the idea of gamified productivity, check out FocusForge — a Pomodoro timer with XP, levels, and daily streaks. We also wrote about why the Pomodoro Technique actually works when your timer has streaks.

Get It

👉 NoiseLog on Google Play (Android)

If you’re dealing with noise issues, start logging today. A week of data is worth more than a year of verbal complaints.