API de legendas para arquivos SRT e VTT traduzidos

Envie um vídeo uma única vez e receba arquivos de legendas em SRT e WebVTT para qualquer idioma de destino, sincronizados com a fala. Corrija qualquer linha pela API e baixe os arquivos atualizados para o seu player, aplicativo ou software de edição de vídeo.
SRT e WebVTT
Mais de 135 opções de idiomas e regiões
REST + SDK para Python
upload, create, download
OAuth 2.0
# 1. upload the video once - YouTube, Drive, S3, Vimeo or direct URL
curl -X POST https://api.rask.ai/api/library/v1/media/link \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d '{"link": "https://example.com/onboarding.mp4", "name": "onboarding"}'

# 2. one project per subtitle language
for lang in es-mx fr-fr ja-jp; do
  curl -X POST https://api.rask.ai/v2/projects \
    -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
    -d "{\"video_id\": \"$VIDEO_ID\", \"dst_lang\": \"$lang\"}"
done
GET /v2/projects/{project_id}
.srt + .vtt
# When status is merging_done, download both subtitle files
P=$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN")
curl -s -o onboarding.es-mx.srt "$(echo $P | jq -r .translation_srt_path)"
curl -s -o onboarding.es-mx.vtt "$(echo $P | jq -r .translation_vtt_path)"
Usado por equipes globais
Recursos

Tudo o que a API de legendas oferece

Crie arquivos SRT e WebVTT traduzidos a partir de gravações de vídeo ou áudio, incluindo podcasts e entrevistas. Escolha o idioma de destino para cada projeto e receba os arquivos de legenda junto com a transcrição, a tradução e o conteúdo dublado.

Arquivos SRT e WebVTT

Cada projeto concluído gera um arquivo .srt e um arquivo .vtt no idioma de destino: o SRT para softwares de edição de vídeo e a maioria das plataformas, e o WebVTT para reprodução de vídeo na web.

Legendas em outro idioma

Elimine as barreiras de idioma para seu público em qualquer mercado: crie um projeto por idioma de destino, como es-mx, pt-br ou fr-ca, a partir do mesmo envio. O idioma original é detectado automaticamente.

Sincronizado com o conteúdo falado

Cada legenda acompanha um trecho da transcrição com o tempo de início e fim, garantindo que cada linha apareça na tela exatamente quando é falada.

Legendas no idioma original

A transcrição armazena o texto original de cada trecho com os respectivos horários. Converta esses dados em um arquivo SRT ou VTT para gerar legendas no mesmo idioma com apenas algumas linhas de código.

Identificação de locutores para diálogos

Cada segmento da transcrição traz o identificador do locutor, permitindo incluir o nome de quem fala nas legendas de entrevistas, debates e diálogos.

Edite uma linha antes de publicar

Corrija o texto ou o tempo de qualquer trecho usando a API e gere o conteúdo novamente. Termos confusos, nomes próprios e sotaques são ajustados de uma só vez em todos os formatos.

Termos consistentes em qualquer idioma

Um glossário garante que os nomes de produtos e termos técnicos fiquem idênticos em todas as legendas ou mantenham o idioma original quando necessário.

Legendas e versão dublada

O mesmo projeto também fornece o vídeo traduzido e as faixas de áudio, permitindo obter legendas e uma versão dublada a partir de um único envio.

Cresça sem limites

Sem limites de taxa, sem cota de simultaneidade e sem restrições por chave. Adicione legendas a toda a sua biblioteca de vídeos em múltiplos idiomas ao mesmo tempo.
Veja na prática

Um vídeo, cinco versões em diferentes idiomas

O mesmo clipe em inglês, francês, alemão, português e espanhol. Cada versão de idioma vem com seus próprios arquivos de legenda SRT e VTT.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Fluxo de trabalho

Três etapas, desde o envio do vídeo até o arquivo de legenda

A criação do projeto inicia a transcrição, a tradução e a versão dublada de uma só vez. Use o endpoint /generate após editar as linhas de legenda.
1

Carregue seu vídeo

Envie o vídeo como arquivo ou cole um link do YouTube, Google Drive, S3, Vimeo ou qualquer URL direta. Um único envio serve para todos os idiomas de legenda.

