Automatically redact PII from audio and video with Python

Cost optimization tips

Building custom PII models requires 6-12 months of development plus ongoing maintenance. AssemblyAI's models achieve 95%+ accuracy across 15+ PII types with zero setup time.

Optimize API usage with these strategies:

• Selective policies: Use redact_pii_policies=[aai.PIIRedactionPolicy.person_name] instead of enabling all policies
• Batch processing: Process multiple files in a single API call with transcriber.transcribe_group(urls, config) for maximum efficiency.
• Caching: Store results in Redis/database for repeated file processing
• File preprocessing: Convert to optimal format before API calls

Process multiple files with batch redaction

In production environments, you'll often need to process multiple files. Here's how to efficiently handle batch processing with proper error handling for each file.

Basic batch processing

For batching a list of URLs, the most efficient method is to use transcribe_group(). This submits all files for processing at once and waits for them to complete.

import assemblyai as aai
from typing import List, Dict

def batch_redact_files(audio_urls: List[str]) -> Dict[str, any]:
   """
   Process multiple audio files for PII redaction using transcribe_group.
   Returns a dictionary mapping URLs to their transcripts or errors.
   """
   config = aai.TranscriptionConfig(
       redact_pii=True,
       redact_pii_audio=True,
       redact_pii_policies=[
           aai.PIIRedactionPolicy.person_name,
           aai.PIIRedactionPolicy.phone_number,
           aai.PIIRedactionPolicy.email_address,
           aai.PIIRedactionPolicy.credit_card_number,
       ],
       redact_pii_sub=aai.PIISubstitutionPolicy.hash,
   )

   transcriber = aai.Transcriber()
   transcript_group = transcriber.transcribe_group(audio_urls, config)

   results = {}
   for transcript in transcript_group:
       if transcript.status == aai.TranscriptStatus.error:
           results[transcript.audio_url] = {'error': transcript.error}
       else:
           results[transcript.audio_url] = {
               'text': transcript.text,
               'redacted_audio_url': transcript.get_redacted_audio_url(),
               'pii_count': len(transcript.pii_redaction) if transcript.pii_redaction else 0
           }
   return results

# Example usage
audio_files = [
   "https://storage.googleapis.com/aai-web-samples/architecture-call.mp3",
   "https://storage.googleapis.com/aai-web-samples/meeting_chunk_1.mp3",
   "https://storage.googleapis.com/aai-web-samples/meeting_chunk_2.mp3",
]

results = batch_redact_files(audio_files)

for url, result in results.items():
   print(f"\n{url}:")
   if 'error' in result:
       print(f"  Error: {result['error']}")
   else:
       print(f"  PII instances found: {result['pii_count']}")
       print(f"  Redacted audio: {result['redacted_audio_url']}")


Async batch processing for better performance

For improved performance when processing many files, use async processing:

import asyncio
import assemblyai as aai
from typing import List

async def async_batch_redact(audio_urls: List[str]):
   """
   Process multiple files concurrently for better performance.
   For batching a list of URLs, `transcribe_group` is a simpler alternative.
   This `asyncio.gather` pattern is useful for more complex async workflows.
   """
   config = aai.TranscriptionConfig(
       redact_pii=True,
       redact_pii_audio=True,
       redact_pii_policies=[
           aai.PIIRedactionPolicy.person_name,
           aai.PIIRedactionPolicy.phone_number,
           aai.PIIRedactionPolicy.email_address,
       ],
   )
   
   transcriber = aai.Transcriber()
   
   # Create tasks for concurrent processing
   tasks = []
   for url in audio_urls:
       task = transcriber.transcribe_async(url, config)
       tasks.append(task)
   
   # Wait for all transcriptions to complete
   transcripts = await asyncio.gather(*tasks, return_exceptions=True)
   
   # Process results
   for url, transcript in zip(audio_urls, transcripts):
       if isinstance(transcript, Exception):
           print(f"Error processing {url}: {transcript}")
       elif transcript.status == aai.TranscriptStatus.error:
           print(f"Transcription failed for {url}: {transcript.error}")
       else:
           print(f"Successfully redacted {url}")
           print(f"  Redacted text preview: {transcript.text[:100]}...")

# Run the async function
audio_files = [
   "https://storage.googleapis.com/aai-web-samples/architecture-call.mp3",
   "https://storage.googleapis.com/aai-web-samples/meeting_chunk_1.mp3",
]

asyncio.run(async_batch_redact(audio_files))


Build secure and compliant applications

In this tutorial, we built a Python script to automatically find and redact sensitive information in audio files and transcripts. This is a critical capability for any application handling user data, ensuring you remain compliant with privacy regulations like HIPAA and GDPR while protecting your users.

PII redaction is just one part of building secure applications. AssemblyAI provides additional security features including:

• SOC 2 Type 2 certification for enterprise-grade security
• HIPAA compliance with Business Associate Agreements available
• End-to-end encryption for all data in transit and at rest
• Data retention controls to automatically delete your data after processing

With PII redaction handled by a reliable API, you can focus on building your application's core features instead of maintaining complex AI infrastructure. Our models are continuously improved by our research team, ensuring you always have access to the latest advances in Voice AI technology.

Ready to add PII redaction to your own application? Try our API for free and see how easy it is to build compliant voice applications.

Frequently asked questions about PII redaction implementation

How do I handle files that exceed the size limits?

Split large files using FFmpeg or use our Streaming Speech-to-Text endpoint for real-time processing without size limits.

What should I do if PII detection confidence is low?

Enable multiple related PII policies and use the word boost feature for domain-specific terms. For critical applications, implement manual review for low-confidence results.

How can I customize redaction for domain-specific PII types?

While AssemblyAI provides comprehensive PII policies out of the box, you can enhance detection for your specific domain by combining multiple policies (for example, using medical_information for healthcare applications), using the entity name substitution to maintain context while redacting, and post-processing the transcript with your own regex patterns for industry-specific identifiers. You can also use our keyterms_prompt feature to improve recognition of domain-specific terms before redaction.

What are the performance differences between audio and text-only redaction?

When you enable redact_pii_audio=True, the API generates a new audio file with the PII portions replaced by silence or tones, which takes additional processing time. Text-only redaction is faster since it only modifies the transcript. For most use cases, the difference is minimal, but if you're processing large volumes and only need redacted transcripts, disabling audio redaction can improve throughput.

How do I validate that all sensitive information was successfully redacted?

Validation is crucial for compliance. You can verify redaction completeness by checking the pii_redaction property of the transcript object to see all detected PII instances, implementing spot checks by comparing samples of original and redacted transcripts, setting up alerts when no PII is detected in files that typically contain sensitive information, and maintaining audit logs of all redaction operations including timestamps and PII types found. For high-stakes applications, consider implementing a two-pass approach where you run the redacted output through a separate PII detection system to verify completeness.