Como transcrever áudios com a API Whisper da OpenAI

Já pensou em transformar áudios em texto de forma simples e precisa? Com o Whisper da OpenAI, isso é possível. Ele é multilíngue, funciona bem mesmo com áudios imperfeitos e mantém boa acurácia em diferentes sotaques.

Neste tutorial, você vai aprender a transcrever áudios em vários cenários: arquivos MP3/WAV, vídeos MP4 e até capturas do microfone. 

Se você é iniciante em Python, não se preocupe! Vamos explicar tudo de forma simples e detalhada. Vamos lá?

O que é Whisper? 

O Whisper é um modelo de Reconhecimento Automático de Fala (ASR – Automatic Speech Recognition) desenvolvido pela OpenAI. Na prática, ele é uma tecnologia de speech-to-text (de fala para texto) usado para transformar áudio em texto com alta precisão, mesmo quando a gravação não está perfeita.

O modelo foi treinado com 680 mil horas de áudio real, em múltiplos idiomas, sotaques, ambientes ruidosos e situações práticas. Por isso, ele consegue lidar bem com ruído de fundo, variações de pronúncia e termos técnicos, sem que você precise ajustar o modelo.

Seu funcionamento é simples: você pode enviar praticamente qualquer gravação, como reunião, entrevista, podcast ou vídeo MP4, e recebe uma transcrição de boa qualidade.

Whisper vs. gpt-4o-transcribe: qual escolher?

A OpenAI oferece mais de uma opção para transcrição. O whisper-1 é apenas uma delas. Ele é o modelo clássico e especializado em speech-to-text. Esse modelo funciona muito bem em situações e tem um bom desempenho em relação a sotaques, ruído e termos técnicos.

Além disso, ele oferece um ótimo custo-benefício, estabilidade e ampla documentação. Por esse motivo, ele é a escolha mais recomendada para a maioria dos casos de uso.

Outra opção é o gpt-4o-transcribe, uma alternativa mais recente, baseada no modelo GPT-4o. Ele tem menos erros, entende melhor diferentes idiomas e tende a entregar resultados mais limpos. 

Se você estiver em dúvida sobre qual usar, a escolha padrão deve ser o gpt-4o-transcribe, já que ele é mais moderno e oferece a melhor qualidade de transcrição no momento.

Como transcrever áudio com a API Whisper e Python: passo a passo

1. Prepare o ambiente (segurança e chaves)  

Antes de chamar a API de speech-to-text da OpenAI no seu código Python, você precisa de duas coisas básicas:

• Uma conta na plataforma;
• Uma chave de API ativa. 

Essa chave funciona como um “cartão de acesso” que autoriza as suas requisições e registra o uso no seu projeto. É com ela que o cliente Python consegue falar com os modelos de transcrição, como o whisper-1 e o gpt-4o-transcribe.

Vale lembrar que a própria documentação da OpenAI recomenda que você trate essa chave como um segredo, ou seja, não deixe-a exposta em repositórios, não a cole direto no código e não a compartilhe em prints ou vídeos. 

E a forma mais segura de guardá-la é armazená-la em uma variável de ambiente ou em um arquivo .env, que não deve ser versionado. 

2. Instale as bibliotecas

Use a biblioteca python-dotenv para carregar automaticamente a chave do arquivo .env. Para isso, rode no terminal:

pip install openai python-dotenv

pip install openai python-dotenv

3. Crie sua chave de API

Com a biblioteca instalada, agora você pode criar sua chave API. Para isso:

1. Acesse o painel da OpenAI;
2. Entre na área API Keys;
3. Clique em Create new key;
4. Copie o valor gerado.

Depois, dentro do seu projeto, crie um arquivo .env com:

OPENAI_API_KEY=sua_api_key_aqui

OPENAI_API_KEY=sua_api_key_aqui

Importante: esse arquivo não deve ser enviado ao GitHub.

4. Carregue a chave e inicialize o cliente

Agora, carregue o .env e inicialize o cliente da OpenAI:

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()  # Carrega as variáveis do .env

client = OpenAI()  # Usa OPENAI_API_KEY automaticamente

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()  # Carrega as variáveis do .env

client = OpenAI()  # Usa OPENAI_API_KEY automaticamente

A partir daqui, todas as chamadas à API já estarão autenticadas. Se você suspeitar que sua chave foi exposta, revogue-a no painel da OpenAI e gere uma nova. 

5. Escreva o código para transcrever áudios

Com o ambiente pronto, você já pode criar um script simples para enviar um arquivo de áudio e receber a transcrição. Antes de tudo, importe as bibliotecas e inicialize o cliente:

from openai import OpenAI
from dotenv import load_dotenv
import os