POST /api/library/v1/media/link
2

Criar o projeto

Passe o ID de mídia como video_id e um idioma de destino por projeto. Os projetos para diferentes idiomas são executados em paralelo.

POST /v2/projects
3

Baixe os arquivos de legenda

Monitore o status até que ele atinja merging_done, depois baixe os arquivos .srt e .vtt e salve-os no seu sistema.

GET /v2/projects/{project_id}
O tempo de processamento varia de acordo com a duração do video, o número de locutores e o idioma de destino. Em um teste recente, um video de 3:47 foi concluído em 165 segundos.
Criado para você

Precisa de um formato de legenda ou entrega que não está listado? Fale com nossa equipe

Outro formato de legenda, entrega no seu próprio armazenamento, um idioma fora do catálogo ou maior capacidade: nossa equipe analisa as necessidades do seu fluxo de produção e as opções disponíveis.

Idiomas e vozes

Precisa de legendas em um idioma fora do catálogo público? Fale com nossa equipe sobre suas necessidades e as opções disponíveis.

Entrega e integração

Webhooks, envio para a sua própria fila, entrega direto no seu S3 e endpoints personalizados. Diga-nos como o seu sistema prefere receber os dados.

Volume e capacidade

Tamanhos de lote, idiomas de destino por ação e prioridade de processamento são termos contratuais, e não limites fixos do produto.

Segurança e hospedagem

A residência de dados, SSO e SAML, regras de retenção e suporte a revisões de segurança são gerenciados como parte da integração empresarial.
Casos de uso

Quem usa uma API de legendas

Plataformas com vídeo integrado

Plataformas de LMS e treinamento de clientes, plataformas de criadores e vídeos, ferramentas de webinars e eventos virtuais, SaaS de hospedagem de vídeos e fluxos de trabalho, plataformas de adoção digital e compras ao vivo. Transforme legendas em todos os idiomas em um recurso dos seus vídeos enviados.

Agências de localização e produção

Entregue arquivos SRT e VTT para todos os idiomas de clientes a partir de um único envio. Os revisores corrigem as linhas pela API e os arquivos são atualizados sem que ninguém precise ajustar o tempo.

Produção de vídeo contínua interna

Varejo internacional e e-commerce, franquias globais, editoras de mídia e universidades corporativas. Torne os treinamentos e os vídeos de produtos acessíveis a todos os mercados e a espectadores que assistem sem som.
Histórias de clientes

Equipes reais, resultados mensuráveis

Como as empresas localizam vídeos com o Rask, em seus próprios números.
seta
seta
Código

Exemplos de código da API de legendas

Um exemplo completo em cada idioma: envie um vídeo, crie um projeto por idioma de legenda, aguarde e salve os arquivos .srt e .vtt ou adicione-os a um player HTML5.
# pip install git+ssh://[email protected]/braskai/rask-sdk.git@main
import asyncio, urllib.request
from rask_sdk import clients, enums, schemas

LANGS = ["es-mx", "fr-fr", "ja-jp"]

async def subtitle(client, video_id, lang):
    job = await client.create_project(data=schemas.ProjectCreate(video_id=video_id, dst_lang=lang))
    while job.status is not enums.ProjectStatus.MERGING_DONE:
        await asyncio.sleep(10)
        job = await client.get_project(project_id=job.id)
    # links are presigned for one hour - save the files right away
    urllib.request.urlretrieve(job.translation_srt_path, f"video.{lang}.srt")
    urllib.request.urlretrieve(job.translation_vtt_path, f"video.{lang}.vtt")

async def main():
    client = clients.RaskSDKClient(client_id=CLIENT_ID, client_secret=CLIENT_SECRET)
    media = await client.create_media_link(data=schemas.MediaCreateLink(link="https://example.com/onboarding.mp4"))
    while media.status is enums.MediaStatus.PROCESSING:
        await asyncio.sleep(5)
        media = await client.get_media(media_id=media.id)
    await asyncio.gather(*(subtitle(client, media.id, l) for l in LANGS))

