Load and preprocess your audio file

Audio files come in different formats and configurations, so you need to standardize them before noise reduction. This function loads any WAV file and prepares it for processing:

def load_audio(file_path):
   """Load and prepare audio file for noise reduction"""
   # Read the audio file
   sample_rate, audio_data = wavfile.read(file_path)
   
   # Convert stereo to mono by averaging channels
   if len(audio_data.shape) > 1:
       audio_data = np.mean(audio_data, axis=1)
   
   # Normalize audio to prevent distortion
   audio_data = audio_data.astype(np.float32)
   if np.max(np.abs(audio_data)) > 0:
       audio_data = audio_data / np.max(np.abs(audio_data))
   
   print(f"Loaded {len(audio_data)/sample_rate:.1f} seconds of audio at {sample_rate}Hz")
   return sample_rate, audio_data



This function converts stereo recordings to mono by averaging the left and right channels. It also normalizes the audio levels to prevent clipping during processing.

Apply noise reduction and transcribe with AssemblyAI

Now create the main function that removes noise and handles transcription:

def clean_and_transcribe(input_file, output_file="cleaned_audio.wav"):
   """Remove noise from audio and get transcription"""
   
   # Load the original audio
   sample_rate, audio_data = load_audio(input_file)
   
   # Apply noise reduction
   reduced_noise = nr.reduce_noise(
       y=audio_data,
       sr=sample_rate,
       prop_decrease=0.8,    # Remove 80% of detected noise
       stationary=True       # Assume consistent background noise
   )
   
   # Convert back to integer format for saving
   reduced_noise = np.int16(reduced_noise * 32767)
   
   # Save the cleaned audio
   wavfile.write(output_file, sample_rate, reduced_noise)
   print(f"Cleaned audio saved as {output_file}")
   
   # Transcribe both versions for comparison
   transcriber = aai.Transcriber()
   
   # Transcribe original audio
   original_transcript = transcriber.transcribe(input_file)
   print("Original transcription complete")
   
   # Transcribe cleaned audio  
   cleaned_transcript = transcriber.transcribe(output_file)
   print("Cleaned transcription complete")
   
   return {
       "original_text": original_transcript.text,
       "cleaned_text": cleaned_transcript.text,
       "confidence": cleaned_transcript.confidence,
       "duration": cleaned_transcript.audio_duration
   }

def main():
   # Replace with your audio file path
   audio_file = "noisy_recording.wav"
   
   if not os.path.exists(audio_file):
       print(f"File {audio_file} not found!")
       return
   
   print("Processing audio file...")
   results = clean_and_transcribe(audio_file)
   
   # Display results
   print("\n" + "="*60)
   print("TRANSCRIPTION RESULTS")
   print("="*60)
   
   print("\nOriginal Audio:")
   print(results["original_text"])
   
   print("\nCleaned Audio:")
   print(results["cleaned_text"])
   
   print(f"\nConfidence: {results['confidence']:.0%}")
   print(f"Duration: {results['duration']} seconds")

if __name__ == "__main__":
   main()



The prop_decrease=0.8 parameter tells the algorithm to remove 80% of detected background noise. This setting works well for most recordings without damaging speech quality.

When background noise removal improves transcription accuracy

Background noise removal doesn't always help transcription accuracy. You need to understand when it helps and when it might make things worse.

Signal-to-noise ratio (SNR) is the key factor. SNR measures how loud the speech is compared to background noise, measured in decibels (dB). Clean recordings with high SNR already transcribe well, while noisy recordings with low SNR benefit significantly from cleaning.

Here's when noise removal makes the biggest difference:

• Phone and video calls: Background chatter, echo, and compression artifacts
• Field recordings: Wind, traffic, construction, and crowd noise
• Home recordings: Air conditioning, computer fans, and room echo
• Older audio files: Tape hiss, electrical hum, and analog artifacts

Skip preprocessing for these scenarios:

• Professional studio recordings: Already optimized with minimal noise
• Modern smartphone audio: Built-in noise cancellation already applied
• Previously processed files: Additional cleaning can introduce artifacts

Aggressive noise reduction can damage speech by removing consonant sounds. You might lose the "s" from plural words or turn "fifteen" into "thirteen." These artifacts hurt transcription accuracy more than moderate background noise.

Modern speech-to-text models handle typical background noise well without preprocessing, though speech recognition accuracy still depends heavily on clear audio with minimal background noise, distortion, and echoes. AssemblyAI's Universal models train on millions of hours of real-world audio, learning to distinguish speech from common environmental sounds. But severely degraded audio—like windy outdoor interviews or construction site recordings—still benefits from cleaning.

Final words

You now have three methods to remove background noise from audio—online tools for quick fixes, desktop software for detailed control, and Python scripts for automated processing—and if your recordings include multiple voices, speaker diarization can further clarify who said what. The Python approach we built combines noise reduction with transcription, creating a complete workflow that scales from single files to thousands of recordings.

AssemblyAI's Voice AI models handle moderate background noise effectively without preprocessing, having trained on diverse acoustic environments from quiet studios to busy coffee shops. The platform's Universal models achieve high accuracy even on challenging audio, but combining smart preprocessing with robust speech-to-text models gives you the best results for severely noisy recordings.