# Carrega variáveis do arquivo .env
load_dotenv()

# Inicializa o cliente (a chave é lida automaticamente)
client = OpenAI()

from openai import OpenAI
from dotenv import load_dotenv
import os

# Carrega variáveis do arquivo .env
load_dotenv()

# Inicializa o cliente (a chave é lida automaticamente)
client = OpenAI()

Esse código configura o ambiente para que o Python consiga usar a API de forma segura, carregando a chave do .env e criando o cliente que vai enviar as requisições.

Exemplos práticos de transcrição de áudios com a API Whisper da OpenAI

1. Transcrevendo um arquivo de áudio (MP3/WAV)

Neste exemplo, você vê o fluxo completo para transcrever um arquivo de áudio usando Python e a API da OpenAI. Esse é o formato recomendado atualmente pela plataforma.

Instale as dependências

No terminal:

pip install openai python-dotenv

pip install openai python-dotenv

Carregue a chave via .env

Crie um arquivo .env no seu projeto:

OPENAI_API_KEY=sua_api_key_aqui

OPENAI_API_KEY=sua_api_key_aqui

Esse arquivo não deve ser versionado.

No código Python, carregue o .env:

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()  # Lê as variáveis do .env

client = OpenAI()  # Inicializa o cliente usando OPENAI_API_KEY

from openai import OpenAI
from dotenv import load_dotenv
import os

load_dotenv()  # Lê as variáveis do .env

client = OpenAI()  # Inicializa o cliente usando OPENAI_API_KEY

Abra o arquivo e chame a API

Vamos supor que você tem audio_asimov.mp3 ou audio_asimov.wav no diretório. Nesse caso, o código fica assim:

audio_file = open("audio_asimov.mp3", "rb")

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",  # Modelo recomendado pela OpenAI
    file=audio_file
)

audio_file = open("audio_asimov.mp3", "rb")

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",  # Modelo recomendado pela OpenAI
    file=audio_file
)

Se quiser usar o modelo tradicional, troque para:

model="whisper-1"

model="whisper-1"

Imprima o resultado

O texto transcrito fica na propriedade .text:

print(transcription.text)

print(transcription.text)

Se preferir uma resposta completa, com timestamps, idioma detectado, duração e metadados, use JSON. Para isso, rode:

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file,
    response_format="verbose_json"
)

print(transcription)

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file,
    response_format="verbose_json"
)

print(transcription)

Esse formato é indicado para legendas, análises detalhadas ou qualquer etapa de pós-processamento.

Veja também:

OpenAI API: como utilizar a principal API para IA em Python

2. Transcrevendo áudio de vídeo MP4

A API de áudio da OpenAI também aceita vídeos em MP4 e faz a extração do áudio automaticamente. Ou seja, você não precisa separar a faixa de som antes de enviar, já que a própria API cuida disso.

Esse recurso é indicado para transcrever reuniões gravadas, videoaulas, apresentações e qualquer conteúdo em vídeo.

Importante

A OpenAI recomenda que você reduza o bitrate ou o tamanho do arquivo (caso ele seja muito grande) antes do envio. Isso porque arquivos leves fazem a transcrição ser mais rápida, mais barata e evitam erros relacionados a limites de upload. 

Por exemplo, vídeos enormes, exportados em 4K, não são necessários para transcrever apenas a fala.

Código de transcrição de vídeo MP4

video_file = open("video_asimov.mp4", "rb")

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",  # modelo recomendado pela OpenAI
    file=video_file
)

print(transcription.text)

video_file = open("video_asimov.mp4", "rb")

transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",  # modelo recomendado pela OpenAI
    file=video_file
)

print(transcription.text)

Veja que a chamada é exatamente a mesma usada para arquivos MP3 ou WAV. A única diferença é que você abre um .mp4. O restante é idêntico: o modelo recebe o vídeo, extrai o áudio e devolve o texto transcrito.

3. Capturando áudio do microfone e transcrevendo em seguida 

Neste exemplo, você grava alguns segundos de áudio pelo microfone, salva em um arquivo .wav e envia esse arquivo para a API da OpenAI. É um fluxo síncrono: primeiro você grava, depois transcreve.

Esse método é ótimo para testes rápidos, anotações de voz e pequenas gravações. Porém, ele não é o mesmo que streaming em tempo real (falaremos disso daqui a pouco).

Código completo com captura + transcrição

import pyaudio
import wave
from openai import OpenAI

client = OpenAI()

# Configurações de gravação
formato = pyaudio.paInt16   # Formato dos dados de áudio (16 bits)
canais = 1                  # Áudio mono
taxa = 44100                # Taxa de amostragem (44.1 kHz)
chunk = 1024                # Tamanho do buffer de leitura
duracao = 5                 # Duração da gravação em segundos
arquivo_saida = "gravacao.wav"

