API de legendas para ficheiros SRT e VTT traduzidos

Carregue um vídeo uma vez e obtenha ficheiros de legendas em SRT e WebVTT para cada idioma de destino, sincronizados com o conteúdo falado. Corrija qualquer linha através da API e descarregue os ficheiros atualizados para o seu leitor, aplicação ou software de edição de vídeo.
SRT e WebVTT
Mais de 135 opções de idiomas e regiões
REST + SDK 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)"
Utilizado por equipas globais
Funcionalidades

Tudo o que a API de legendas devolve

Crie ficheiros SRT e WebVTT traduzidos a partir de gravações de vídeo ou áudio, incluindo podcasts e entrevistas. Escolha um idioma de destino para cada projeto e obtenha ficheiros de legendas juntamente com a transcrição, tradução e conteúdo dobrado.

Ficheiros SRT e WebVTT

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

Legendas noutrom idioma

Remova as barreiras linguísticas para os espetadores em todos os mercados: crie um projeto por idioma de destino, como es-mx, pt-br ou fr-ca, a partir do mesmo upload. O idioma de origem é detetado automaticamente.

Sincronizado com o conteúdo falado

Cada legenda acompanha um segmento da transcrição com um tempo de início e fim, para que cada linha apareça no ecrã enquanto é falada.

Legendas no idioma original

A transcrição contém o texto de origem de cada segmento com caraterísticas temporais. Converta-o num ficheiro SRT ou VTT para legendas no mesmo idioma em poucas linhas de código.

Etiquetas de orador para diálogos

Cada segmento da transcrição inclui uma etiqueta de orador, permitindo-lhe adicionar a identificação do orador às legendas em entrevistas, painéis e diálogos.

Edite uma linha antes de publicar

Corrija o texto ou o tempo de qualquer segmento através da API e regenere. Palavras pouco claras, nomes e sotaques são corrigidos de uma vez só, em todos os formatos.

Termos consistentes em todos os idiomas

Um glossário mantém os nomes de produtos e termos técnicos idênticos em todos os idiomas de legendas, ou no idioma original de propósito.

Legendas e uma versão dobrada

O mesmo projeto também devolve as faixas de vídeo e áudio traduzidas, pelo que as legendas e a versão dobrada provêm de um único upload.

Cresça sem limites

Sem limites de taxa, sem quota de concorrência, sem limitações por chave. Legende toda a sua biblioteca de vídeos em cada idioma de destino em paralelo.
Veja como funciona

Um vídeo, cinco versões de idiomas

O mesmo clip em inglês, francês, alemão, português e espanhol. Cada versão de idioma inclui os seus próprios ficheiros de legendas SRT e VTT.
EN flag
En
FR flag
Fr
DE flag
De
PT flag
Pt
ES flag
Es
Fluxo de trabalho

Três pedidos desde o envio do vídeo até ao ficheiro de legendas

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

Carregar o seu vídeo

Envie o vídeo como um ficheiro ou partilhe um link do YouTube, Google Drive, S3, Vimeo ou qualquer URL direto. Um único envio serve para todos os idiomas de legendas.

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

Criar o projeto

Passe o ID de multimé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

Descarregue os ficheiros de legendas

Consulte o estado até atingir merging_done, depois descarregue os ficheiros .srt e .vtt e guarde-os do seu lado.

GET /v2/projects/{project_id}
O tempo de processamento varia consoante a duração do vídeo, o número de locutores e o idioma de destino. Numa execução observada, um vídeo de 3:47 ficou pronto em 165 segundos.
Criado a pensar em si

Precisa de um formato de legendas ou de uma entrega que não está listada? Fale com a nossa equipa

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

Idiomas e vozes

Precisa de legendas num idioma fora do catálogo público? Fale com a nossa equipa sobre os seus requisitos e as opções disponíveis.

Entrega e integração

Webhooks, envio direto para a sua própria fila, entrega direta no seu S3, pontos de extremidade personalizados. Diga-nos como é que o seu sistema prefere receber os dados.

Volume e capacidade

