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:
- Rode o filtro silencedetect do ffmpeg para listar os trechos de silêncio.
- Percorra a gravação. Quando uma parte chegar a cerca de 10 minutos, corte no próximo silêncio.
- 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). Usebroadnet/cohere-transcribecom o código de idioma certo para inglês, francês ou qualquer outro dos idiomas suportados. - Limiares.
-35dBe0.5segundo 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.mapdevolve 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ó.