audio = pyaudio.PyAudio()

print("Gravando...")

# Abre o stream de captura do microfone
stream = audio.open(
    format=formato,
    channels=canais,
    rate=taxa,
    input=True,
    frames_per_buffer=chunk
)

frames = []

# Lê os dados do microfone em "chunks" por X segundos
for _ in range(int(taxa / chunk * duracao)):
    frames.append(stream.read(chunk))

print("Gravação finalizada.")

# Encerra o stream e o PyAudio
stream.stop_stream()
stream.close()
audio.terminate()

# Salva o áudio capturado em um arquivo WAV
with wave.open(arquivo_saida, "wb") as wf:
    wf.setnchannels(canais)
    wf.setsampwidth(pyaudio.PyAudio().get_sample_size(formato))
    wf.setframerate(taxa)
    wf.writeframes(b"".join(frames))

print("Enviando para transcrição...")

# Abre o arquivo WAV gerado
audio_file = open(arquivo_saida, "rb")

# Envia o arquivo para a API de transcrição
transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file
)

# Imprime o texto transcrito
print(transcription.text)

import pyaudio
import wave
from openai import OpenAI

client = OpenAI()

# Configurações de gravação
formato = pyaudio.paInt16   # Formato dos dados de áudio (16 bits)
canais = 1                  # Áudio mono
taxa = 44100                # Taxa de amostragem (44.1 kHz)
chunk = 1024                # Tamanho do buffer de leitura
duracao = 5                 # Duração da gravação em segundos
arquivo_saida = "gravacao.wav"

audio = pyaudio.PyAudio()

print("Gravando...")

# Abre o stream de captura do microfone
stream = audio.open(
    format=formato,
    channels=canais,
    rate=taxa,
    input=True,
    frames_per_buffer=chunk
)

frames = []

# Lê os dados do microfone em "chunks" por X segundos
for _ in range(int(taxa / chunk * duracao)):
    frames.append(stream.read(chunk))

print("Gravação finalizada.")

# Encerra o stream e o PyAudio
stream.stop_stream()
stream.close()
audio.terminate()

# Salva o áudio capturado em um arquivo WAV
with wave.open(arquivo_saida, "wb") as wf:
    wf.setnchannels(canais)
    wf.setsampwidth(pyaudio.PyAudio().get_sample_size(formato))
    wf.setframerate(taxa)
    wf.writeframes(b"".join(frames))

print("Enviando para transcrição...")

# Abre o arquivo WAV gerado
audio_file = open(arquivo_saida, "rb")

# Envia o arquivo para a API de transcrição
transcription = client.audio.transcriptions.create(
    model="gpt-4o-transcribe",
    file=audio_file
)

# Imprime o texto transcrito
print(transcription.text)

Como o código está organizado

O script segue quatro etapas simples:

1. Inicialização do PyAudio: configura o microfone;
2. Captura do áudio: grava por alguns segundos;
3. Geração do .wav: salva o arquivo localmente;
4. Transcrição: envia o arquivo para o gpt-4o-transcribe e recebe o texto.

Importante: Whisper API não é streaming

Esse fluxo funciona bem para gravações curtas, porque a API trabalha de forma síncrona, ou seja, ela recebe um arquivo completo, processa e devolve a transcrição.

Mas o Whisper não faz transcrição contínua do microfone, ou seja, ele não é um modelo de streaming. 

Por isso, se você quiser transcrição em tempo real, o ideal é usar a Realtime API da OpenAI, que foi pensada para streaming de áudio, com outra arquitetura e modelo de custo.

Veja também:

Como usar IA para transcrever áudio automaticamente com Python

Boas práticas de transcrição (retries, timeouts e resiliência)

Quando você trabalha com APIs, especialmente para áudio, é normal que algumas chamadas falhem. Isso pode acontecer por causa da sua conexão, limites temporários da plataforma ou arquivos muito grandes. 

Por isso, você não deve assumir que o seu código “vá funcionar sempre”. Ele precisa estar preparado para:

• Tentar novamente (retry) quando fizer sentido;
• Encerrar a chamada após um tempo limite (timeout);
• Evitar travar o programa em uma requisição que nunca retorna.

O SDK moderno da OpenAI já facilita essa configuração. O ideal é você definir:

• Um timeout curto, para evitar ficar esperando por uma resposta que não chega;
• Um número pequeno de tentativas, caso a API esteja temporariamente ocupada ou retorne um erro recuperável;
• Espera incremental entre tentativas, para não bater na API várias vezes em sequência.