Os tamanhos dos lotes, os idiomas de destino por ação e a prioridade de processamento são termos contratuais e não limites fixos do produto.

Segurança e alojamento

A residência de dados, o SSO e SAML, as regras de retenção e o suporte a auditorias de segurança são tratados como parte da integração empresarial.
Casos de utilização

Quem utiliza uma API de legendas

Plataformas com vídeo integrado

Plataformas de LMS e formação de clientes, plataformas de criadores e vídeo, ferramentas de webinars e eventos virtuais, SaaS de alojamento de vídeo e fluxos de trabalho, plataformas de adoção digital, live shopping. Transforme legendas em todos os idiomas numa funcionalidade dos seus envios de vídeo.

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

Forneça ficheiros SRT e VTT para cada idioma de cliente a partir de um único envio. Os revisores corrigem as linhas através da API e os ficheiros são atualizados sem que ninguém precise de os sincronizar novamente.

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

Retalho internacional e comércio eletrónico, franquias globais, editores de média, universidades corporativas. Torne a formação e o conteúdo de vídeo de produtos acessíveis a todos os mercados e a espectadores que assistem sem som.
Histórias de clientes

Equipas reais, resultados mensuráveis

Como as empresas localizam vídeos com a Rask, através dos seus próprios números.
seta
seta
Código

Exemplos de código da API de legendas

Um exemplo completo em cada idioma: carregar um vídeo, criar um projeto por idioma de legendas, aguardar e, em seguida, guardar os ficheiros .srt e .vtt ou adicioná-los a um leitor 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
O Python é o SDK oficial. Os separadores Node, PHP e cURL são exemplos simples de HTTP para os mesmos pontos de finalização.
Progresso

Como um projeto de legendas reporta o progresso

Cada projeto passa por estados documentados, para que os utilizadores que enviam vídeos na sua aplicação possam acompanhar o progresso de cada idioma de legendas. Só precisa de agir sobre três grupos.

Concluído com sucesso, parar por aqui

merging_done
Os ficheiros de legendas estão prontos. Obtenha o projeto mais uma vez para receber links de descarga atualizados.

Em progresso, continuar a verificar

created
uploading
transcription_started
separate_background_started
determine_speakers_started
translation_started
voiceover_started
merging_started
Para além da correspondência _done estados. Estes correspondem perfeitamente a uma interface de progresso por etapas.

Falha, parar e reportar

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 suficientemente específicos para serem mostrados diretamente ao seu próprio utilizador.
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 ignore a consulta de estado por completo

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

Ficheiros de legendas primeiro, tudo o resto em simultâneo

Cada projeto concluído disponibiliza ambos os formatos de legendas, os segmentos de transcrição subjacentes e os conteúdos multimédia dobrados. Os links de descarga são pré-assinados e válidos por uma hora, por isso copie os ficheiros para o seu próprio armazenamento.
Campo
Formato
O que é
translation_srt_path
.srt
Legendas no idioma de destino, para software 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 leitores web
/transcription
JSON
Texto de origem, tradução, identificação do orador e marcas temporais para cada segmento
translated_video
MP4
O vídeo dobrado, caso também publique uma versão dobrada
translated_audio
WAV
Discurso traduzido misturado com a música original e efeitos sonoros
original_video
MP4
O seu ficheiro de origem tal como foi guardado, para referência
Controlo

Corrija uma linha de legendas e regenere apenas essa parte

As legendas provêm dos segmentos da transcrição. Edite o texto ou o tempo de uma linha, regenere, e os ficheiros de legendas e a versão dobrada atualizam-se em conjunto. A faturação cobre os segmentos alterados, com um mínimo de um minuto por execução.

Edição ao nível de segmento

Edição ao nível de segmento
Cada projeto disponibiliza a sua transcrição como segmentos acessíveis, pelo que uma palavra errada ou uma legenda desfasada resolve-se com um único pedido de atualização.
Obter a transcrição e os respetivos segmentos
Alterar o texto de origem para traduzirmos novamente
Alterar o texto traduzido diretamente para manter as suas próprias palavras
Ajustar os carateres temporais, adicionar segmentos, eliminar segmentos
Reatribuir a voz associada a qualquer orador

