Most engineering leads integrating Microsoft Teams transcription assume the Graph API will plug in cleanly, then discover in staging that the native stack delivers transcripts only after the meeting ends, hits throttling limits well before the concurrency their product demands, and silently drops accuracy on any speaker who isn't a native English speaker in a quiet room. The fix is not a workaround: it's a different architectural layer entirely.
This guide covers the internal architecture of the Teams transcription stack, shows exactly how to register an Entra app, fetch tokens, and call transcript endpoints, and details when and how to bypass native transcription using custom bots with WebRTC audio extraction routed to our API.
Under the hood: Teams transcription API architecture
Mapping the Teams integration stack
Teams transcription involves several Microsoft services working together: the Teams client handles signaling and UI, the Microsoft Graph API provides data retrieval and management of meeting records and transcripts, and Azure Communication Services or Azure Cognitive Services may be part of the underlying processing pipeline depending on the deployment model. The access model differs at each boundary, so understanding the topology before you write a line of code prevents architectural rework later.
The Microsoft Graph API meeting transcripts documentation confirms a critical constraint: Graph does not support accessing live or partial transcript content while a meeting is in progress. Transcript data becomes available only after the meeting ends and the recording pipeline completes, meaning a delay of several minutes before your application can retrieve anything.
The call record flows through client audio capture, the Teams media plane, cloud processing, storage in the Microsoft 365 tenant, and finally exposure through the Graph API. Each hop adds latency. For post-meeting analytics this is acceptable. For real-time use cases, it rules out the native stack entirely.
Securing Microsoft Teams API tokens
Access to Teams meeting data requires OAuth 2.0 with Microsoft Entra ID using the client credentials flow for application-level access. Use certificate-based credentials in production rather than client secrets, implement token caching (typical token lifetime: 60–90 minutes), and confirm that admin consent is granted for all required scopes before any API call runs.
Choosing between real-time and async
- Async (post-meeting fetch): Call the Graph API after the meeting ends to retrieve the VTT (Web Video Text Tracks) transcript file. Lower infrastructure cost, no bot required during the meeting, but you accept a processing delay. This is the path for meeting summary tools, post-call CRM population, and compliance archiving, where speaker diarization powered by pyannoteAI's Precision-2 delivers accurate speaker attribution in post-processing.
- Real-time (bot-based audio extraction): A custom bot joins the meeting, captures raw audio via the Communications Media SDK over WebRTC, and streams PCM (Pulse Code Modulation) audio to your speech-to-text (STT) engine. Necessary for live captions, agent-assist, and real-time coaching dashboards. Solaria-1 handles real-time streaming with partial transcripts under 103ms and final transcript latency of ~300ms. For speaker attribution in real-time workflows, this can be handled in post-processing for higher accuracy.
Setting up Teams transcription API access
Create your Microsoft Entra app
- Register the application: In the Microsoft Entra admin center, select App registrations and create a new registration. Set the supported account type to match your tenant configuration.
- Configure a certificate: For production, upload the public key of an X.509 certificate under "Certificates and secrets" and store the private key in your secrets manager.
- Note your tenant ID and client ID: Both are required for token requests.
Define Microsoft Teams API scopes
For post-meeting transcript retrieval, your app needs application permissions (not delegated) with admin consent from the target tenant. The exact scopes depend on which permission model you use: organization-wide application permissions or resource-specific consent. OnlineMeetings.Read.All is required for meeting access in both models. For transcript retrieval, use OnlineMeetingTranscript.Read.All under organization-wide permissions or OnlineMeetingTranscript.Read.Chat under resource-specific consent.
OnlineMeetings.Read.All : read online meeting details (required in both permission models)OnlineMeetingTranscript.Read.All : read meeting transcripts (organization-wide application permissions)OnlineMeetingTranscript.Read.Chat : read meeting transcripts (resource-specific consent)
Application permissions grant your app broad access across the organization without requiring a signed-in user, which is necessary for automated pipelines. If your bot also accesses live media streams, Calls.AccessMedia.All is required separately for that capability.
How to fetch your Teams API token
```python
import msal
TENANT_ID = "your-tenant-id"
CLIENT_ID = "your-client-id"
# Certificate-based auth (recommended for production):
# Load your certificate and private key, then use:
# client_credential={"thumbprint": CERT_THUMBPRINT, "private_key": PRIVATE_KEY}
CLIENT_SECRET = "your-client-secret" # use a cert in production
SCOPE = ["https://graph.microsoft.com/.default"]
app = msal.ConfidentialClientApplication(
client_id=CLIENT_ID,
authority=f"https://login.microsoftonline.com/{TENANT_ID}",
client_credential=CLIENT_SECRET,
)
token_response = app.acquire_token_for_client(scopes=SCOPE)
access_token = token_response.get("access_token")
```
Cache the token and refresh before expiry. Hitting the identity endpoint on every Graph API call adds unnecessary overhead and slows your pipeline under load.
Handling real-time meeting events
Subscribe to Microsoft Graph change notifications to trigger workflows when a meeting starts or ends. A webhook subscription to the /communications/onlineMeetings resource delivers event payloads when meeting state changes. Your endpoint must handle validation token challenges during subscription creation, and subscriptions to online meeting resources require proactive renewal before they expire, so build renewal logic into your service from the start.
Automating Teams meeting transcript workflows
Fetch Teams transcripts via REST API
After a meeting ends and transcription processing completes, retrieve the transcript list and then fetch its content:
```python
import requests
MEETING_ID = "your-meeting-id"
headers = {"Authorization": f"Bearer {access_token}"}
# Retrieve the list of transcripts for the meeting
transcripts_endpoint = f"https://graph.microsoft.com/v1.0/me/onlineMeetings/{MEETING_ID}/transcripts"
response = requests.get(transcripts_endpoint, headers=headers)
transcripts = response.json().get("value", [])
if transcripts:
content_url = transcripts[0]["transcriptContentUrl"]
content = requests.get(
f"{content_url}?$format=text/vtt",
headers=headers
).text
```
The transcriptContentUrl field provides the endpoint to retrieve .vtt content. You can request either text/vtt or application/vnd.microsoft.graph.transcript+text via the $format parameter.
Analyzing Teams transcript schema
The Graph API returns a minimal schema. Each transcript object includes id, meetingId, createdDateTime, endDateTime, and transcriptContentUrl. The .vtt content provides utterance text, cue-block start and end timestamps, and a speaker label pulled from the meeting roster.
The native schema does not provide:
- Per-word timestamps (only cue-block utterance-level timing)
- Confidence scores per word or utterance
- Named entity recognition or sentiment data
- Structured JSON output suitable for LLM pipelines
If your downstream system needs to populate CRM fields, generate coaching scores, or feed a summarization model, the native schema forces you to build an enrichment layer on top of an already-imprecise transcript. Every field you extract is only as accurate as the words that made it into that .vtt file.
Diarization for Teams audio streams
Teams' native transcript labels speakers in the .vtt file, but attribution quality drops on overlapping speech and in meetings with more than three or four participants. For post-meeting workflows that demand accurate speaker attribution, routing the raw audio file through our async pipeline gives you diarization powered by pyannoteAI's Precision-2 model. It runs as part of the standard async transcription call, included in the base rate on Starter and Growth plans alongside translation, named entity recognition, and sentiment analysis.
Microsoft Teams transcription limitations
Non-English and multilingual accuracy
Teams supports live transcription with speaker attribution in 28 languages by default. Its broader live-captions feature covers 50+ spoken languages, though meeting organizers can select only 6 languages for simultaneous display (10 with Teams Premium), with additional translation capabilities available for post-meeting transcripts. Accuracy on European and Asian languages in noisy business meetings falls well short of the English baseline. When a speaker shifts languages mid-sentence, the native transcript either drops words or produces output in the wrong language entirely.
Solaria-1 covers a broad range of supported languages, with true mid-conversation code-switching across both real-time and async modes. Spoke, a meeting transcription tool, processes 27,000+ meeting hours weekly on our API while serving European markets.
For European business audio in EN, FR, DE, ES, and IT, Solaria-3 is our most accurate model: it ranks #1 on Switchboard, ahead of AssemblyAI, ElevenLabs, Deepgram, Mistral, and Speechmatics, on real customer recordings in EN and core European languages.
Real-time transcription lag and rate limits
Teams' built-in live captions operate with a lag of several seconds in practice, and they offer no programmatic access to partial transcripts, making it impossible to feed them to an inference pipeline without additional middleware. Solaria-1's real-time streaming delivers partial transcripts in under 103ms and final transcript latency of ~300ms.
On the rate-limiting front, Microsoft Graph throttling documentation confirms that when a throttling threshold is exceeded, the API returns HTTP 429 with a Retry-After header. Online meetings, call records, and transcripts share the same Teams workload throttling bucket, and Microsoft does not expose these limits for tenant-level increase requests. Parse the Retry-After value from the response header and back off for exactly that duration rather than using exponential backoff alone. A practical checklist for 50+ concurrent meetings:
- Distribute API calls across time windows rather than batching at the top of the hour
- Cache transcript IDs and content separately to avoid refetching
- Use change notifications to trigger retrieval only when transcripts are ready, rather than polling
Evaluating custom STT for specialized use cases
Assessing transcription WER for Teams API
Native Teams transcription WER varies significantly with audio conditions: high single digits in clean, quiet office audio with native English speakers, rising into the mid-twenties in far-field, noisy, or heavily accented speech, the conditions that define most production deployments. That error rate compounds across every downstream system: a wrong name in a transcript becomes a wrong name in your CRM entry, your coaching scorecard, and your AI summary before any human reviews it.
For comparison, Solaria-3 achieves 9.6% WER on real customer audio, a 26% improvement over Solaria-1 on the same dataset.
Optimizing STT for domain glossaries
Product names, internal project names, and industry-specific acronyms are consistently high-error zones in any generic STT model. Our custom vocabulary feature lets you supply a glossary of terms with phonetic hints so the model prioritizes your terminology over phonetically similar common words. For Teams integrations in legal, medical, or financial services, this has a measurable impact on downstream entity extraction accuracy.
Unit economics of managed STT APIs
Native Teams transcription appears free, but that calculation ignores engineering hours required to build accuracy remediation, the cost of downstream errors in CRM data and AI summaries, and the complete absence of audio intelligence features. The following table compares the all-in cost profile across approaches:
| Provider |
Async pricing |
Diarization |
Language coverage |
Add-on fees |
| Gladia (Starter) |
$0.61/hr |
Included |
100+ languages |
None on Starter/Growth |
| Gladia (Growth) |
From $0.20/hr |
Included |
100+ languages |
None |
| Deepgram |
$0.46/hr (Nova-3 base, pre-recorded) |
Included |
45+ languages |
Varies by feature |
| AssemblyAI |
$0.15/hr base |
Add-on |
English-primary |
Yes, add-ons stack |
| Speechmatics |
From $0.24/hr on Pro |
Included |
56+ languages and dialects |
Bolt-ons for translation, chapters, topics, sentiment |
| ElevenLabs (Scribe v2) |
From $0.22/hr |
Included |
90+ languages |
None found |
Per-hour pricing based on audio duration makes cost modeling straightforward. At 10,000 hours/month on our Growth plan with diarization, sentiment, and NER included, the bill is predictable before you run a single meeting. The same volume on a provider that charges diarization and sentiment separately costs meaningfully more once add-ons stack. The pricing table above shows where those fees apply by provider. See our current pricing page for exact per-hour rates by plan.
Ensuring data residency and compliance
On Growth and Enterprise plans, customer audio is never used to retrain our models, and no opt-out action or contract clause is required. On the Starter plan, data can be used for model training by default. Our compliance hub covers SOC 2 Type II, ISO 27001, HIPAA, GDPR, and PCI DSS certifications. Our infrastructure runs on dedicated cloud clusters across EU and US regions, configurable to your geographic footprint to satisfy GDPR data residency requirements.
Integrating external speech engines with Teams
Extracting audio via the Communications Media SDK
For real-time audio access, you need a custom bot built on the Microsoft Graph Communications Client SDK. The bot joins the meeting as a participant, registers for media access using Calls.AccessMedia.All, and receives raw PCM audio frames from the Teams media plane over WebRTC.
Key infrastructure requirements:
- The bot must run on Azure VMs or AKS with a public IP and open media ports for RTP/RTCP traffic (typically UDP ports 49152–65535). Local or NAT-ed deployments cannot receive media from the Teams media plane.
- As a production best practice, build in disconnection recovery logic and design your service to manage concurrent instances across parallel meetings. Microsoft's Teams bot documentation covers media handling and pinned VM instances, but rejoin logic and concurrency management are implementation-level responsibilities, not platform-enforced requirements.
Forwarding Teams audio to our API
Once your bot is receiving PCM audio frames, you have two routing options depending on whether you need real-time or post-meeting output.
Real-time route via WebSocket:
```python
import asyncio
import aiohttp
import websockets
import json
GLADIA_API_KEY = "your-gladia-api-key"
async def init_gladia_session():
config = {
"encoding": "wav/pcm",
"sample_rate": 16000,
"bit_depth": 16,
"channels": 1,
"model": "solaria-1",
"language_config": {
"languages": [], # empty list enables automatic language detection
"code_switching": True,
},
}
headers = {"x-gladia-key": GLADIA_API_KEY}
async with aiohttp.ClientSession() as session:
async with session.post(
"https://api.gladia.io/v2/live",
json=config,
headers=headers,
) as response:
data = await response.json()
return data["url"] # wss://api.gladia.io/v2/live?token=...
async def stream_to_gladia(audio_chunk_generator):
ws_url = await init_gladia_session()
async with websockets.connect(ws_url) as ws:
async def send_audio():
async for chunk in audio_chunk_generator:
await ws.send(chunk) # raw bytes; Gladia also accepts base64-encoded JSON
async def receive_transcripts():
async for message in ws:
data = json.loads(message)
print(data)
await asyncio.gather(send_audio(), receive_transcripts())
```
Async route via REST (post-meeting): Download the meeting recording to a URL or local file, then initiate an async transcription with diarization and any audio intelligence features enabled.
For teams building real-time transcription into React applications, our TypeScript SDK walkthrough covers the WebSocket integration pattern. Our SDK overview gives a broader introduction to the API surface.
Before starting any integration work, running npx skills add gladiaio/skills in your repository gives Cursor or Claude Code accurate context on our API and SDK surface, including the pre-recorded transcription skill and real-time streaming skill, so your coding agent produces correct parameters rather than hallucinated ones.
Mapping external transcripts to Teams
Our async response includes word-level timestamps and speaker labels. To align this output back to Teams meeting metadata, map two things:
- Participant identity: Match diarization speaker IDs (SPEAKER_01, SPEAKER_02, etc.) to Teams participant display names using the meeting roster from the Graph API.
- Timestamp alignment: Use the meeting start time from the call record (
startDateTime) as the epoch and offset word-level timestamps to generate absolute UTC timestamps that match the Teams event log.
Once your transcript has accurate speaker attribution and absolute timestamps, named entity extraction can be attributed to the correct participant for CRM population.
Assessing internal vs managed Teams pipelines
True cost of Teams API integration
Building and maintaining custom Teams bots involves more ongoing cost than the initial integration sprint suggests. The following matrix captures the full TCO picture:
| Dimension |
Native Graph API |
Self-hosted STT |
Gladia managed API |
| Setup time |
Low (days) |
High (weeks) |
Low (hours to days) |
| Infrastructure cost |
Low |
High (GPU, ops) |
Per-hour usage |
| DevOps overhead |
Low |
High (model updates, scaling) |
Minimal |
| Accuracy (real-world audio) |
High single digits to mid-twenties WER depending on audio conditions |
10%+ WER |
Solaria-3 for European business audio, Solaria-1 for real-time and 100+ languages |
| Diarization |
Basic |
Manual integration |
Included (async) |
| Compliance |
Microsoft-controlled |
Self-managed |
SOC 2, GDPR, HIPAA |
Teams moving off self-hosted STT setups eliminate recurring overhead across model versioning, GPU provisioning, and stability management. Aircall, for example, cut transcription time by 95% (from 30 minutes to 1.5 minutes per call) after switching to our API and now processes over 1M calls per week.
Criteria for choosing an STT partner
A concrete evaluation checklist for engineering leads assessing STT vendors for Teams integrations:
- WER on your actual audio: Run your own audio through the vendor's API. The blind comparison tool is a fun and useful way to test your own audio across six providers with ELO-ranked results and no integration work required. It removes brand bias and works as a gut check, but follow it with a reproducible benchmark on your full audio distribution before making a production commitment.
- Language coverage depth: Does the vendor cover your actual language distribution, including lower-resource languages in your user base?
- Diarization quality and pricing: Is speaker attribution included or metered separately? What's the DER on multi-speaker audio?
- Data retraining policy: Does the vendor use your audio to train models by default, and does that default change at each pricing tier?
- Compliance certifications: SOC 2 Type II, ISO 27001, GDPR, and HIPAA should all be in the vendor's documentation, not just their marketing page.
- Pricing at scale: Model costs at 1x, 5x, and 10x your current volume with all features enabled.
"The API is straightforward and well documented, making integration into our internal tools quick and easy." - Faes W. on G2
Validating production audio quality
Set up a continuous evaluation pipeline that runs a sample of production transcripts against human-reviewed ground truth at regular intervals. Track WER by language, meeting type, and audio quality tier (clean office audio vs. speakerphone vs. noisy open floor), and alert on WER regression above your production threshold before users churn from accuracy degradation.
For Teams-specific evaluation, include meetings with three or more participants (where diarization matters most), meetings in non-primary languages, and recordings from mobile clients, which introduce more compression artifacts than desktop clients. The multilingual customer support guide covers language-specific accuracy benchmarking approaches.
Once you've validated the approach on your architecture, start with €50 in free credits and have your Teams integration in production in less than a day.
FAQs
What languages does Teams transcription support?
Teams supports live transcription with speaker attribution in 28 languages by default. Its live-captions feature covers 50+ spoken languages, though meeting organizers can select only 6 languages for simultaneous display (10 with Teams Premium). Post-meeting transcript translation extends to a wide range of languages if enabled by an IT admin, but that is a separate capability from live transcription. No publicly available language-specific WER figures from Microsoft were found for Teams transcription, and accuracy on European and Asian languages in noisy business environments falls well below the English baseline.
How do I retrieve archived Teams meeting transcripts?
Call the Graph API endpoint /onlineMeetings/{meetingId}/transcripts using the OnlineMeetingTranscript.Read.All application permission after the meeting ends. The response includes a transcriptContentUrl you fetch in .vtt or plain text format.
How accurate is native Teams transcription?
Native Teams transcription WER depends heavily on audio conditions. In clean office audio with native English speakers, error rates sit in the high single digits. In far-field, noisy, or multi-speaker environments, or with regional accents and mid-conversation language switches, error rates climb into the mid-twenties. No Microsoft-published WER figure for Teams transcription exists to cite a fixed number against.
What WER should I expect in noisy multi-speaker conditions?
In noisy, multi-speaker environments, native Teams transcription shows high insertion and deletion rates from cross-talk and background noise. These are the conditions that drive the highest error rates. Expect WER toward the mid-twenties or higher, versus high single digits in clean, quiet office audio with native English speakers. No Microsoft-published WER figure exists to anchor a fixed number against.
Can I use the Teams API with third-party STT?
Yes. Extract raw audio from a Teams meeting using a custom WebRTC bot built on the Microsoft Graph Communications Client SDK, then route that PCM audio stream to any external STT engine via WebSocket for real-time processing or REST for async processing. Our API accepts both modes and returns structured JSON output with word-level timestamps, speaker labels, and audio intelligence features included at the base rate.
Key terms glossary
Word Error Rate (WER): The standard metric for transcription accuracy, calculated by dividing the sum of insertions, deletions, and substitutions by the total number of words spoken. Lower is better.
Diarization Error Rate (DER): The metric for speaker attribution accuracy, measuring the percentage of time that speaker identities are incorrectly assigned in a transcript.
Code-switching: Alternating between two or more languages or dialects within a single conversation, a common pattern in multilingual business meetings that most STT APIs handle poorly.
PCM (Pulse Code Modulation): A digital representation of analog audio signals, commonly used for uncompressed audio transmission in real-time systems like WebRTC.
STT (Speech-to-Text): The technology that converts spoken audio into written text, also known as automatic speech recognition (ASR).
NER (Named Entity Recognition): The process of identifying and classifying key information in text such as names, organizations, locations, dates, and other specific entities.
Microsoft Graph API: Microsoft's REST API platform providing unified access to data across Microsoft 365 services, including Teams meeting metadata, call records, and post-meeting transcripts.
WebRTC (Web Real-Time Communication): An open-source protocol enabling real-time audio and video communication. In the Teams context, it is the media transport layer a custom bot uses to capture raw audio from a live meeting.