Ou seja, em vez de esperar que tudo funcione 100% do tempo, configure o cliente para lidar bem com instabilidades.

Exemplo de configuração de timeout e retries

from openai import OpenAI
from httpx import Timeout

client = OpenAI(
    timeout=Timeout(30.0),  # tempo máximo de espera (segundos)
    max_retries=3           # tenta novamente até 3 vezes
)

from openai import OpenAI
from httpx import Timeout

client = OpenAI(
    timeout=Timeout(30.0),  # tempo máximo de espera (segundos)
    max_retries=3           # tenta novamente até 3 vezes
)

Com essa configuração, se uma transcrição falhar por instabilidade momentânea, o SDK tenta de novo automaticamente. Se ainda assim não der certo, você recebe um erro claro no código e pode tratar o problema da forma que achar melhor (log, nova tentativa manual, aviso para o usuário etc.).

Orientações importantes para usar o Whisper API

Tamanho máximo do arquivo

A API de transcrição aceita arquivos de até ~25 MB por requisição.
Se ultrapassar esse valor, você precisa:

• Comprimir o áudio;
• Reduzir bitrate;
• Ou dividir em partes (chunking): divida em blocos de 30 a 60 segundos, envie cada trecho separadamente e una as transcrições ao final.

Formatos recomendados

• MP3 em 128 kbps
• M4A / AAC
• OGG / Opus (excelente compressão)

Custos da API (Whisper / gpt-4o-transcribe)

Os valores variam conforme o modelo utilizado e são cobrados por minuto de áudio processado. O ideal é sempre consultar a tabela de preços atualizada no site da OpenAI, já que ela pode mudar.

Evite áudio com volume baixo ou ruidoso

A transcrição melhora bastante quando:

• O volume é consistente;
• Há menos ruído;
• Não há sobreposição de vozes.

Aplicações reais: o que dá para fazer com o Whisper?

O Whisper é um dos modelos mais práticos da OpenAI, porque transforma fala em texto com precisão em vários idiomas. Isso abre espaço para uma série de aplicações reais que você consegue construir com poucas linhas de Python.

Confira algumas delas:

• Transcrever reuniões, aulas e entrevistas: grave reuniões no Zoom, aulas, podcasts ou entrevistas e converta tudo em texto;
• Criar legendas automáticas para vídeos: com o verbose_json, você recebe timestamps detalhados. Com isso, fica fácil gerar arquivos .srt, legendas traduzidas e legendas sincronizadas para YouTube, cursos, treinamentos;
• Criar resumos automáticos a partir da transcrição: com a transcrição pronta, você pode usar um modelo de linguagem (como GPT-4o) para gerar resumo em tópicos, ata de reunião, lista de tarefas e insights;
• Criar assistentes de voz no computador: você pode capturar áudio do microfone, transcrever e enviar o texto para um agente de IA. Em segundos, você tem um assistente que entende o que você fala, pesquisa coisas, responde com voz e executa comandos;
• Traduzir áudios automaticamente: com translate=True, o modelo traduz automaticamente falas em diferentes idiomas, sem precisar indicar a língua de origem. Isso pode ser usado para dublagem automática, suporte multilíngue e legendagem internacional;
• Indexar e pesquisar conteúdos em áudio: depois de transcrever, você pode armazenar tudo em um banco de dados e fazer buscas por palavras-chave;
• Criar aplicações acessíveis: o Whisper permite transformar podcasts, aulas e vídeos em texto, o que amplia o acesso para pessoas com deficiência auditiva;
• Processar grandes volumes de áudio: usando chunking, você consegue transcrever palestras longas, conferências, eventos corporativos e conteúdos audiovisuais extensos.

Aprenda na prática:

Asimov Transcripts – Transcrevendo áudios com a API do ChatGPT

Como usar transcrição de áudio da OpenAI em projetos de IA

O Whisper da OpenAI é uma forma simples e eficiente de transformar fala em texto. Com ela, você consegue transcrever reuniões, processar vídeos, traduzir áudios e alimentar aplicações mais inteligentes, tudo com poucas linhas de Python.

Mas, se você quer ir além da transcrição e aprender a construir agentes de IA completos, capazes de ouvir, analisar, decidir e agir, precisa fazer a Formação Engenheiro de Agentes de IA, da Asimov Academy.

Nela, você aprende do zero a transformar quaisquer LLMs em um agente, usando Python e Agno, um dos frameworks mais avançados do momento.

Inscreva-se agora e crie seus agentes do zero!

Formação Engenheiro de Agentes de IA

Domine os frameworks de criação de agentes de IA mais avançados da atualidade e aprenda a transformar qualquer LLM em um agente!

Comece agora