Glossários para terminologia

Glossários para terminologia
Associe um glossário para garantir que os nomes de marca e os termos técnicos são lidos da mesma forma nas legendas de todos os idiomas, ou mantidos no idioma original de propósito.

Um glossário abrange um par de línguas e aplica-se a todas as variantes regionais dessa língua de destino, pelo que um único glossário de espanhol serve es-mx e es-es igualmente. O registo do projeto glossary_version, para que edições posteriores nunca alterem silenciosamente o trabalho concluído.
Entrada

Formatos de ficheiro suportados

Carregue um vídeo ou uma gravação de áudio suportados, ou utilize um URL de multimédia suportado. Crie um projeto para cada idioma de destino e descarregue os respetivos ficheiros SRT e WebVTT.

Vídeo

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

Áudio

4 formatos
.mp3
.wav
.flac
.m4a

Metadados antes de gastar

O ponto final de multimédia devolve a duração, o tamanho do ficheiro, o codec de vídeo, a frequência de fotogramas, a resolução, o codec de áudio, a taxa de amostragem e a disposição dos canais. Valide um ficheiro e estime o custo com antecedência, uma vez que os projetos são faturados por minuto de vídeo.
Segurança e conformidade

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

A Brask Inc possui a certificação SOC 2 Type II, opera em conformidade com o RGPD e publica o estado de controlo em direto no seu Centro de Confiança para a sua análise de segurança.

Certificações

SOC 2 Type II
GDPR
Membro da CAI e C2PA

Encriptação

TLS 1.2 em trânsito
AES-256 em repouso
Chaves geridas SSE-S3
Rotação de chaves pelo menos a cada 12 meses

O seu conteúdo

Ambiente de IA fechado
Nunca utilizado para treinar modelos gerais
Exportação completa, sem dependência de fornecedor

Acesso

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

Empresa

Opções de residência de dados
SLA personalizados
Gestor de conta dedicado

Direitos de voz

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

API da Rask em comparação com um canal de legendas criado por si

As legendas noutra língua exigem transcrição, tradução, sincronização temporal e exportação de ficheiros. Eis o mesmo resultado, obtido de duas formas diferentes.
O que precisa
Rask API
Montado a partir de peças
Transcrição com marcas temporais
Incluído
Uma API de conversão de voz em texto
Legendas noutrom idioma
Mais de 135 opções de idiomas e regiões
Uma API de tradução com nova sincronização temporal
Exportação em SRT e WebVTT
Ambos os formatos em cada projeto
O seu próprio criador de ficheiros
Terminologia consistente
Glossários
Pós-processamento personalizado
Corrigir uma linha
Um pedido de atualização e, em seguida, regenerar
Editar cada ficheiro manualmente
Uma versão dobrada do mesmo vídeo
Incluído no mesmo projeto
Um fornecedor de TTS mais a sua própria mistura
Limites de taxa
Nenhum
Tudo o que os seus fornecedores impõem
Legendas integradas no vídeo
Na aplicação web da Rask, ainda não na API
A sua própria renderização de vídeo
Tipo de letra, tamanho e esquema
Definido no seu leitor de vídeo
Definido no seu leitor de vídeo
Perguntas frequentes

API de legendas: perguntas frequentes

Não consegue encontrar o que procura? Contacte o departamento de vendas.

A Rask tem uma API de legendas?

Quais são os formatos de legendas devolvidos pela API?

Posso obter legendas no idioma original?

Que idiomas são suportados?

A API consegue integrar legendas no vídeo?

Posso alterar o tipo de letra, o tamanho ou o esquema das legendas?

As legendas descrevem a música e os efeitos sonoros?

Os oradores são identificados?

Como posso corrigir uma linha de legendas?

Durante quanto tempo são válidas as ligações de transferência?

Posso utilizar as minhas próprias legendas?

Como é faturada a API de legendas?

Como obtenho acesso à API e uma chave de API?

Comece a dobrar numa tarde

Faça o seu primeiro pedido hoje e fale connosco quando precisar de termos de volume ou de um idioma que mais ninguém tem.