asyncio.run(main())
github.com/braskai/rask-sdk
async, typed models
import time, requests

AUTH = "https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token"
API  = "https://api.rask.ai"
token = requests.post(AUTH, auth=(CLIENT_ID, CLIENT_SECRET),
                      data={"grant_type": "client_credentials"}).json()["access_token"]
h = {"Authorization": f"Bearer {token}"}

pid = requests.post(f"{API}/v2/projects", headers=h,
                    json={"video_id": VIDEO_ID, "dst_lang": "de-de"}).json()["id"]
while (p := requests.get(f"{API}/v2/projects/{pid}", headers=h).json())["status"] != "merging_done":
    time.sleep(10)

# translated subtitles: download the files
open("video.de-de.vtt", "wb").write(requests.get(p["translation_vtt_path"]).content)

# original-language captions: build a WebVTT file from the transcript segments
segs = requests.get(f"{API}/v2/projects/{pid}/transcription", headers=h).json()["segments"]
cues = [f"{s['start'].replace(',', '.')} --> {s['end'].replace(',', '.')}\n{s['src']['text']}" for s in segs]
open("video.en.vtt", "w").write("WEBVTT\n\n" + "\n\n".join(cues) + "\n")
requests + polling
same-language captions
// no dependencies, Node 18+ global fetch
import { writeFile } from 'node:fs/promises';
const API = 'https://api.rask.ai';
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const auth = await fetch('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token', {
  method: 'POST',
  headers: { Authorization: 'Basic ' + btoa(`${CLIENT_ID}:${CLIENT_SECRET}`) },
  body: new URLSearchParams({ grant_type: 'client_credentials' }),
}).then((r) => r.json());
const h = { Authorization: `Bearer ${auth.access_token}`, 'Content-Type': 'application/json' };
const call = (method, path, body) => fetch(API + path, { method, headers: h, body: body && JSON.stringify(body) }).then((r) => r.json());

const langs = ['es-mx', 'pt-br', 'ko-kr'];
const tracks = await Promise.all(langs.map(async (dst_lang) => {
  let p = await call('POST', '/v2/projects', { video_id: VIDEO_ID, dst_lang });
  while (p.status !== 'merging_done') { await sleep(10000); p = await call('GET', `/v2/projects/${p.id}`); }
  const file = `subs/${dst_lang}.vtt`;
  await writeFile(file, await ((await fetch(p.translation_vtt_path)).text()));
  return `<track kind="subtitles" srclang="${dst_lang}" src="/${file}">`;
}));
console.log(tracks.join('\n'));   // paste inside your <video> element
fetch, Node 18+
HTML5 track elements
# 1. token (valid 1 hour - cache and reuse it)
TOKEN=$(curl -s -X POST https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token \
  -u "$CLIENT_ID:$CLIENT_SECRET" -d "grant_type=client_credentials" | jq -r .access_token)

# 2. create the project for one subtitle language
ID=$(curl -s -X POST https://api.rask.ai/v2/projects \
  -H "Authorization: Bearer $TOKEN" -H "Content-Type: application/json" \
  -d "{\"video_id\": \"$VIDEO_ID\", \"dst_lang\": \"it-it\"}" | jq -r .id)

# 3. wait for merging_done
until [ "$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN" | jq -r .status)" = merging_done ]; do
  sleep 10
done

