How to build a lecture capture system with speaker identification

This tutorial shows you how to build a complete lecture capture system that automatically identifies different speakers in classroom recordings. You'll create a Python application that records audio, processes it through Voice AI models for speaker diarization, and generates accessible captions with speaker labels. The system handles real classroom conditions like background noise and varying microphone distances while keeping privacy considerations in mind for educational settings.

You'll use Python's audio recording libraries, AssemblyAI's speaker diarization API, and standard caption formats like WebVTT and SRT. The implementation processes audio asynchronously through cloud-based AI models, delivering higher accuracy than local processing while generating searchable transcripts that students can use to jump directly to instructor explanations or specific discussion topics. For live classroom use, we also cover the real-time streaming diarization option.

What is a lecture capture system?

A lecture capture system is software that records classroom audio and video, then makes those recordings available for students to watch later. This means you can automatically capture what happens in your classroom and give students on-demand access to review lectures, discussions, and presentations.

Modern systems go beyond basic recording by adding speaker diarization—technology that tells you who's talking at any moment in the recording. This creates searchable transcripts where students can jump directly to professor explanations or student questions.

When you add speaker diarization to your lecture capture system, you get several key benefits: searchable content where students can search for specific speakers or topics, better accessibility through captions that show who's speaking for students with hearing difficulties, study efficiency by letting learners skip directly to instructor explanations, and cleaner organization of Q&A sections separate from lecture content.

Why speaker diarization matters for lecture capture

Speaker diarization transforms a basic recording into an intelligent learning resource. When your system can tell the difference between the professor's voice and student questions, it creates much more useful content for learning.

Here's what makes the biggest difference for students: international learners can identify speakers even when working through accented speech; screen readers can announce speaker changes for visually impaired students; and automated systems can separate lecture content from Q&A discussions for more focused study.

A note on privacy: In educational settings, speaker diarization produces anonymous labels—Speaker A, Speaker B—not names tied to student identities. If you're considering named speaker attribution, be aware that many privacy frameworks (including FERPA in the US, which protects students' educational records from unauthorized disclosure) counsel care around identifying and storing records of individual student voices. The recommended approach is to use generic labels, obtain informed consent before recording, and store transcripts with appropriate access controls. See the compliance section below for implementation details.

Lecture capture system architecture options

You can build lecture capture systems using two main approaches: hardware-based solutions or software-based implementations. Each approach handles speaker diarization differently and affects your costs and capabilities.

Software-based systems for speaker diarization

Software-based systems give you the most flexibility for speaker diarization because they can integrate with modern Voice AI APIs. You use standard computers with quality microphones to capture audio, then send recordings to cloud services for processing.

This approach costs much less upfront than hardware systems. You only pay for the speech-to-text processing you use, and you can upgrade your speaker diarization capabilities as AI models improve without buying new equipment.

Python-based implementations work best for custom lecture capture systems. You can use libraries like PyAudio to record classroom discussions, then process those recordings through speech-to-text APIs that specialize in speaker diarization.

How to build a lecture capture system with speaker diarization

Building your system requires four main steps: setting up audio capture, configuring Python, implementing speaker diarization, and generating captions. Each step builds on the previous one to create a complete solution.

Set up audio capture for speaker diarization

Quality audio recording determines how well your system can identify different speakers. You need clear audio from both instructors and students to get accurate results from speaker diarization models.

Record at 16kHz sample rate minimum with 16-bit depth for reliable speaker diarization. Higher quality like 44.1kHz improves accuracy but creates larger files. Position microphones to capture speech clearly from different areas of your classroom.

Test your audio setup with this Python script:

import sounddevice as sd
import wave

def test_microphone_quality():
    """Test your microphone setup for speaker diarization"""
    duration = 10  # seconds
    sample_rate = 16000  # minimum for accurate results

    print(f"Recording {duration} seconds...")
    print("Speak normally, then have someone else speak.")

    # Record test audio
    recording = sd.rec(int(duration * sample_rate),
                      samplerate=sample_rate,
                      channels=1,
                      dtype='int16')
    sd.wait()

    # Save test file
    with wave.open('mic_test.wav', 'wb') as wf:
        wf.setnchannels(1)
        wf.setsampwidth(2)
        wf.setframerate(sample_rate)
        wf.writeframes(recording.tobytes())

    print("Test saved as mic_test.wav")
    print("Check audio quality before proceeding")

