---
title: "Legendas SRT em árabe com uma API de fala para texto"
description: "Do que um SRT precisa, quais APIs de fala para texto devolvem timestamps ou SRT para árabe e um pipeline testado que gera legendas com uma API só de texto."
url: https://broadrouter.com/pt/blog/arabic-subtitles-srt-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/arabic-subtitles-srt-api/) (atualizado em 2026-11-16).

# Legendas em árabe (SRT) com uma API de fala para texto: o que precisa

Pela equipe da BroadNet Inference · 7 min de leitura · Publicado em 2026-11-15 · Atualizado em 2026-11-16

Um arquivo SRT precisa de texto mais um tempo de início e de fim para cada legenda. APIs com timestamps por palavra ou por segmento, ou com exportação direta de SRT, dão o melhor sincronismo. O BroadNet Transcribe Arabic devolve só texto, então divida o áudio nas pausas, transcreva cada chunk e sincronize as legendas pelos offsets dos chunks. Serve para palestras e podcasts, não para legendas de filme precisas ao quadro.

## Pontos principais

-   SRT é uma lista numerada de legendas, cada uma com uma linha hh:mm:ss,mmm --> hh:mm:ss,mmm. A Library of Congress observa que o formato não tem especificação formal nem padrão de codificação de caracteres.
-   A resposta de transcrição documentada pela BroadNet é só {"text": ...}: sem timestamps, sem segmentos e sem saída SRT.
-   A OpenAI documenta SRT e timestamps por palavra só no whisper-1, cujo desligamento está previsto para 26 de fevereiro de 2027. A AssemblyAI e a Speechmatics documentam exportação de SRT; a Deepgram e a ElevenLabs documentam timestamps por palavra.
-   O guia de árabe da Netflix define 42 caracteres por linha, duas linhas e até 20 caracteres por segundo em programas adultos; o guia geral limita uma legenda a 7 segundos.
-   O sincronismo por chunk é tão preciso quanto as suas pausas. Dentro de um chunk, os tempos das legendas são estimados pelo tamanho do texto.

**Nesta página**

1.  Do que um arquivo SRT precisa?
2.  Qual deve ser o tamanho de uma linha de legenda em árabe?
3.  Quais APIs de fala para texto documentam timestamps ou SRT?
4.  Como gerar legendas a partir de uma API só de texto?
5.  O pipeline em Python
6.  Quão preciso é o sincronismo por chunk?
7.  Quanto custa e quão rápido é?
8.  Onde entra a BroadNet Inference

Legendas são texto com tempos associados. A maior parte do trabalho num pipeline de legendas em árabe é obter esses tempos. Algumas APIs de fala para texto entregam isso como timestamps por palavra ou como um arquivo SRT pronto. Outras, incluindo a BroadNet Inference, devolvem só o texto da transcrição. Este post explica do que um arquivo SRT precisa, quais provedores documentam timestamps e como montar legendas em árabe utilizáveis a partir de uma API só de texto, com os limites ditos claramente.

O BroadRouter é o site da própria BroadNet. Se você precisa de sincronismo preciso ao quadro, a resposta honesta abaixo é um provedor com timestamps por palavra, não a BroadNet.

## Do que um arquivo SRT precisa?

Um arquivo SRT (SubRip) é texto puro. Cada legenda tem quatro partes: um número, uma linha de tempo, uma ou duas linhas de texto e uma linha em branco.

```text
1
00:00:00,000 --> 00:00:02,800
مرحباً بكم في الحلقة الأولى

2
00:00:03,600 --> 00:00:07,600
اليوم نتحدث عن تحويل الكلام إلى نص وكيف
نصنع ملف ترجمة مصاحبة
```

A descrição do formato da Library of Congress dá o formato de tempo como horas:minutos:segundos,milissegundos e a seta como dois hifens e um sinal de maior. Ela também diz que o SRT é “not well standardized” (tradução: pouco padronizado) e que arquivos SRT “do not have a character encoding standard” (tradução: não têm um padrão de codificação de caracteres). Para árabe, grave em UTF-8 e teste no player de destino. O WebVTT, sucessor dele para a web, usa um ponto em vez da vírgula antes dos milissegundos.

Então o requisito obrigatório é um tempo de início e de fim para cada legenda. Só o texto não basta.

## Qual deve ser o tamanho de uma linha de legenda em árabe?

Use um guia de estilo publicado em vez de chutar. O Arabic Timed Text Style Guide da Netflix (registro de alterações datado de 2025-12-19) define:

