BroadRouter

Transcrever áudio longo acima de 25 MB: dividir, enviar e juntar

Pela equipe da BroadNet Inference · 6 min de leitura · Publicado em

A maioria das APIs de transcrição rejeita um arquivo acima de cerca de 25 MB. Primeiro converta a gravação para mono a 16 kHz: só isso já faz caber cerca de 13 minutos de WAV ou 54 minutos de MP3 a 64 kbit/s no limite de 26.214.400 bytes da BroadNet. Para áudios mais longos, divida nos silêncios com ffmpeg, transcreva as partes em paralelo e junte o texto na ordem.

A maioria das APIs de fala para texto aceita um arquivo de cerca de 25 MB por requisição. A BroadNet Inference aceita WAV ou MP3 de até 26.214.400 bytes. Uma reunião longa, uma aula ou um podcast passam disso fácil, e a requisição falha com 413. A solução tem quatro passos: reduzir o arquivo, dividi-lo nos silêncios, enviar as partes em paralelo e juntar o texto de volta.

Por que uma gravação longa falha?

O limite é em bytes, não em minutos. Quantos minutos cabem depende do formato:

Formato Bytes por segundo Quanto cabe em 26.214.400 bytes
WAV, 44,1 kHz estéreo, 16 bits 176.400 Cerca de 2,5 minutos
WAV, 16 kHz mono, 16 bits 32.000 Cerca de 13,6 minutos
MP3, 64 kbit/s 8.000 Cerca de 54 minutos
MP3, 32 kbit/s 4.000 Cerca de 109 minutos

São contas simples: bytes por segundo vezes segundos. Uma gravação de celular ou notebook costuma ser estéreo a 44,1 ou 48 kHz, o que estoura o limite em poucos minutos. Fala não precisa disso. Converter antes para mono a 16 kHz é o maior ganho isolado.

Quando o arquivo ainda é grande demais, a API o rejeita de cara. Na BroadNet a resposta é 413, “the request exceeds the endpoint byte or text limit” (tradução: a requisição excede o limite de bytes ou de texto do endpoint), e nada é transcrito. Veja o guia de códigos de erro.

Passo 1: como reduzir o arquivo?

Converta para mono a 16 kHz antes de qualquer coisa. Um comando do ffmpeg resolve:

ffmpeg -i meeting.m4a -ac 1 -ar 16000 meeting.wav

Para a BroadNet, a saída precisa ser WAV (audio/wav) ou MP3 (audio/mpeg). Formatos como .m4a, .ogg e .webm precisam ser convertidos de qualquer jeito, então faça a reamostragem no mesmo passo.

WAV ou MP3? WAV é sem perdas, então nada se perde, mas enche o limite em cerca de 13 minutos. MP3 a 64 kbit/s cabe quatro vezes mais áudio por requisição, mas tem perdas. Se usar MP3, faça um teste rápido: transcreva os mesmos cinco minutos em WAV e em MP3 e compare o texto. O verbete taxa de amostragem explica por que 16 kHz basta para fala.

Passo 2: como dividir o áudio sem cortar palavras?

Divida por tempo, nunca por bytes. Um corte em uma posição em bytes pode cair no meio de um frame de áudio, e o arquivo não decodifica. Um corte em tempo fixo pode cair no meio de uma palavra. O próprio guia da OpenAI desaconselha dividir no meio da frase porque isso “can remove context and reduce accuracy” (tradução: pode remover contexto e reduzir a precisão).

O método confiável é cortar dentro de um silêncio perto do tamanho desejado. Para ter comandos prontos para o tamanho e a duração do seu arquivo, use o gerador gratuito de comandos para dividir áudio. À mão, funciona assim:

  1. Rode o filtro silencedetect do ffmpeg para listar os trechos de silêncio.
  2. Percorra a gravação. Quando uma parte chegar a cerca de 10 minutos, corte no próximo silêncio.
  3. Corte cada parte com o ffmpeg, de um ponto de corte ao seguinte.

Dez minutos de WAV mono a 16 kHz são 19,2 MB, o que deixa folga abaixo do limite. Se alguém falar muito tempo sem pausa, o script abaixo corta no máximo rígido.

O segment muxer do ffmpeg também divide um arquivo em partes “of nearly fixed duration” (tradução: de duração quase fixa) com um só comando. É rápido, mas não procura silêncio, então use só quando perder uma palavra em cada divisa for aceitável, ou adicione sobreposição (abaixo).

Como fica o script completo?

Este script Python converte, divide nos silêncios, envia até quatro partes de uma vez e junta o texto. Ele usa o SDK da OpenAI apontado para a BroadNet Inference.

