---
title: "Transcrever áudio acima de 25 MB via API: dividir e juntar"
description: "Como transcrever gravações acima do limite de uma API de fala para texto: reduza o arquivo, divida nos silêncios com ffmpeg, envie em paralelo e junte o texto."
url: https://broadrouter.com/pt/blog/transcribe-long-audio-files-api/
lang: pt-BR
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Traduzido do inglês com ajuda de IA. [Leia o original em inglês](https://broadrouter.com/blog/transcribe-long-audio-files-api/) (atualizado em 2026-11-15).

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

Pela equipe da BroadNet Inference · 6 min de leitura · Publicado em 2026-11-15

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.

## Pontos principais

-   O limite é em bytes, não em minutos. WAV mono a 16 kHz ocupa 32.000 bytes por segundo, então 26.214.400 bytes dão cerca de 13,6 minutos; MP3 a 64 kbit/s, cerca de 54 minutos.
-   Divida por tempo, em um silêncio, nunca por posição em bytes. Um corte em bytes quebra os frames de áudio, e um corte no meio de uma palavra perde palavras.
-   Mantenha as partes bem abaixo do limite, como 10 minutos de WAV, para que um arquivo ruidoso nunca retorne 413.
-   Envie as partes em paralelo até o limite da chave: 4 requisições simultâneas e 30 por minuto em uma chave de pagamento por uso da BroadNet.
-   Dividir não muda a duração de áudio que você paga. Uma hora de árabe custa $0.25 no BroadNet Transcribe Arabic.

**Nesta página**

1.  Por que uma gravação longa falha?
2.  Passo 1: como reduzir o arquivo?
3.  Passo 2: como dividir o áudio sem cortar palavras?
4.  Como fica o script completo?
5.  Quantas partes dá para enviar ao mesmo tempo?
6.  É preciso sobrepor as partes?
7.  A próxima parte pode usar o texto da anterior como contexto?
8.  Quanto custa um arquivo longo?
9.  Quais erros evitar?
10.  Quando dividir em partes é a ferramenta errada?
11.  Onde a BroadNet Inference se encaixa

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](https://broadrouter.com/pt/guides/errors-and-retries/).

## Passo 1: como reduzir o arquivo?

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

```bash
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](https://broadrouter.com/pt/glossary/sample-rate/) 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](https://broadrouter.com/tools/audio-splitter-ffmpeg/). À mão, funciona assim:

1.  Rode o filtro [silencedetect](https://ffmpeg.org/ffmpeg-filters.html) 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](https://ffmpeg.org/ffmpeg-formats.html) 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.

```python
# 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](https://broadrouter.com/pt/blog/multilingual-speech-to-text-api/).
-   **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](https://broadrouter.com/pt/blog/handle-llm-api-429-rate-limits/) 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](https://broadrouter.com/tools/speech-to-text-cost-calculator/); para comparar provedores, veja o [conjunto de dados de preços de APIs de fala para texto](https://broadrouter.com/data/speech-to-text-api-prices/).

## 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](https://broadrouter.com/pt/glossary/diarization/) e [timestamps](https://broadrouter.com/pt/glossary/timestamps-asr/) também lidam com arquivos longos de forma mais direta; o [guia de compra de API de fala para texto em árabe](https://broadrouter.com/pt/blog/arabic-speech-to-text-api-buyers-guide/) os compara. Para gravações de ligações em estéreo, divida por canal em vez de por tempo: o [pipeline de call center](https://broadrouter.com/pt/blog/transcribe-call-center-recordings/) 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](https://huggingface.co/spaces/elmresearchcenter/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](https://broadrouter.com/pt/guides/arabic-speech-to-text-api/) cobre a primeira requisição; este post cobre os arquivos grandes demais para uma só.

Ferramentas gratuitas sobre o tema (em inglês)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Ferramentas gratuitas (em inglês)](https://broadrouter.com/tools/)

## Termos neste artigo

[Fala para texto (speech-to-text)](https://broadrouter.com/pt/glossary/speech-to-text/)

Fala para texto, ou reconhecimento automático de fala (ASR), é a tecnologia que converte áudio falado em texto. Uma API de fala para texto recebe um arquivo ou stream de áudio e retorna uma transcrição, normalmente cobrada por minuto de áudio. A precisão é medida pela taxa de erro de palavras e varia com sotaque, dialeto e qualidade da gravação.

[WAV (arquivo de áudio WAV)](https://broadrouter.com/pt/glossary/wav/)

WAV (Waveform Audio File Format, ou WAVE) é um contêiner de áudio baseado no formato RIFF da Microsoft e da IBM. Ele costuma guardar amostras PCM lineares sem compressão, então o tamanho é previsível: taxa de amostragem vezes bytes por amostra vezes canais, por segundo.

[Concorrência (concurrency)](https://broadrouter.com/pt/glossary/concurrency/)

Concorrência é o número de requisições que um cliente tem em andamento ao mesmo tempo. APIs de LLM muitas vezes a limitam por chave ou por plano, separadamente das requisições por minuto, porque cada requisição aberta ocupa capacidade de GPU até a resposta terminar.

[Pagamento por uso (pay-as-you-go)](https://broadrouter.com/pt/glossary/pay-as-you-go/)

Pagamento por uso é um modelo de preço em que você paga só pelo que usa, medido por unidade, como tokens, requisições ou minutos de áudio, sem assinatura nem compromisso mínimo. A maioria das APIs de LLM cobra assim, a partir de um saldo pré-pago ou de uma fatura periódica.

[Rate limit (limite de taxa)](https://broadrouter.com/pt/glossary/rate-limit/)

Um rate limit é um teto que uma API impõe a quanto um cliente pode usá-la em um intervalo de tempo, como requisições por minuto ou tokens por minuto. As requisições acima do limite são recusadas, normalmente com HTTP 429 Too Many Requests, até que o uso volte a ficar abaixo dele.

[Streaming](https://broadrouter.com/pt/glossary/streaming/)

Streaming é uma forma de devolver a resposta de um modelo de linguagem em pequenos pedaços enquanto ela ainda está sendo gerada, em vez de uma resposta única no final. APIs compatíveis com a OpenAI fazem streaming via server-sent events quando a requisição define stream como true.

[Tool calling (chamada de ferramentas)](https://broadrouter.com/pt/glossary/tool-calling/)

Tool calling, também chamado de function calling ou chamada de ferramentas, é um recurso de APIs de LLM em que o modelo devolve um pedido estruturado para executar uma função definida pelo desenvolvedor, com argumentos JSON. A aplicação executa a função e devolve o resultado; o modelo nunca executa código sozinho.

[Backoff exponencial (exponential backoff)](https://broadrouter.com/pt/glossary/exponential-backoff/)

Backoff exponencial é uma estratégia de retry em que o cliente espera mais tempo depois de cada tentativa que falha, normalmente dobrando o atraso até um teto, antes de tentar de novo. Adicionar um jitter aleatório a cada espera espalha os retries de muitos clientes, para que não atinjam o servidor no mesmo instante.

## 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á.

## Continue lendo

-   [Como transcrever gravações de call center: pipeline pronto para árabe](https://broadrouter.com/pt/blog/transcribe-call-center-recordings/)
-   [API de fala para texto multilíngue: 14 idiomas, um endpoint](https://broadrouter.com/pt/blog/multilingual-speech-to-text-api/)
-   [API de fala para texto em árabe: como escolher em 2026](https://broadrouter.com/pt/blog/arabic-speech-to-text-api-buyers-guide/)
-   [Alternativa à API do Whisper: quando trocar e como testar](https://broadrouter.com/pt/blog/whisper-api-alternative/)
-   [Preço de API speech-to-text comparado: preço por minuto em 2026](https://broadrouter.com/pt/blog/speech-to-text-api-pricing-compared/)
-   [Legendas em árabe (SRT) com uma API de fala para texto: o que precisa](https://broadrouter.com/pt/blog/arabic-subtitles-srt-api/)
-   [Gravar áudio no navegador e enviar para uma API de speech-to-text](https://broadrouter.com/pt/blog/record-browser-audio-transcription-api/)
-   [Traduzir áudio em árabe para texto em inglês com API: pipeline testado](https://broadrouter.com/pt/blog/translate-arabic-audio-to-english/)
-   [Hardware de GPU e serving da BroadNet, segundo a própria BroadNet](https://broadrouter.com/pt/blog/broadnet-gpu-fleet-and-serving/)
-   [Cache de respostas de LLM para cortar custo: um cache exato em Python](https://broadrouter.com/pt/blog/cache-llm-responses-cut-cost/)
-   [Guia: API de transcrição de áudio em árabe, passo a passo](https://broadrouter.com/pt/guides/arabic-speech-to-text-api/)
-   [Guia: Transcrever áudios do WhatsApp para texto com uma API](https://broadrouter.com/pt/guides/transcribe-whatsapp-voice-notes/)
-   [Guia: Códigos de erro da BroadNet Inference e quando tentar de novo](https://broadrouter.com/pt/guides/errors-and-retries/)

Teste com a sua carga de trabalho real. Contas novas começam com US$ 5 de crédito para Gemma e transcrição. DeepSeek, GLM e Qwen3.8 exigem uma recarga.

[Começar](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-transcribe-long-audio-files-api&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: WAV ou MP3 até 26.214.400 bytes, campo language, erros 413 e 429, limites do pagamento por uso (consultada em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [Página de preços da BroadNet Inference, preço de transcrição por minuto de áudio (consultada em 2026-11-15) (em inglês)](https://inference.broadnet.ai/pricing?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-transcribe-long-audio-files-api&utm_content=sources)
-   [Guia de fala para texto da OpenAI: limite de 25 MB por arquivo, divisão em partes, evitar cortes no meio da frase (consultado em 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [Documentação de formatos do FFmpeg, segment muxer (consultada em 2026-11-15)](https://ffmpeg.org/ffmpeg-formats.html)
-   [Open Universal Arabic ASR Leaderboard no Hugging Face (posição informada pela BroadNet; conferida pelo BroadRouter em 2026-11-15)](https://huggingface.co/spaces/elmresearchcenter/open_universal_arabic_asr_leaderboard)
-   [Documentação de filtros do FFmpeg, silencedetect (consultada em 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
