BroadRouter

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 · Atualizado em

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.

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.

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 e a comparação de preços de fala para texto. 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, 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 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.

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.
  • Sem rótulos de falante. A BroadNet não devolve diarização, 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 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, 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, e a configuração está no guia de fala para texto em árabe.

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.

Ler em MarkdownPerguntar ao ChatGPTPerguntar ao ClaudePerguntar ao Perplexity

Fontes