pyannote.audio is an open-source Python toolkit for speaker diarization — the task of answering "who spoke when" in an audio recording. Maintained by the pyannote team and released under the MIT license, it has grown past 10,000 GitHub stars and become the de facto community standard for the diarization step that sits alongside speech-to-text pipelines. Built on the PyTorch machine-learning framework, it ships with state-of-the-art pretrained models and pipelines hosted on the Hugging Face model hub, and every component can be fine-tuned on your own data for even better performance. ## What Speaker Diarization Solves Automatic speech recognition converts audio into words, but on its own it cannot tell you how many people were talking or which words belong to which person. Speaker diarization fills that gap. pyannote.audio segments a recording into speaker turns, producing timestamped output such as `start=0.2s stop=1.5s speaker_0`, so a raw transcript can be reorganized into a readable, attributed conversation. This is the missing layer that turns a wall of transcribed text from a meeting, interview, or call into a structured dialogue. ## The community-1 Pipeline The headline offering is the `community-1` open-source diarization pipeline, loaded through `Pipeline.from_pretrained("pyannote/speaker-diarization-community-1")`. Under the hood it composes the classic building blocks the project is known for: voice activity detection to find speech regions, overlapped-speech detection, neural speaker embeddings, and clustering to group turns by speaker. The pipeline runs locally, can be moved to a GPU with a single `pipeline.to(torch.device("cuda"))` call, and exposes an optional progress hook for long files. Because the models are published on the Hugging Face hub, users accept the model's user conditions and supply an access token before first use. ## Pretrained Models, Fine-Tuning, and Ecosystem pyannote.audio is deliberately modular. Beyond the end-to-end pipeline, it publishes individual pretrained models — voice activity detection, segmentation, speaker embedding — that developers can reuse independently. The Python-first API integrates with pytorch-lightning for multi-GPU training, so teams can fine-tune segmentation or clustering on domain-specific audio (noisy call-center recordings, multi-party meetings, broadcast media) to close the gap on their own benchmarks. Audio decoding relies on torchcodec and ffmpeg, keeping the ingestion path standard and scriptable. ## Open Source Plus a Premium Tier The repository also wires in optional access to pyannoteAI's commercial `precision-2` service for teams that want higher accuracy without maintaining their own models. The two paths share the same API surface — swap the pipeline identifier and supply an API key — which lets projects prototype on the free open-source pipeline and later upgrade specific workloads to the premium engine with minimal code change. ## Trade-offs and Limitations The pretrained pipelines are gated on Hugging Face, so first-time setup requires accepting user conditions and creating an access token — a small friction that can trip up fully offline or air-gapped deployments. Diarization remains an inherently hard problem: heavy background noise, many simultaneous speakers, and long stretches of overlapping speech all degrade accuracy, and short audio clips give the clustering stage little to work with. Real-time or streaming diarization is more constrained than the offline batch mode most examples show, and a GPU is strongly recommended for anything beyond short files. ## Who Should Use This pyannote.audio is the natural choice for developers building meeting-transcription tools, podcast and media indexing, call analytics, or any "who-spoke-when" layer to pair with a Whisper-style transcriber, and for researchers who need a fine-tunable, benchmark-grade diarization stack. If your product needs speaker-attributed transcripts and you want a permissively licensed, actively maintained, PyTorch-native foundation, this toolkit is the standard starting point.