# pip install openai
import os, re, subprocess, tempfile
from concurrent.futures import ThreadPoolExecutor
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
TARGET, HARD_MAX = 600, 750   # seconds: aim for 10 min, never above 12.5 min

def run(*args):
    return subprocess.run(args, capture_output=True, text=True, check=True)

def silences(path):
    """Midpoints (in seconds) of silent gaps of 0.5 s or more."""
    out = run("ffmpeg", "-i", path, "-af", "silencedetect=noise=-35dB:d=0.5",
              "-f", "null", "-").stderr
    starts = [float(x) for x in re.findall(r"silence_start: ([\d.]+)", out)]
    ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", out)]
    return [(s + e) / 2 for s, e in zip(starts, ends)]

def duration(path):
    return float(run("ffprobe", "-v", "error", "-show_entries", "format=duration",
                     "-of", "csv=p=0", path).stdout)

def cut_points(path):
    total, gaps, cuts, last = duration(path), silences(path), [0.0], 0.0
    while total - last > HARD_MAX:
        ok = [g for g in gaps if last + TARGET <= g <= last + HARD_MAX]
        last = ok[0] if ok else last + HARD_MAX   # no silence: hard cut
        cuts.append(last)
    return cuts + [total]

def transcribe(chunk):
    with open(chunk, "rb") as f:
        return client.audio.transcriptions.create(
            model="broadnet/cohere-transcribe-arabic", file=f, language="ar").text

def transcribe_long(src):
    with tempfile.TemporaryDirectory() as tmp:
        wav = os.path.join(tmp, "full.wav")
        run("ffmpeg", "-y", "-i", src, "-ac", "1", "-ar", "16000", wav)
        cuts, chunks = cut_points(wav), []
        for i, (a, b) in enumerate(zip(cuts, cuts[1:])):
            out = os.path.join(tmp, f"part{i:03d}.wav")
            run("ffmpeg", "-y", "-i", wav, "-ss", str(a), "-to", str(b), out)
            chunks.append(out)
        with ThreadPoolExecutor(max_workers=4) as pool:   # map() keeps order
            return "\n".join(pool.map(transcribe, chunks))

print(transcribe_long("meeting.m4a"))

Observações sobre o script:

  • Idioma. A documentação da BroadNet diz para sempre enviar language; sem ele, o árabe “can otherwise be transliterated into Latin letters” (tradução: pode acabar transliterado em letras latinas). Use broadnet/cohere-transcribe com o código de idioma certo para inglês, francês ou qualquer outro dos idiomas suportados.
  • Limiares. -35dB e 0.5 segundo servem para uma sala silenciosa. Ambientes ruidosos pedem um valor de ruído mais alto, como -30dB. Imprima os pontos de corte uma vez e confira.
  • Ordem. pool.map devolve os resultados na ordem de entrada, então o texto se junta na sequência certa mesmo que as partes terminem em momentos diferentes.

Quantas partes dá para enviar ao mesmo tempo?

Quantas a sua chave permitir. Uma chave de pagamento por uso da BroadNet permite 4 requisições simultâneas e 30 requisições por minuto, e é por isso que o script usa quatro workers. Uma quinta requisição ao mesmo tempo recebe 429. Repita as respostas 429 e 5xx com backoff exponencial; não repita a 413, porque o mesmo arquivo vai falhar de novo. Como lidar com erros 429 traz um auxiliar de novas tentativas que você pode colocar em volta de transcribe().

Com quatro workers, uma gravação de duas horas em partes de 10 minutos vira 12 requisições em três ondas. O tempo total fica em torno de três idas e voltas, não doze.

É preciso sobrepor as partes?

Não, se você cortar dentro dos silêncios: não há fala na divisa para perder. A sobreposição serve para cortes em tempo fixo. Comece cada parte um ou dois segundos antes do fim da anterior e remova as palavras repetidas ao juntar o texto. O jeito usual é comparar as últimas palavras de uma parte com as primeiras da seguinte e descartar a coincidência.

A sobreposição custa um pouco. Dois segundos por parte de 10 minutos acrescentam cerca de 0,3% ao áudio que você paga.

A próxima parte pode usar o texto da anterior como contexto?

Algumas APIs permitem. A OpenAI lista “carrying context from a previous chunk of a longer recording” (tradução: levar contexto de uma parte anterior de uma gravação mais longa) como um uso do parâmetro prompt. A referência da API da BroadNet lista só model, language e file para transcrição e devolve JSON com um campo text. Então, na BroadNet, trate cada parte como independente e corrija nomes e termos depois. Uma correção barata é enviar a transcrição completa a um modelo de chat com uma lista das grafias corretas de pessoas, produtos e lugares.