| Regra | Valor da Netflix |
| --- | --- |
| Caracteres por linha | 42 |
| Linhas por legenda | No máximo duas |
| Velocidade de leitura, programas adultos | Até 20 caracteres por segundo |
| Velocidade de leitura, programas infantis | Até 17 caracteres por segundo |
| Quebras de linha | Não separe um verbo do sujeito, uma preposição do substantivo nem um número daquilo que ele conta |

Os requisitos gerais da Netflix acrescentam um mínimo de cinco sextos de segundo e um máximo de 7 segundos por legenda. O guia de árabe também pede árabe padrão moderno nas legendas traduzidas. Essa é uma regra de tradução; a transcrição de uma fala em dialeto continua em dialeto.

Esses números viram código: quebre a linha em 42 caracteres, duas linhas por legenda, avise acima de 20 caracteres por segundo e nunca mantenha uma legenda na tela por mais de 7 segundos.

## Quais APIs de fala para texto documentam timestamps ou SRT?

Lemos a documentação atual de cada provedor em 15 de novembro de 2026. A tabela mostra o que eles documentam, não quão preciso é o sincronismo.

| Provedor | O que a documentação oferece | Árabe |
| --- | --- | --- |
| OpenAI | `response_format` `srt`, `vtt` ou `verbose_json`, e `timestamp_granularities[]` por palavra ou segmento, só no `whisper-1`. `gpt-4o-transcribe` e `gpt-4o-mini-transcribe` devolvem só `json` | Não verificado. A página de descontinuações da OpenAI lista `whisper-1`, `gpt-4o-transcribe`, `gpt-4o-mini-transcribe` e `gpt-4o-transcribe-diarize` como descontinuados, todos com desligamento em 26 de fevereiro de 2027, e recomenda `gpt-transcribe` ou `gpt-live-transcribe` no lugar |
| AssemblyAI | `GET /v2/transcript/{transcript_id}/srt` ou `/vtt`, com `chars_per_caption` | Árabe listado no Universal-2, na faixa de WER de 10 a 25% |
| Speechmatics | `format=srt` no endpoint da transcrição; `srt_overrides` com `max_line_length` e `max_lines`; os itens por palavra trazem `start_time` e `end_time` | Árabe, mais um pacote árabe-inglês `ar_en` |
| Deepgram | Timestamps por palavra e por enunciado; bibliotecas oficiais de legendas em Python e JavaScript que geram SRT e WebVTT | Árabe e códigos regionais no Nova-3 |
| ElevenLabs | `timestamps_granularity` por palavra ou por caractere; cada palavra tem `start` e `end` em segundos | Árabe listado, na faixa de WER de 10 a 20% |
| BroadNet Inference | Só `{"text": ...}` | Um modelo específico para árabe e um modelo de 14 idiomas |

Se você pode rodar modelos por conta própria, o filtro `whisper` do FFmpeg, compilado com o whisper.cpp, pode gravar `srt` diretamente e tem uma opção `max_len` para linhas mais curtas.