test_microphone_quality()

‍



Your microphone setup should capture these audio characteristics: each speaker's voice should be distinct, background noise from air conditioning and fans should be minimized, volume levels should be consistent from different classroom positions, and echo from walls and surfaces should be avoided.

Configure Python recording environment

Start by installing the Python packages you need for recording and processing audio. Your environment needs libraries for audio capture and API communication with speech-to-text services.

pip install assemblyai pyaudio numpy sounddevice requests python-dotenv

Create a project folder structure that organizes your coded:

lecture-capture/
├── .env                 # Store your API key here
├── config.py           # Audio settings
├── recorder.py         # Recording functions
├── processor.py        # Speaker diarization
├── captions.py         # Caption generation
└── recordings/         # Audio files

Set up your configuration file to manage recording parameters:

# config.py
import os
from dotenv import load_dotenv

load_dotenv()

class AudioConfig:
    # Recording quality for speaker diarization
    SAMPLE_RATE = 16000
    CHANNELS = 1
    CHUNK_SIZE = 1024
    AUDIO_FORMAT = 'int16'

    # API key for speech processing
    ASSEMBLYAI_API_KEY = os.getenv('ASSEMBLYAI_API_KEY')

    # File organization
    RECORDINGS_DIR = 'recordings'

    # Default lecture length
    DEFAULT_DURATION = 3600  # 1 hour

‍


Create your main recording module:

# recorder.py
import pyaudio
import wave
import threading
from datetime import datetime
from config import AudioConfig
import os

class LectureRecorder:
    def __init__(self):
        self.audio = pyaudio.PyAudio()
        self.stream = None
        self.frames = []
        self.recording = False

        # Create recordings directory
        os.makedirs(AudioConfig.RECORDINGS_DIR, exist_ok=True)

    def start_recording(self, duration=None):
        """Begin recording classroom audio"""
        self.recording = True
        self.frames = []

        # Set up audio stream
        self.stream = self.audio.open(
            format=pyaudio.paInt16,
            channels=AudioConfig.CHANNELS,
            rate=AudioConfig.SAMPLE_RATE,
            input=True,
            frames_per_buffer=AudioConfig.CHUNK_SIZE,
            stream_callback=self._audio_callback
        )

        print("Recording started...")
        self.stream.start_stream()

        # Auto-stop after duration if specified
        if duration:
            threading.Timer(duration, self.stop_recording).start()
            print(f"Will stop automatically after {duration/60:.1f} minutes")

    def _audio_callback(self, in_data, frame_count, time_info, status):
        """Handle incoming audio data"""
        if self.recording:
            self.frames.append(in_data)
        return (in_data, pyaudio.paContinue)

    def stop_recording(self):
        """Stop recording and save the audio file"""
        if not self.recording:
            return None

        self.recording = False
        self.stream.stop_stream()
        self.stream.close()

        # Create filename with timestamp
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"{AudioConfig.RECORDINGS_DIR}/lecture_{timestamp}.wav"

        # Save audio to file
        with wave.open(filename, 'wb') as wf:
            wf.setnchannels(AudioConfig.CHANNELS)
            wf.setsampwidth(self.audio.get_sample_size(pyaudio.paInt16))
            wf.setframerate(AudioConfig.SAMPLE_RATE)
            wf.writeframes(b''.join(self.frames))

        print(f"Recording saved: {filename}")
        print(f"Duration: {len(self.frames) * AudioConfig.CHUNK_SIZE / AudioConfig.SAMPLE_RATE:.1f} seconds")

        return filename

    def __del__(self):
        if hasattr(self, 'audio'):
            self.audio.terminate()

Implement async speaker diarization pipeline

Speaker diarization is the process of identifying "who spoke when" in your audio recordings. This step processes your recorded classroom audio to create timestamped transcripts with speaker labels.

# processor.py
import assemblyai as aai
from config import AudioConfig
import json