Quanto custa um arquivo longo?

Fala para texto é cobrada por minuto de áudio, então dividir não muda o total. Nos preços publicados da BroadNet:

Áudio BroadNet Transcribe Arabic BroadNet Transcribe (14 idiomas)
Preço por minuto $0.0042 $0.002
Uma hora $0.25 $0.12
1.000 horas $252.00 $120.00

A página de preços lista um preço por minuto de áudio e não diz nada sobre mínimo por arquivo ou arredondamento. Confira sua página de uso depois do primeiro lote para ver se o total bate com a duração do áudio. Os dois modelos de transcrição estão disponíveis com o crédito inicial gratuito de $5, que cobre cerca de 1,190 minutos de árabe. Para precificar o seu volume, use a calculadora de custo de fala para texto; para comparar provedores, veja o conjunto de dados de preços de APIs de fala para texto.

Quais erros evitar?

  • Enviar o arquivo original. Um WAV estéreo a 48 kHz é seis vezes maior que o necessário.
  • Cortar por posição em bytes. A parte não decodifica, ou o primeiro segundo vira ruído.
  • Partes bem no limite. Uma parte de 25,9 MB passa hoje e falha quando uma gravação vier um pouco mais alta. Deixe folga.
  • Paralelismo sem limite. Disparar 50 partes de uma vez faz a maioria levar 429. Limite os workers ao número de requisições simultâneas da chave.
  • Esquecer o idioma. Cada parte é uma requisição separada, então cada uma precisa de language.

Quando dividir em partes é a ferramenta errada?

Se você precisa de rótulos de falante ou timestamps por palavra, dividir em partes uma API que só devolve texto não vai entregá-los. A resposta de transcrição da BroadNet é só texto. Provedores que devolvem diarização e timestamps também lidam com arquivos longos de forma mais direta; o guia de compra de API de fala para texto em árabe os compara. Para gravações de ligações em estéreo, divida por canal em vez de por tempo: o pipeline de call center mostra como.

Onde a BroadNet Inference se encaixa

O BroadNet Transcribe Arabic custa $0.0042 por minuto, e a BroadNet informa que ele está em #2 de 37 (dado de setembro de 2026; o ranking ao vivo o listava em #4 de 39 em 15 de novembro de 2026) no Open Universal Arabic ASR Leaderboard. Áudio e transcrições não são retidos depois da requisição. Ele serve para transcrição em lote de gravações longas em árabe, depois de divididas como acima. Não serve se você precisa de timestamps, rótulos de falante ou streaming ao vivo na mesma API. O guia de fala para texto em árabe cobre a primeira requisição; este post cobre os arquivos grandes demais para uma só.

Perguntas frequentes

Como transcrever um arquivo de áudio maior que 25 MB?

Primeiro converta para mono a 16 kHz, o que muitas vezes já o coloca abaixo do limite. Se ainda for grande demais, divida-o com ffmpeg em partes de cerca de 10 minutos nos pontos de silêncio, transcreva cada parte com a mesma configuração de idioma e junte os textos na ordem.

Quantos minutos de áudio cabem em 25 MB?

Depende do formato. WAV mono a 16 kHz e 16 bits usa 32.000 bytes por segundo, então 26.214.400 bytes comportam cerca de 13,6 minutos. MP3 a 64 kbit/s comporta cerca de 54 minutos. WAV estéreo ou a 44,1 kHz comporta bem menos.

O que acontece se eu enviar um arquivo acima do limite?

A requisição é rejeitada. A BroadNet Inference retorna 413, que a documentação define como uma requisição que excede o limite de bytes ou de texto do endpoint. Nada é transcrito, então divida e reenvie.

Perco palavras nas divisas entre as partes?

Pode perder, se cortar em um tempo fixo no meio da fala. Corte dentro de um silêncio. Se precisar cortar em tempo fixo, sobreponha as partes em um ou dois segundos e remova as palavras repetidas ao juntar.

Dividir um arquivo custa mais?

Você paga por minutos de áudio, então a duração total é a mesma. A página de preços da BroadNet lista um preço por minuto de áudio e não menciona mínimo por arquivo nem arredondamento; confira a página de uso depois do primeiro lote para confirmar.

Posso enviar o texto da parte anterior como contexto?

Algumas APIs aceitam um prompt para isso; a OpenAI cita levar contexto de uma parte anterior como um uso do parâmetro prompt. A documentação da BroadNet lista só model, language e file, então não conte com um prompt lá.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity