Skip to main content Skills Marketplace Descubra e explore skills de IA criadas pela comunidade.
Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.
Mostrar detalhes do prompt Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.
npx skills add https://github.com/foolhardy45/portfolio --skill azure-speech-to-text-rest-pyO comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.
Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.
Baixar Zip Baixando... Ocupações relacionadas SOC
Baseado na classificação ocupacional SOC
name azure-speech-to-text-rest-py description Azure Speech to Text REST API for short audio (Python). Use for simple speech recognition of audio files up to 60 seconds without the Speech SDK. risk unknown source community date_added 2026-02-27
Azure Speech to Text REST API for Short Audio
Simple REST API for speech-to-text transcription of short audio files (up to 60 seconds). No SDK required - just HTTP requests.
Prerequisites
Azure subscription - Create one free Speech resource - Create in Azure Portal Get credentials - After deployment, go to resource > Keys and Endpoint
Environment Variables
AZURE_SPEECH_KEY=<your-speech-resource-key>
AZURE_SPEECH_REGION=<region>
AZURE_SPEECH_ENDPOINT=https://<region>.stt.speech.microsoft.com
Installation
Quick Start import os
import requests
def transcribe_audio (audio_file_path: str , language: str = "en-US" ) -> dict :
"""Transcribe short audio file (max 60 seconds) using REST API."""
region = os.environ["AZURE_SPEECH_REGION" ]
api_key = os.environ["AZURE_SPEECH_KEY" ]
url = f"https://{region} .stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1"
headers = {
"Ocp-Apim-Subscription-Key" : api_key,
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000" ,
"Accept" : "application/json"
}
params = {
"language" : language,
"format" : "detailed"
}
with open (audio_file_path, "rb" ) as audio_file:
response = requests.post(url, headers=headers, params=params, data=audio_file)
response.raise_for_status()
return response.json()
result = transcribe_audio("audio.wav" , "en-US" )
print (result["DisplayText" ])
Audio Requirements Format Codec Sample Rate Notes WAV PCM 16 kHz, mono Recommended OGG OPUS 16 kHz, mono Smaller file size
Maximum 60 seconds of audio
For pronunciation assessment: maximum 30 seconds
No partial/interim results (final only)
Content-Type Headers
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000"
"Content-Type" : "audio/ogg; codecs=opus"
Response Formats
Simple Format (default) params = {"language" : "en-US" , "format" : "simple" }
{
"RecognitionStatus" : "Success" ,
"DisplayText" : "Remind me to buy 5 pencils." ,
"Offset" : "1236645672289" ,
"Duration" : "1236645672289"
}
Detailed Format params = {"language" : "en-US" , "format" : "detailed" }
{
"RecognitionStatus" : "Success" ,
"Offset" : "1236645672289" ,
"Duration" : "1236645672289" ,
"NBest" : [
{
"Confidence" : 0.9052885 ,
"Display" : "What's the weather like?" ,
"ITN" : "what's the weather like" ,
"Lexical" : "what's the weather like" ,
"MaskedITN" : "what's the weather like"
}
]
}
Chunked Transfer (Recommended) For lower latency, stream audio in chunks:
import os
import requests
def transcribe_chunked (audio_file_path: str , language: str = "en-US" ) -> dict :
"""Stream audio in chunks for lower latency."""
region = os.environ["AZURE_SPEECH_REGION" ]
api_key = os.environ["AZURE_SPEECH_KEY" ]
url = f"https://{region} .stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1"
headers = {
"Ocp-Apim-Subscription-Key" : api_key,
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000" ,
"Accept" : "application/json" ,
"Transfer-Encoding" : "chunked" ,
"Expect" : "100-continue"
}
params = {"language" : language, "format" : "detailed" }
def generate_chunks (file_path: str , chunk_size: int = 1024 ):
with open (file_path, "rb" ) as f:
while chunk := f.read(chunk_size):
yield chunk
response = requests.post(
url,
headers=headers,
params=params,
data=generate_chunks(audio_file_path)
)
response.raise_for_status()
return response.json()
Authentication Options
Option 1: Subscription Key (Simple) headers = {
"Ocp-Apim-Subscription-Key" : os.environ["AZURE_SPEECH_KEY" ]
}
Option 2: Bearer Token import requests
import os
def get_access_token () -> str :
"""Get access token from the token endpoint."""
region = os.environ["AZURE_SPEECH_REGION" ]
api_key = os.environ["AZURE_SPEECH_KEY" ]
token_url = f"https://{region} .api.cognitive.microsoft.com/sts/v1.0/issueToken"
response = requests.post(
token_url,
headers={
"Ocp-Apim-Subscription-Key" : api_key,
"Content-Type" : "application/x-www-form-urlencoded" ,
"Content-Length" : "0"
}
)
response.raise_for_status()
return response.text
token = get_access_token()
headers = {
"Authorization" : f"Bearer {token} " ,
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000" ,
"Accept" : "application/json"
}
Query Parameters Parameter Required Values Description languageYes en-US, de-DE, etc.Language of speech formatNo simple, detailedResult format (default: simple) profanityNo masked, removed, rawProfanity handling (default: masked)
Recognition Status Values Status Description SuccessRecognition succeeded NoMatchSpeech detected but no words matched InitialSilenceTimeoutOnly silence detected BabbleTimeoutOnly noise detected ErrorInternal service error
Profanity Handling
params = {"language" : "en-US" , "profanity" : "masked" }
params = {"language" : "en-US" , "profanity" : "removed" }
params = {"language" : "en-US" , "profanity" : "raw" }
Error Handling import requests
def transcribe_with_error_handling (audio_path: str , language: str = "en-US" ) -> dict | None :
"""Transcribe with proper error handling."""
region = os.environ["AZURE_SPEECH_REGION" ]
api_key = os.environ["AZURE_SPEECH_KEY" ]
url = f"https://{region} .stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1"
try :
with open (audio_path, "rb" ) as audio_file:
response = requests.post(
url,
headers={
"Ocp-Apim-Subscription-Key" : api_key,
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000" ,
"Accept" : "application/json"
},
params={"language" : language, "format" : "detailed" },
data=audio_file
)
if response.status_code == 200 :
result = response.json()
if result.get("RecognitionStatus" ) == "Success" :
return result
else :
print (f"Recognition failed: {result.get('RecognitionStatus' )} " )
return None
elif response.status_code == 400 :
print (f"Bad request: Check language code or audio format" )
elif response.status_code == 401 :
print (f"Unauthorized: Check API key or token" )
elif response.status_code == 403 :
print (f"Forbidden: Missing authorization header" )
else :
print (f"Error {response.status_code} : {response.text} " )
return None
except requests.exceptions.RequestException as e:
print (f"Request failed: {e} " )
return None
Async Version import os
import aiohttp
import asyncio
async def transcribe_async (audio_file_path: str , language: str = "en-US" ) -> dict :
"""Async version using aiohttp."""
region = os.environ["AZURE_SPEECH_REGION" ]
api_key = os.environ["AZURE_SPEECH_KEY" ]
url = f"https://{region} .stt.speech.microsoft.com/speech/recognition/conversation/cognitiveservices/v1"
headers = {
"Ocp-Apim-Subscription-Key" : api_key,
"Content-Type" : "audio/wav; codecs=audio/pcm; samplerate=16000" ,
"Accept" : "application/json"
}
params = {"language" : language, "format" : "detailed" }
async with aiohttp.ClientSession() as session:
with open (audio_file_path, "rb" ) as f:
audio_data = f.read()
async with session.post(url, headers=headers, params=params, data=audio_data) as response:
response.raise_for_status()
return await response.json()
result = asyncio.run(transcribe_async("audio.wav" , "en-US" ))
print (result["DisplayText" ])
Supported Languages Code Language en-USEnglish (US) en-GBEnglish (UK) de-DEGerman fr-FRFrench es-ESSpanish (Spain) es-MXSpanish (Mexico) zh-CNChinese (Mandarin) ja-JPJapanese ko-KRKorean pt-BRPortuguese (Brazil)
Best Practices
Use WAV PCM 16kHz mono for best compatibilityEnable chunked transfer for lower latencyCache access tokens for 9 minutes (valid for 10)Specify the correct language for accurate recognitionUse detailed format when you need confidence scoresHandle all RecognitionStatus values in production code
When NOT to Use This API Use the Speech SDK or Batch Transcription API instead when you need:
Audio longer than 60 seconds
Real-time streaming transcription
Partial/interim results
Speech translation
Custom speech models
Batch transcription of many files
Reference Files File Contents references/pronunciation-assessment.md Pronunciation assessment parameters and scoring
When to Use This skill is applicable to execute the workflow or actions described in the overview.