Para uma primeira comparação de precisão e preço em árabe, veja o [guia de compra de APIs de fala para texto em árabe](https://broadrouter.com/pt/blog/arabic-speech-to-text-api-buyers-guide/) e a [comparação de preços de fala para texto](https://broadrouter.com/pt/blog/speech-to-text-api-pricing-compared/). Timestamps são uma linha dessa decisão, não a única.

## Como gerar legendas a partir de uma API só de texto?

Você cria os seus próprios timestamps a partir de onde corta o áudio. Os passos:

1.  **Encontre as pausas.** O `silencedetect` do FFmpeg registra `silence_start` e `silence_end` em segundos sempre que o nível fica abaixo de um limiar por um tempo mínimo.
2.  **Transforme as pausas em trechos de fala.** Tudo entre dois silêncios é um trecho. Limite os trechos a cerca de 12 segundos, para que alguém que nunca pausa ainda gere legendas curtas.
3.  **Transcreva cada trecho.** Corte-o num WAV mono de 16 kHz e envie com `language=ar`.
4.  **Sincronize as legendas.** O início e o fim do trecho são os seus tempos de âncora. Se o texto precisar de várias linhas, divida o tempo do trecho entre elas na proporção do tamanho de cada uma.
5.  **Grave o SRT** e confira o tamanho das linhas, a velocidade de leitura e a duração contra as regras de estilo.

É a mesma divisão de [transcrever arquivos de áudio longos](https://broadrouter.com/pt/blog/transcribe-long-audio-files-api/), com outro objetivo. Lá, os chunks têm cerca de 10 minutos e só importa o texto unido. Aqui, os chunks têm segundos de duração, porque cada um vira tempos de legenda. A [ferramenta de divisão de áudio](https://broadrouter.com/tools/audio-splitter-ffmpeg/) monta os comandos do FFmpeg se você preferir dividir à mão.

## O pipeline em Python

Este script usa o SDK Python da OpenAI e o FFmpeg. Rodamos em 15 de novembro de 2026 contra um servidor mock local que responde como o endpoint documentado da BroadNet (`{"text": ...}`), com um arquivo de teste gerado com tons e pausas. O SRT acima é a saída dele. Nenhuma chave da BroadNet foi usada, então o texto em árabe veio do mock, não do modelo.

```python
import os, re, subprocess, sys
from openai import OpenAI

FFMPEG = os.environ.get("FFMPEG", "ffmpeg")
client = OpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                api_key=os.environ["BROADNET_API_KEY"])
MODEL = "broadnet/cohere-transcribe-arabic"
MAX_CHARS, MAX_LINES, MAX_CUE, MAX_CPS = 42, 2, 7.0, 20   # Netflix Arabic / general guide values

def find_speech(path, noise="-35dB", min_silence=0.4, max_span=12.0):
    """Return [(start, end)] seconds of speech between silences, each at most max_span long."""
    log = subprocess.run([FFMPEG, "-hide_banner", "-nostats", "-i", path,
                          "-af", f"silencedetect=n={noise}:d={min_silence}", "-f", "null", "-"],
                         capture_output=True, text=True).stderr
    h, m, s = re.search(r"Duration: (\d+):(\d+):([\d.]+)", log).groups()
    total = int(h) * 3600 + int(m) * 60 + float(s)
    starts = [float(x) for x in re.findall(r"silence_start: (-?[\d.]+)", log)]
    ends = [float(x) for x in re.findall(r"silence_end: ([\d.]+)", log)]
    spans, t = [], 0.0
    for i, s0 in enumerate(starts):
        if s0 - t > 0.2:
            spans.append((t, s0))
        t = ends[i] if i < len(ends) else total
    if total - t > 0.2:
        spans.append((t, total))
    out = []
    for a, b in spans:                       # no pause found: cut at a fixed length
        while b - a > max_span:
            out.append((a, a + max_span)); a += max_span
        out.append((a, b))
    return out

def transcribe_span(path, a, b, name):
    subprocess.run([FFMPEG, "-hide_banner", "-loglevel", "error", "-y", "-ss", f"{a:.3f}",
                    "-to", f"{b:.3f}", "-i", path, "-ar", "16000", "-ac", "1", name], check=True)
    with open(name, "rb") as f:
        return client.audio.transcriptions.create(model=MODEL, file=f, language="ar").text.strip()

def to_cues(text, a, b):
    """Wrap text into lines of <= MAX_CHARS, give each line a share of the span's time
    in proportion to its length, then pack lines into cues of <= MAX_LINES and <= MAX_CUE s."""
    lines, cur = [], ""
    for w in text.split():
        if cur and len(cur) + 1 + len(w) > MAX_CHARS:
            lines.append(cur); cur = w
        else:
            cur = f"{cur} {w}".strip()
    if cur:
        lines.append(cur)
    chars = sum(len(l) for l in lines) or 1
    cues, t = [], a
    for line in lines:
        d = (b - a) * len(line) / chars
        last = cues[-1] if cues else None
        if last and len(last[2]) < MAX_LINES and t + d - last[0] <= MAX_CUE:
            last[1] = t + d; last[2].append(line)
        else:
            cues.append([t, t + d, [line]])
        t += d
    for c in cues:                           # a long pause inside a span: don't hold text on screen
        c[1] = min(c[1], c[0] + MAX_CUE)
    return cues

def ts(x):
    ms = round(x * 1000)
    return f"{ms // 3600000:02}:{ms // 60000 % 60:02}:{ms // 1000 % 60:02},{ms % 1000:03}"

def make_srt(path, out="out.srt"):
    cues = []
    for i, (a, b) in enumerate(find_speech(path)):
        text = transcribe_span(path, a, b, f"chunk-{i:04}.wav")
        if text:
            cues += to_cues(text, a, b)
    with open(out, "w", encoding="utf-8") as f:
        for n, (a, b, g) in enumerate(cues, 1):
            cps = len(" ".join(g)) / (b - a)
            if b - a > MAX_CUE or cps > MAX_CPS:
                print(f"check cue {n}: {b - a:.1f} s, {cps:.0f} chars/s", file=sys.stderr)
            f.write(f"{n}\n{ts(a)} --> {ts(b)}\n" + "\n".join(g) + "\n\n")
    return len(cues)

if __name__ == "__main__":
    print(make_srt(sys.argv[1], sys.argv[2] if len(sys.argv) > 2 else "out.srt"), "cues written")
```

Rode com `BROADNET_API_KEY` definida: `python make_srt.py episode.wav episode.srt`. No arquivo de teste, a detecção de pausas encontrou trechos de 0 a 2,8 s, de 3,6 a 7,6 s, de 8,8 a 28,8 s (cortado em 12 s porque não tinha pausa) e de 29,4 a 30,9 s, o que bateu com a forma como o arquivo foi montado. A saída foi lida sem erros pelo pacote Python `srt` e convertida para WebVTT com o FFmpeg.

Ajuste dois valores ao seu áudio. `noise` é o nível que conta como silêncio: tente de -30 a -40 dB para fala limpa e valores mais altos para ambientes barulhentos. `min_silence` é quanto tempo uma pausa precisa durar: de 0,3 a 0,5 segundo pega as pausas entre frases sem cortar a cada respiração.

## Quão preciso é o sincronismo por chunk?

Seja claro sobre o que este método consegue e não consegue fazer.

-   **As bordas dos trechos são a melhor parte.** Inícios e fins de legenda que caem numa pausa real são tão precisos quanto a detecção de silêncio. No nosso arquivo de teste sintético eles bateram exatamente; gravações reais, com respirações e ruído de ambiente, são mais bagunçadas.
-   **Os tempos dentro de um trecho são estimativas.** Quando um trecho contém duas ou três legendas, o script divide o tempo pela contagem de caracteres. As pessoas não falam num ritmo constante, então essas fronteiras internas podem errar por um segundo ou mais.
-   **Cortes fixos podem partir palavras.** Quando um trecho passa do teto de 12 segundos sem pausa, o corte cai onde cair. Uma palavra no corte pode se perder ou sair truncada. Aumente `noise` ou diminua `min_silence` primeiro, para que menos trechos precisem de corte fixo.
-   **Chunks curtos dão menos contexto ao modelo.** Um clipe de 3 segundos tem menos palavras em volta de cada palavra do que um arquivo de 10 minutos. Não medimos o quanto isso muda a precisão em árabe; teste no seu próprio áudio com o [WER](https://broadrouter.com/pt/blog/arabic-asr-wer-explained/).
-   **Sem rótulos de falante.** A BroadNet não devolve [diarização](https://broadrouter.com/pt/glossary/diarization/), então as legendas não dizem quem está falando.
-   **Música e ruído.** Música de fundo pode esconder as pausas por completo. Aí a maioria dos trechos vira corte fixo e o sincronismo piora.

Para aulas, podcasts, webinars e vídeos de treinamento, legendas a até um segundo da fala costumam ser legíveis. Para dramaturgia, clipes musicais ou qualquer coisa com sincronia labial, use um provedor com [timestamps](https://broadrouter.com/pt/glossary/timestamps-asr/) por palavra ou peça a um legendador que ajuste o arquivo.

## Quanto custa e quão rápido é?

O preço acompanha a duração do áudio. Uma hora de árabe no BroadNet Transcribe Arabic custa $0.25, quer você envie como um arquivo ou como 720 arquivos de cinco segundos. A página de preços da BroadNet lista um preço por minuto de áudio e nenhum mínimo por arquivo; confira a página de uso depois do primeiro episódio para confirmar.

A velocidade acompanha o número de requisições. Uma chave de pagamento por uso permite 30 requisições por minuto e 4 em andamento. Uma hora de fala dividida em trechos de 5 segundos dá cerca de 720 requisições, o que leva pelo menos 720 ÷ 30 minutos. Trechos mais longos significam menos requisições. Se receber um 429, espere e tente de novo como no [guia de erros e novas tentativas](https://broadrouter.com/pt/guides/errors-and-retries/), e não espalhe um job por várias chaves para contornar os limites publicados.

## Onde entra a BroadNet Inference

O BroadNet Transcribe Arabic serve para a metade de texto de um trabalho de legendagem: fala em árabe para texto em árabe a $0.0042 por minuto, com áudio e transcrições não retidos depois da requisição. O crédito inicial de $5 cobre a transcrição, então você pode testar o pipeline em episódios reais antes de recarregar. Ele não devolve timestamps, segmentos, rótulos de falante nem SRT. Se as suas legendas precisam de sincronismo por palavra, use um provedor que documente isso, ou alinhe o texto da BroadNet ao áudio com uma ferramenta de forced alignment. Formatos de requisição e limites estão na [referência da API da BroadNet](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-subtitles-srt-api&utm_content=body), e a configuração está no [guia de fala para texto em árabe](https://broadrouter.com/pt/guides/arabic-speech-to-text-api/).

Ferramentas gratuitas sobre o tema (em inglês)

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

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

## Termos neste artigo

[Legendas SRT (arquivo .srt)](https://broadrouter.com/pt/glossary/srt-subtitles/)

SRT (SubRip) é um formato de legenda em texto puro. Cada legenda tem um número sequencial, um tempo de início e fim escrito como hh:mm:ss,mmm --> hh:mm:ss,mmm, uma ou mais linhas de texto e uma linha em branco. WebVTT é o formato web parecido usado pelo vídeo em HTML.

[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.

[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.

[Timestamps (speech-to-text)](https://broadrouter.com/pt/glossary/timestamps-asr/)

Timestamps em speech-to-text são tempos de início e fim, em segundos, associados a partes de uma transcrição. Timestamps de segmento cobrem uma frase ou trecho; timestamps por palavra cobrem cada palavra. Eles são necessários para legendas, busca dentro de gravações e alinhamento do texto com os locutores.

[Word error rate (WER)](https://broadrouter.com/pt/glossary/word-error-rate/)

Word error rate (WER, taxa de erro de palavras) é a medida padrão de precisão do reconhecimento de fala: o número de substituições, deleções e inserções de palavras necessárias para transformar uma transcrição na referência correta, dividido pelo número de palavras da referência. Quanto menor, melhor.

[Árabe padrão moderno (MSA)](https://broadrouter.com/pt/glossary/msa/)

O árabe padrão moderno (MSA) é a forma padronizada do árabe usada na escrita, no noticiário, na educação e na fala formal em todo o mundo árabe. Ele não é a língua materna do dia a dia de ninguém: as pessoas falam dialetos regionais, como o egípcio ou o árabe do Golfo, e passam para o MSA em contextos formais.

[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.

## Perguntas frequentes

### Posso obter um arquivo SRT direto da API de transcrição da BroadNet?

Não. A documentação da BroadNet mostra uma resposta JSON com um único campo text, sem opção de SRT, VTT ou timestamps. Os metadados do /v1/models (verificados em 2026-11-15) listam os formatos de resposta json, text e verbose\_json, mas nenhuma fonte diz que o verbose\_json traz timestamps. Monte o sincronismo você mesmo a partir dos offsets dos chunks, como neste post, ou use um provedor que documente timestamps.

### Quais APIs de fala para texto exportam SRT para árabe?

Entre as que verificamos em 15 de novembro de 2026, a AssemblyAI (um endpoint de legendas, árabe no Universal-2) e a Speechmatics (format=srt, árabe e um pacote árabe-inglês) documentam exportação de SRT. A OpenAI documenta SRT no whisper-1, que está descontinuado. A Deepgram documenta bibliotecas de legendas construídas sobre os seus timestamps.

### Quantos caracteres por linha as legendas em árabe devem ter?

O Arabic Timed Text Style Guide da Netflix define 42 caracteres por linha e no máximo duas linhas. O limite de velocidade de leitura para programas adultos é de até 20 caracteres por segundo, e de 17 para programas infantis.

### Quão precisas são as legendas sincronizadas por chunks de áudio?

O início e o fim de cada chunk são tão precisos quanto a detecção de pausas, então ajuste-a no seu áudio. As legendas dentro de um chunk recebem tempos estimados pelo tamanho do texto, então podem se deslocar um segundo ou mais. Serve para palestras e podcasts, não para dramaturgia com sincronia labial.

### Por que o meu SRT em árabe mostra a pontuação do lado errado?

O SRT não tem marcação de direção, então é o player que decide como dispor o texto da direita para a esquerda. Teste o arquivo nos players que o seu público usa. Se a pontuação mudar de lugar, tente um formato com estilo mais rico ou uma configuração do player para texto RTL.

### Dividir o áudio em chunks curtos custa mais?

A BroadNet cobra a transcrição por minuto de áudio, então o total de áudio é o mesmo. Mas significa mais requisições: chunks curtos atingem antes o limite do pagamento por uso de 30 requisições por minuto. Confira a página de uso depois de uma primeira execução para confirmar a cobrança.

## Continue lendo

-   [Transcrever áudio longo acima de 25 MB: dividir, enviar e juntar](https://broadrouter.com/pt/blog/transcribe-long-audio-files-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/)
-   [Atas de reuniões em árabe a partir de gravações: um pipeline de API](https://broadrouter.com/pt/blog/arabic-meeting-minutes-from-recordings/)
-   [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/)
-   [Diacríticos no árabe com um LLM: prompt, checagens e DER](https://broadrouter.com/pt/blog/arabic-diacritization-llm/)
-   [Correção gramatical e ortográfica do árabe com um LLM: passo a passo](https://broadrouter.com/pt/blog/arabic-grammar-spelling-correction-llm/)
-   [Guia: API de transcrição de áudio em árabe, passo a passo](https://broadrouter.com/pt/guides/arabic-speech-to-text-api/)
-   [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-arabic-subtitles-srt-api&utm_content=page-cta) ·

**Fontes**

-   [Referência da API da BroadNet Inference: requisição de transcrição e resposta {"text": ...}, limites do pagamento por uso (verificado em 2026-11-15) (em inglês)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=pt-blog-arabic-subtitles-srt-api&utm_content=sources)
-   [Library of Congress, Sustainability of Digital Formats: descrição do formato SubRip (SRT) fdd000569 (verificado em 2026-11-15)](https://www.loc.gov/preservation/digital/formats/fdd/fdd000569.shtml)
-   [Netflix Partner Help Center, Arabic Timed Text Style Guide: 42 caracteres por linha, limites de velocidade de leitura (verificado em 2026-11-15)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215517947)
-   [Netflix Partner Help Center, Timed Text Style Guide: General Requirements, duração mínima e máxima (verificado em 2026-11-15)](https://partnerhelp.netflixstudios.com/hc/en-us/articles/215758617-Timed-Text-Style-Guide-General-Requirements)
-   [Referência da API da OpenAI, create transcription: response\_format e timestamp\_granularities por modelo (verificado em 2026-11-15)](https://developers.openai.com/api/reference/resources/audio/subresources/transcriptions/methods/create)
-   [Guia de fala para texto da OpenAI: timestamp\_granularities só no whisper-1, data de descontinuação (verificado em 2026-11-15)](https://developers.openai.com/api/docs/guides/speech-to-text)
-   [Descontinuações da OpenAI: whisper-1 e os modelos gpt-4o transcribe desligam em 26 de fevereiro de 2027; substitutos gpt-transcribe ou gpt-live-transcribe (verificado em 2026-11-15)](https://developers.openai.com/api/docs/deprecations)
-   [Referência da API da AssemblyAI, Get subtitles: o endpoint de legendas da transcrição, formato SRT ou VTT (verificado em 2026-11-15)](https://www.assemblyai.com/docs/api-reference/transcripts/get-subtitles)
-   [AssemblyAI, idiomas suportados para áudio pré-gravado (verificado em 2026-11-15)](https://www.assemblyai.com/docs/pre-recorded-audio/supported-languages)
-   [Documentação da Speechmatics, formatos de saída em lote: format=srt e srt\_overrides (verificado em 2026-11-15)](https://docs.speechmatics.com/speech-to-text/batch/output)
-   [Documentação da Speechmatics, idiomas suportados: árabe e o pacote bilíngue ar\_en (verificado em 2026-11-15)](https://docs.speechmatics.com/speech-to-text/languages)
-   [Documentação da Deepgram, geração automática de legendas WebVTT e SRT (verificado em 2026-11-15)](https://developers.deepgram.com/docs/automatically-generating-webvtt-and-srt-captions)
-   [Documentação da Deepgram, visão geral de modelos e idiomas: árabe no Nova-3 (verificado em 2026-11-15)](https://developers.deepgram.com/docs/models-languages-overview)
-   [Referência da API da ElevenLabs, fala para texto: timestamps\_granularity e start/end por palavra (verificado em 2026-11-15)](https://elevenlabs.io/docs/api-reference/speech-to-text/convert)
-   [Documentação de filtros do FFmpeg: filtros silencedetect e whisper (verificado em 2026-11-15)](https://ffmpeg.org/ffmpeg-filters.html)