# 4. save both subtitle files
P=$(curl -s https://api.rask.ai/v2/projects/$ID -H "Authorization: Bearer $TOKEN")
curl -s -o video.it-it.srt "$(echo $P | jq -r .translation_srt_path)"
curl -s -o video.it-it.vtt "$(echo $P | jq -r .translation_vtt_path)"
download .srt and .vtt
shell script
<?php
use GuzzleHttp\Client;

$http = new Client(['base_uri' => 'https://api.rask.ai']);
$json = fn($r) => json_decode($r->getBody(), true);
$auth = $json((new Client)->post('https://rask-prod.auth.us-east-2.amazoncognito.com/oauth2/token',
    ['auth' => [$clientId, $clientSecret], 'form_params' => ['grant_type' => 'client_credentials']]));
$h = ['Authorization' => 'Bearer ' . $auth['access_token']];

foreach (['es-mx', 'tr-tr'] as $lang) {
    $p = $json($http->post('/v2/projects', ['headers' => $h, 'json' => [
        'video_id' => $videoId, 'dst_lang' => $lang]]));
    while ($p['status'] !== 'merging_done') {
        sleep(10);
        $p = $json($http->get("/v2/projects/{$p['id']}", ['headers' => $h]));
    }
    // presigned links, valid for one hour
    file_put_contents("video.$lang.srt", file_get_contents($p['translation_srt_path']));
    file_put_contents("video.$lang.vtt", file_get_contents($p['translation_vtt_path']));
}
Guzzle 7
plain HTTP
Python é o SDK oficial. As abas Node, PHP e cURL são exemplos simples de HTTP para os mesmos endpoints.
Progresso

Como um projeto de legenda relata o progresso

Cada projeto passa por status documentados, para que os usuários que enviam vídeos no seu aplicativo possam acompanhar o andamento de cada idioma de legenda. Você só precisa interagir com três grupos.

Sucesso, pare por aqui

merging_done
Os arquivos de legenda estão prontos. Acesse o projeto mais uma vez para obter novos links de download.

Em andamento, continue verificando

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
Mais o correspondente _done estados. Eles se encaixam perfeitamente em uma interface de progresso por etapas.

Erro, parar e relatar

failed
upload_failed
transcription_failed
translation_failed
voiceover_failed
merging_failed
no_audio
no_words
forbidden_link
no_audio, no_words e forbidden_link são claros o suficiente para serem exibidos diretamente para o seu próprio usuário.
Observed run, 3:47 source video, en → es-mx
GET /v2/projects/{project_id}
   0s  created
  11s  transcription_started
  87s  translation_started
  99s  voiceover_started
 154s  merging_started
 165s  merging_done

Ou pule as consultas completamente

Aponte para um endpoint de webhook e cada mudança de estado chega como um POST, para que sua fila reaja a cada alteração no momento em que ela acontece. O envio por webhook faz parte da integração empresarial.
Ler a documentação
preserveAspectRatio="xMidYMid meet" aria-hidden="true" role="img">
Saída

Arquivos de legenda primeiro, todo o resto junto

Cada projeto concluído disponibiliza ambos os formatos de legenda, os segmentos de transcrição correspondentes e a mídia dublada. Os links de download são pré-assinados e válidos por uma hora; portanto, copie os arquivos para o seu próprio armazenamento.
Campo
Formato
O que é
translation_srt_path
.srt
Legendas no idioma de destino, para softwares de edição e a maioria das plataformas de vídeo
translation_vtt_path
.vtt
Legendas WebVTT para reprodução de vídeo em HTML5 e players web
/transcription
JSON
Texto original, tradução, identificação do falante e carimbos de data/hora para cada segmento
translated_video
MP4
O vídeo dublado, caso você também publique uma versão com voz
translated_audio
WAV
Fala traduzida misturada com a música e os efeitos sonoros originais
original_video
MP4
Seu arquivo de origem armazenado, para referência
Controle

Corrija uma linha de legenda e regenere apenas essa parte

As legendas vêm dos segmentos da transcrição. Edite o texto ou o tempo de uma linha, regenere, e os arquivos de legenda e a versão dublada serão atualizados juntos. A cobrança cobre os segmentos alterados, com um mínimo de um minuto por execução.

Edição por segmentos

Edição por segmentos
Cada projeto disponibiliza sua transcrição como segmentos acessíveis, então uma palavra errada ou uma legenda atrasada é resolvida com uma simples solicitação de atualização.
Obtenha a transcrição e seus segmentos
Atualize o texto original e nós fazemos a tradução novamente
Edite o texto traduzido diretamente para manter as suas próprias palavras
Ajuste os tempos, adicione segmentos ou exclua segmentos
Altere a voz associada a qualquer falante

Glossários para termos específicos

Glossários para termos específicos
Adicione um glossário para garantir que nomes de marcas e termos técnicos fiquem iguais nas legendas de todos os idiomas, ou mantenha-os no idioma original de propósito.

Um glossário funciona para um par de idiomas e vale para todas as variações regionais desse idioma de destino, ou seja, um único glossário em espanhol atende pt-br e pt-pt igualmente. O registro do projeto versão_do_glossário, garantindo que edições futuras nunca alterem o que já foi finalizado sem que você perceba.
Entrada

Formatos de arquivo compatíveis

Envie um arquivo de vídeo ou áudio compatível ou use uma URL de mídia suportada. Crie um projeto para cada idioma de destino e baixe os arquivos SRT e WebVTT.

Vídeo

7 formatos
.mp4
.mov
.mkv
.avi
.webm
.m4v
.3gp

Áudio

4 formatos
.mp3
.wav
.flac
.m4a

Informações antes de gastar

O endpoint de mídia retorna a duração, o tamanho do arquivo, o codec de vídeo, a taxa de quadros, a resolução, o codec de áudio, a taxa de amostragem e a disposição dos canais. Valide o arquivo e estime o custo com antecedência, pois os projetos são cobrados por minuto de vídeo.
Segurança e conformidade

Segurança e conformidade para o seu conteúdo em vídeo

A Brask Inc possui a certificação SOC 2 Tipo II, opera em conformidade com o GDPR e publica o status de controle em tempo real em seu Centro de Confiança para a sua análise de segurança.

Certificações

SOC 2 Tipo II
GDPR
Membro da CAI e C2PA

Criptografia

TLS 1.2 em trânsito
AES-256 em repouso
Chaves gerenciadas SSE-S3
Rotação de chaves a cada 12 meses no mínimo

Seu conteúdo

Ambiente de IA fechado
Nunca usado para treinar modelos gerais
Exportação completa, sem retenção de dados

Acesso

SSO e SAML
Controle de acesso baseado em funções
Credenciais de cliente OAuth 2.0

Corporativo

Opções de residência de dados
SLAs personalizados
Gerente de contas dedicado

Direitos de voz

Vozes sintéticas com direitos de uso
Clonagem de voz baseada em consentimento
Controles de segurança de IA, humano no circuito
Comparação

API da Rask em comparação com um fluxo de legendas criado por você

As legendas em outro idioma exigem transcrição, tradução, ajuste de tempo e exportação de arquivos. Veja o mesmo resultado montado de duas maneiras.
O que você precisa
Rask API
Montado a partir de partes
Transcrição com carimbos de data/hora
Incluído
Uma API de conversão de fala em texto
Legendas em outro idioma
Mais de 135 opções de idiomas e regiões
Uma API de tradução com ajuste de tempo
Exportação em SRT e WebVTT
Ambos os formatos em cada projeto
Seu próprio criador de arquivos
Terminologia consistente
Glossários
Pós-processamento personalizado
Corrigindo apenas uma linha
Uma solicitação de atualização e depois regenerar
Editar cada arquivo manualmente
Uma versão dublada do mesmo vídeo
Incluído no mesmo projeto
Um fornecedor de TTS mais a sua própria mixagem
Limites de taxa
Nenhum
O que os seus provedores determinarem
Legendas embutidas no vídeo
No aplicativo web da Rask, ainda não na API
Sua própria renderização de vídeo
Fonte, tamanho e layout
Definido no seu player de vídeo
Definido no seu player de vídeo
Perguntas frequentes

API de legendas: perguntas frequentes

Não conseguiu encontrar o que procura? Entre em contato com o departamento de vendas.

A Rask tem uma API de legendas?

Quais formatos de legenda a API retorna?

Posso obter legendas no idioma original?

Quais idiomas são suportados?

A API consegue embutir legendas no vídeo?

Posso alterar a fonte, o tamanho ou o layout das legendas?

As legendas descrevem músicas e efeitos sonoros?

Os locutores são identificados?

Como faço para corrigir uma linha de legenda?

Por quanto tempo os links de download ficam válidos?

Posso usar minhas próprias legendas?

Como a API de legendas é cobrada?

Como obtenho acesso à API e uma chave de API?

Comece a dublar em uma tarde

Faça sua primeira solicitação hoje e fale conosco quando precisar de condições para grande volume ou de um idioma que mais ninguém tem.