class SpeakerProcessor:
    def __init__(self):
        # Set up AssemblyAI for speech processing
        aai.settings.api_key = AudioConfig.ASSEMBLYAI_API_KEY
        self.transcriber = aai.Transcriber()

    def identify_speakers(self, audio_file_path, expected_speakers=None):
        """Process lecture audio with speaker diarization

        Args:
            audio_file_path: Path to WAV file
            expected_speakers: Tuple of (min, max) expected speakers. For full
                lectures (>10 min), the API default max is 30. For short clips
                (<10 min), the default max is 10. Pass explicit values if you
                know your classroom size.
        """
        print(f"Processing {audio_file_path} for speaker diarization...")

        # Build speaker_options
        speaker_options = {}
        if expected_speakers:
            speaker_options['min_speakers_expected'] = expected_speakers[0]
            speaker_options['max_speakers_expected'] = expected_speakers[1]

        # Configure transcription settings
        config = aai.TranscriptionConfig(
            speaker_labels=True,          # Enable speaker diarization
            speaker_options=aai.speaker_options(**speaker_options) if speaker_options else None,
            language_detection=True,      # Auto-detect language
            punctuate=True,              # Add punctuation
            format_text=True             # Clean up formatting
        )

        # Process the audio (blocking call)
        print("Processing audio... This may take a few minutes for long lectures.")
        transcript = self.transcriber.transcribe(
            audio_file_path,
            config=config
        )

        if transcript.status == aai.TranscriptStatus.error:
            raise Exception(f"Processing failed: {transcript.error}")

        return self._format_speaker_results(transcript)

    def _format_speaker_results(self, transcript):
        """Format results with speaker labels and timestamps"""
        results = {
            'transcript_id': transcript.id,
            'audio_duration_seconds': transcript.audio_duration / 1000,
            'speakers_detected': [],
            'speaker_segments': []
        }

        # Process each speaking segment
        for utterance in transcript.utterances:
            speaker_label = f"Speaker {utterance.speaker}"

            # Add segment with speaker info
            results['speaker_segments'].append({
                'speaker': speaker_label,
                'text': utterance.text,
                'start_time_ms': utterance.start,
                'end_time_ms': utterance.end,
                'confidence': utterance.confidence
            })

            # Track unique speakers
            if speaker_label not in results['speakers_detected']:
                results['speakers_detected'].append(speaker_label)

        print(f"Found {len(results['speakers_detected'])} speakers")
        print(f"Generated {len(results['speaker_segments'])} speaking segments")

        return results

    def save_transcript(self, results, output_file):
        """Save diarized transcript to JSON"""
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(results, f, indent=2, ensure_ascii=False)
        print(f"Transcript saved: {output_file}")
        return output_file


A note on the speaker_options parameter: the API defaults work well for most lectures, but if you're seeing speakers being incorrectly merged or over-split, you can tune behavior with short_file_diarization_method ("deliberate" | "balanced" | "conservative" | "aggressive") and speaker_labels_model ("standard" | "experimental"):

# For recordings showing diarization quality issues, add these to speaker_options:
speaker_options = {
    'min_speakers_expected': 2,
    'max_speakers_expected': 30,       # Use 30 for typical full-length lectures
    'short_file_diarization_method': 'deliberate',   # default; try 'balanced' for fast-paced discussions
    'speaker_labels_model': 'experimental'           # try if standard produces splitting errors
}

‍

A note on the speaker_options parameter: the API defaults work well for most lectures, but if you're seeing speakers being incorrectly merged or over-split, you can tune behavior with short_file_diarization_method ("deliberate" | "balanced" | "conservative" | "aggressive") and speaker_labels_model ("standard" | "experimental"}:

# For recordings showing diarization quality issues, add these to speaker_options:
speaker_options = {
    'min_speakers_expected': 2,
    'max_speakers_expected': 30,       # Use 30 for typical full-length lectures
    'short_file_diarization_method': 'deliberate',   # default; try 'balanced' for fast-paced discussions
    'speaker_labels_model': 'experimental'           # try if standard produces splitting errors
}

Now create a main script to run everything:

# main.py
from recorder import LectureRecorder
from processor import SpeakerProcessor

def main():
    print("Lecture Capture System with Speaker Diarization")
    print("-" * 50)

    # Initialize components
    recorder = LectureRecorder()
    processor = SpeakerProcessor()

    # Get recording duration from user
    try:
        duration_input = input("Enter recording duration in minutes (press Enter for 60): ")
        duration_minutes = int(duration_input) if duration_input else 60
        duration_seconds = duration_minutes * 60
    except ValueError:
        duration_seconds = 3600  # Default to 1 hour

    try:
        # Start recording
        recorder.start_recording(duration=duration_seconds)

        # Wait for recording to finish
        input("Press Enter to stop recording early...\n")

        # Save the recording
        audio_file = recorder.stop_recording()

        if audio_file:
            # Process for speaker diarization
            # For full lectures (>10 min), default max speakers is 30.
            # Pass expected_speakers=(min, max) to constrain if you know class size.
            results = processor.identify_speakers(audio_file)

            # Save transcript
            transcript_file = audio_file.replace('.wav', '_transcript.json')
            processor.save_transcript(results, transcript_file)

            # Show summary
            print(f"\nProcessing complete!")
            print(f"Speakers identified: {len(results['speakers_detected'])}")
            print(f"Total duration: {results['audio_duration_seconds']/60:.1f} minutes")

        else:
            print("No recording was saved.")

    except KeyboardInterrupt:
        print("\nRecording stopped by user")
        if recorder.recording:
            audio_file = recorder.stop_recording()

    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

Key aspects of this speaker diarization approach: your system uploads the audio file and waits for results rather than processing in real-time (async); cloud-based AI models deliver higher accuracy than local processing for speaker diarization; the API handles punctuation, capitalization, and text cleanup automatically; and for full-length lectures (over 10 minutes), the API's default max speaker range covers up to 30 speakers without any configuration needed.

Real-time streaming diarization for live lectures

The async approach above processes a complete recording file and delivers the highest accuracy. But for live classroom use—displaying captions as the professor speaks, or providing real-time accessibility support—AssemblyAI's Universal-3 Pro Streaming model also supports speaker diarization directly in the stream.

Note: Streaming diarization is currently in public beta. It is actively scaling infrastructure, and behavior may change as improvements continue. Use it for live captioning and real-time accessibility use cases, but validate accuracy on your specific audio before relying on it for production workflows.

Parameters for enabling real-time speaker diarization:

# Streaming diarization parameters (WebSocket session setup)
session_config = {
    "speech_model": "u3-rt-pro",
    "speaker_labels": True,
    "format_turns": True   # Recommended: groups consecutive words from the same speaker into turns
}

‍

Each transcript response will include a speaker_label field ("Speaker A", "Speaker B", etc.) alongside the transcribed text. One edge case to be aware of: turns under 1 second in length will be labeled as "unknown" rather than assigned a speaker—this is expected behavior in fast back-and-forth exchanges.

Recent improvements to streaming diarization include a 56% reduction in phantom speaker detections (where the model incorrectly creates extra speaker labels) and a 4 percentage point improvement in diarization error rate on 2-speaker conversations. This makes it increasingly viable for standard classroom scenarios with a clear professor-student dynamic.

For live classroom captioning using the streaming endpoint, see the Streaming Diarization documentation.

Generate speaker-attributed captions

Converting your speaker diarization results into caption formats makes your content accessible across different platforms. WebVTT format works with most video players and learning management systems:

# captions.py
import json
from datetime import timedelta

class CaptionGenerator:

    def create_webvtt_captions(self, transcript_file, output_file):
        """Generate WebVTT captions with speaker labels"""
        # Load the transcript
        with open(transcript_file, 'r', encoding='utf-8') as f:
            transcript = json.load(f)

        # Start WebVTT file
        webvtt_content = ["WEBVTT\n\n"]

        # Add each speaking segment as a caption
        for i, segment in enumerate(transcript['speaker_segments'], 1):
            # Format timestamps for WebVTT
            start_time = self._milliseconds_to_webvtt(segment['start_time_ms'])
            end_time = self._milliseconds_to_webvtt(segment['end_time_ms'])

            # Add caption entry
            webvtt_content.append(f"{i}\n")
            webvtt_content.append(f"{start_time} --> {end_time}\n")
            webvtt_content.append(f"<v {segment['speaker']}>{segment['text']}\n\n")

        # Save WebVTT file
        with open(output_file, 'w', encoding='utf-8') as f:
            f.writelines(webvtt_content)

        print(f"WebVTT captions saved: {output_file}")
        return output_file

    def _milliseconds_to_webvtt(self, milliseconds):
        """Convert milliseconds to WebVTT timestamp format (HH:MM:SS.mmm)"""
        total_seconds = milliseconds / 1000
        hours = int(total_seconds // 3600)
        minutes = int((total_seconds % 3600) // 60)
        seconds = total_seconds % 60

        return f"{hours:02d}:{minutes:02d}:{seconds:06.3f}"

    def create_srt_captions(self, transcript_file, output_file):
        """Generate SRT captions as an alternative format"""
        with open(transcript_file, 'r', encoding='utf-8') as f:
            transcript = json.load(f)

        srt_lines = []

        for i, segment in enumerate(transcript['speaker_segments'], 1):
            # Format timestamps for SRT
            start = self._milliseconds_to_srt(segment['start_time_ms'])
            end = self._milliseconds_to_srt(segment['end_time_ms'])

            # Add SRT entry
            srt_lines.append(f"{i}\n")
            srt_lines.append(f"{start} --> {end}\n")
            srt_lines.append(f"[{segment['speaker']}] {segment['text']}\n\n")

        with open(output_file, 'w', encoding='utf-8') as f:
            f.writelines(srt_lines)

        print(f"SRT captions saved: {output_file}")
        return output_file

    def _milliseconds_to_srt(self, milliseconds):
        """Convert to SRT timestamp format (HH:MM:SS,mmm)"""
        td = timedelta(milliseconds=milliseconds)
        hours = td.seconds // 3600
        minutes = (td.seconds % 3600) // 60
        seconds = td.seconds % 60
        ms = td.microseconds // 1000

        return f"{hours:02d}:{minutes:02d}:{seconds:02d},{ms:03d}"

    def create_searchable_transcript(self, transcript_file, output_file):
        """Generate a text file organized by speaker for easy searching"""
        with open(transcript_file, 'r', encoding='utf-8') as f:
            transcript = json.load(f)

        # Group content by speaker
        speaker_content = {}
        for segment in transcript['speaker_segments']:
            speaker = segment['speaker']
            if speaker not in speaker_content:
                speaker_content[speaker] = []
            speaker_content[speaker].append(segment['text'])

        # Create searchable text file
        with open(output_file, 'w', encoding='utf-8') as f:
            f.write("LECTURE TRANSCRIPT WITH SPEAKER DIARIZATION\n")
            f.write("=" * 50 + "\n\n")

            # Timeline view
            f.write("TIMELINE VIEW:\n")
            f.write("-" * 20 + "\n")
            for segment in transcript['speaker_segments']:
                timestamp = self._milliseconds_to_readable(segment['start_time_ms'])
                f.write(f"[{timestamp}] {segment['speaker']}: {segment['text']}\n")

            # Speaker summary
            f.write(f"\n\nSPEAKER SUMMARY:\n")
            f.write("-" * 20 + "\n")
            for speaker, content in speaker_content.items():
                f.write(f"\n{speaker}:\n")
                f.write("\n".join(content))
                f.write("\n")

        print(f"Searchable transcript saved: {output_file}")
        return output_file

    def _milliseconds_to_readable(self, milliseconds):
        """Convert to readable time format (MM:SS)"""
        total_seconds = int(milliseconds / 1000)
        minutes = total_seconds // 60
        seconds = total_seconds % 60
        return f"{minutes:02d}:{seconds:02d}"

‍



Update your main script to generate captions:

from captions import CaptionGenerator

# After saving transcript, add:
caption_gen = CaptionGenerator()

# Generate different caption formats
base_filename = audio_file.replace('.wav', '')

# WebVTT for web players and LMS systems
webvtt_file = f"{base_filename}.vtt"
caption_gen.create_webvtt_captions(transcript_file, webvtt_file)

# SRT for video editing software
srt_file = f"{base_filename}.srt"
caption_gen.create_srt_captions(transcript_file, srt_file)

# Searchable text for study purposes
text_file = f"{base_filename}_searchable.txt"
caption_gen.create_searchable_transcript(transcript_file, text_file)

print("All formats generated successfully!")

‍

These caption formats serve different purposes: WebVTT (.vtt) works with HTML5 video players and most learning management systems; SRT (.srt) is compatible with video editing software and media players; and the searchable text (.txt) allows students to search for specific topics or speakers.

Technical requirements and compliance considerations

Building a compliant lecture capture system requires attention to audio quality, privacy regulations, and accessibility standards.

You need specific audio quality standards for reliable speaker diarization: 16kHz sample rate minimum (44.1kHz recommended for best results), 16-bit depth or higher for voice clarity, signal-to-noise ratio above 15dB to distinguish speakers clearly, and consistent volume levels from different classroom positions.

Privacy compliance shapes how you handle classroom recordings. Key frameworks to be aware of: FERPA (US) protects students' educational records and restricts unauthorized disclosure—this means you should not create records that identify individual students by voice without appropriate consent and institutional authorization. ADA and Section 508 (for federal institutions) require accessible content formats, which speaker-labeled captions help satisfy. GDPR (EU) requires lawful basis and data minimization for processing identifiable personal data, including voice recordings.

Here's what you should implement for compliance:

AssemblyAI processes audio securely and can work with institutions that need Business Associate Agreements or specific data handling arrangements for enhanced privacy compliance. Store API keys using environment variables rather than hard-coding them in source code.

For accessibility, speaker-labeled captions created with this approach meet Section 508 and ADA guidelines for captioned content. For real-time accessibility during live lectures, the streaming diarization option discussed above provides live captions during class rather than only post-lecture.

Your implementation should include these privacy protections: store API keys in .env files, not source code; ensure all API calls use encrypted connections (HTTPS); keep audio files on your servers and process intentionally rather than automatically; and use generic speaker labels ("Speaker A", "Speaker B") rather than student names or identifiers.

Final words

This lecture capture system combines quality audio recording with speaker diarization to create accessible, searchable educational content. The Python-based approach processes classroom recordings asynchronously, sending audio files to speech-to-text APIs that return detailed transcripts with speaker labels and timestamps. For live classroom use, the streaming diarization option (currently in public beta) delivers speaker labels in real time with the same Universal-3 Pro model.

AssemblyAI's Voice AI platform delivers the speaker diarization that makes this system work in real classroom environments—handling background noise, overlapping speech, and varying microphone distances. For full-length lectures, the API's updated defaults (max 30 speakers for files over 10 minutes) handle typical classroom sizes without configuration. When you hit diarization quality issues in specific recordings, the short_file_diarization_method and speaker_labels_model tuning options give you direct control over the underlying model behavior.

Frequently asked questions

Which Python packages do I need to install for lecture capture with speaker diarization?

Install these essential packages: assemblyai for speech processing, pyaudio for recording audio, sounddevice as an alternative recording option, python-dotenv for environment variables, and requests for file handling.

How accurate is speaker diarization in typical classroom recordings?

Speaker diarization accuracy depends on audio quality, background noise, number of speakers, and microphone placement. Results improve with clearer audio separation between speakers and proper microphone positioning. If you see speakers being incorrectly merged or over-split, use the short_file_diarization_method and speaker_labels_model parameters in speaker_options to tune behavior.

What's the right max_speakers_expected value for a lecture?

For full-length lectures (over 10 minutes), the API default max is 30 speakers—appropriate for most classroom sizes. For short clips under 10 minutes, the default max is 10. You can pass explicit min_speakers_expected and max_speakers_expected values in speaker_options if you know your class size, but for most recordings the defaults work well.

Can I process existing lecture recordings that I already have?

Yes, any audio file with 16kHz sample rate or higher can be processed for speaker diarization using the same Python approach, regardless of when it was originally recorded.

What minimum audio quality do I need for reliable speaker diarization results?

Your recordings need at least 16kHz sample rate with 16-bit depth, signal-to-noise ratio above 15dB, and clear voice separation between speakers for consistent results.

Is real-time speaker diarization available for live lectures?

Yes. Universal-3 Pro Streaming supports real-time speaker diarization with speaker_labels: true and format_turns: true. This is currently in public beta—results are strong for 2-speaker scenarios and standard classroom recordings, with streaming accuracy improving as the model is tuned. Check the Streaming Diarization documentation for current limitations.

How should I handle student privacy when using speaker diarization in classrooms?

Use generic speaker labels like "Speaker A" instead of student names, obtain written recording consent, process audio through secure APIs, and implement automatic deletion policies for recorded content. Be aware that FERPA restricts unauthorized disclosure of student educational records—consult your institution's privacy office before deploying any system that creates persistent, identifiable records of student voices.