Documentação da API

Integrar tradução poderosa em suas aplicações com a nossa API REST simples.

Começar

A TranslateAPI fornece uma interface REST simples para traduzir texto entre 180 mais idiomas. Todos os endpoints da API retornam respostas JSON.

URL da base: https://api.translateapi.ai/api/v1/
Inicio Rápido

Faça o seu primeiro pedido de tradução:

curl -X POST https://api.translateapi.ai/api/v1/translate/ \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -d '{
    "text": "Hello, world!",
    "target_language": "es"
  }'
import requests

response = requests.post(
    "https://api.translateapi.ai/api/v1/translate/",
    headers={
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    json={
        "text": "Hello, world!",
        "target_language": "es"
    }
)

result = response.json()
print(result["translated_text"])  # "Hola, mundo!"
const response = await fetch("https://api.translateapi.ai/api/v1/translate/", {
    method: "POST",
    headers: {
        "Authorization": "Bearer YOUR_API_KEY",
        "Content-Type": "application/json"
    },
    body: JSON.stringify({
        text: "Hello, world!",
        target_language: "es"
    })
});

const result = await response.json();
console.log(result.translated_text);  // "Hola, mundo!"
using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Newtonsoft.Json;

class Program
{
    static async Task Main()
    {
        var client = new HttpClient();
        client.DefaultRequestHeaders.Add(
            "Authorization", "Bearer YOUR_API_KEY"
        );

        var content = new StringContent(
            JsonConvert.SerializeObject(new {
                text = "Hello, world!",
                target_language = "es"
            }),
            Encoding.UTF8,
            "application/json"
        );

        var response = await client.PostAsync(
            "https://api.translateapi.ai/api/v1/translate/",
            content
        );

        var result = await response.Content.ReadAsStringAsync();
        var data = JsonConvert.DeserializeObject<dynamic>(result);
        Console.WriteLine(data.translated_text);  // "Hola, mundo!"
    }
}

Autenticação

Autenticar seus pedidos usando uma chave API. Você pode criar chaves API a partir de sua painel.

Autenticação Header (Recomendado)
Authorization: Bearer ta_your_api_key_here
Parâmetro de Consulta
https://api.translateapi.ai/api/v1/translate/?api_key=ta_your_api_key_here
Mantenha as teclas API seguras! Não os expor no código do lado do cliente ou repositórios públicos.

Traduzir Texto

Traduzir texto para um único idioma alvo.

POST https://api.translateapi.ai/api/v1/translate/
Órgão de Pedido
Parâmetro Tipo Requerido Descrição
text string Sim Texto a traduzir (máx. 50.000 caracteres)
target_language string Sim* Target language code (e.g., "es", "fr", "de")
source_language string Não Source language code. Default: "auto" (auto-detect)

* Utilizar target_language (string) para uma única língua ou target_languages Para múltiplos. Tradução Multi-Target.

Resposta
{
    "translated_text": "Hola, mundo!",
    "source_language": "en",
    "target_language": "es",
    "translations": {
        "es": "Hola, mundo!"
    },
    "character_count": 13,
    "translation_time": 0.45
}

Tradução Multi-Target

Traduzir texto para múltiplos idiomas em um único pedido. Usa o mesmo endpoint que uma única tradução.

Dica: Você pode traduzir até 50 idiomas em um único pedido.
POST https://api.translateapi.ai/api/v1/translate/
Órgão de Pedido
{
    "text": "Hello, world!",
    "target_languages": ["es", "fr", "de", "ja"],
    "source_language": "en"
}

Utilização target_languages Em vez de target_language (string) para múltiplos alvos.

Resposta
{
    "source_language": "en",
    "translations": {
        "es": "Hola, mundo!",
        "fr": "Bonjour, monde!",
        "de": "Hallo, Welt!",
        "ja": "こんにちは、世界！"
    },
    "character_count": 52,
    "translation_time": 2.31
}

Tradução de Lote

Traduzir múltiplos textos de uma vez com processamento de async. Envie um lote e pesquisa para obter resultados.

Limites: máximo 500 textos por lote, máximo 750 itens totais (textos × línguas-alvo). Tempo de saída de trabalho 30 minutos após o início do processamento (o tempo de espera da fila não é contado).
O tempo de processamento varia por linguagem: línguas comuns (espanhol, francês, alemão, etc.) utiliza modelos rápidos (~0.1s por texto), enquanto que línguas menos comuns usam o nosso grande modelo multilingue (~1-3s por texto). Um lote de 100 textos geralmente completa em 10-30 segundos para línguas comuns, ou 2-5 minutos para línguas menos comuns. Para os melhores resultados, envie 1 língua-alvo por pedido de lote e mantenha tamanhos de lote abaixo de 50 textos.
POST https://api.translateapi.ai/api/v1/translate/batch/
Passo 1: Enviar Lote
curl -X POST https://api.translateapi.ai/api/v1/translate/batch/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["Hello", "Goodbye", "Thank you"],
    "target_language": "es",
    "source_language": "en"
}'
Resposta (HTTP 202 Aceitada)
{
    "job_id": "67535b2b-c9e3-4f82-9499-e237edbc1dd8",
    "status": "pending",
    "total_texts": 3,
    "queue_position": 1,
    "source_language": "en",
    "target_languages": ["es"],
    "character_count": 22,
    "credits_remaining": -1,
    "poll_url": "https://api.translateapi.ai/api/v1/jobs/67535b2b-c9e3-4f82-9499-e237edbc1dd8/"
}
Etapa 2: Pesquisa de Resultados
GET https://api.translateapi.ai/api/v1/jobs/{job_id}/
Exemplo de sondagem (Python)
import time, requests

job_id = response.json()["job_id"]
total = response.json()["total_texts"]
headers = {"Authorization": "Bearer YOUR_API_KEY"}

print(f"Batch submitted: {total} texts (job {job_id})")

while True:
    result = requests.get(f"https://api.translateapi.ai/api/v1/jobs/{job_id}/", headers=headers).json()
    status = result["status"]
    processed = result.get("processed_texts", 0)
    progress = result.get("progress_percentage", 0)

    if status == "completed":
        print(f"Completed: {processed}/{total} texts in {result.get('processing_time', 0):.1f}s")
        translations = result["result_data"]["translations"]
        break
    elif status == "failed":
        print(f"Failed at {processed}/{total}: {result.get('error_message', 'unknown')}")
        raise Exception(result.get("error_message", "Translation failed"))
    elif status == "pending":
        queue_pos = result.get("queue_position", "?")
        print(f"Queued (position {queue_pos}) — waiting for GPU worker...")
    else:
        print(f"[{status}] {processed}/{total} ({progress:.0f}%)")

    time.sleep(3)
Resposta (em função — na fila, à espera da GPU)
{
    "job_id": "67535b2b-...",
    "status": "pending",
    "processed_texts": 0,
    "total_texts": 3,
    "progress_percentage": 0.0,
    "queue_position": 3
}
Resposta (durante o processamento)
{
    "job_id": "67535b2b-...",
    "status": "processing",
    "processed_texts": 1,
    "total_texts": 3,
    "progress_percentage": 33.33,
    "queue_position": null
}
Resposta (completada)
{
    "job_id": "67535b2b-...",
    "status": "completed",
    "processed_texts": 3,
    "total_texts": 3,
    "progress_percentage": 100.0,
    "processing_time": 10.65,
    "result_data": {
        "translations": ["Hola", "Adiós", "Gracias"],
        "source_language": "en",
        "target_language": "es",
        "character_count": 22,
        "processing_time": 10.65
    }
}
Seguimento do progresso em tempo real

Cada resposta da pesquisa inclui campos de progresso em tempo real para que você possa monitorar exatamente o que está acontecendo com o seu lote:

Campo Descrição
status Estado do trabalho atual: pending (em fila, à espera de um trabalhador do GPU), processing (traduzir ativamente), completed, failed
processed_texts Número de traduções individuais completadas até agora. Atualizações em tempo real como cada texto é traduzido.
total_texts Número total de traduções neste lote (textos × línguas-alvo).
progress_percentage Percentagem de conclusão (0-100). Calculada a partir de textos_processados/textos_total.
queue_position Sua posição na fila quando o estado está "pendido" (1 = próximo). Null ao processar ou completar. Use isto para estimar o tempo de espera e mostrar o estado da fila aos seus usuários.
processing_time Tempo total de processamento em segundos (disponível quando completado).
Dica: Quando status é "pending", os trabalhadores da GPU estão ocupados com outros lotes. queue_position Para ver quantos trabalhos estão à sua frente (1 = você é o próximo). Seu trabalho vai começar automaticamente — nenhuma ação necessária, apenas continuar a votar.
Melhores práticas para grandes cargas de trabalho
  • Envie 1 idioma-alvo por pedido de lote. Isto mantém cada lote rápido e torna o progresso fácil de rastrear.
  • Manter lotes em 50-100 textos. Lotes menores completam mais rápido e lhe dão atualizações de progresso mais frequentes.
  • Execute no máximo 2 trabalhos em lote concorrentes. O GPU processa 2 lotes em paralelo — fila de trabalhos adicionais e não vai começar mais rápido.
  • No tempo de espera, re-poll o mesmo job_id em vez de enviar um novo lote. O trabalho original pode ainda estar processando na GPU.
  • Enquete a cada 3-5 segundos. A sondagem mais frequente não acelera o processamento.
Lote Multi-Língua

Traduzir múltiplos textos para múltiplos idiomas de uma vez:

{
    "texts": ["Hello", "Goodbye"],
    "target_languages": ["es", "fr"],
    "source_language": "en"
}
Data_de_resultado Completado
{
    "translations": [
        {"es": "Hola", "fr": "Bonjour"},
        {"es": "Adiós", "fr": "Au revoir"}
    ],
    "source_language": "en",
    "target_languages": ["es", "fr"],
    "character_count": 24,
    "processing_time": 2.45
}
Parâmetros de Pedido
Parâmetro Tipo Requerido Descrição
texts array Sim Array de cordas para traduzir
target_language string Sim* Código da língua-alvo para uma única língua
target_languages array Sim* Array de códigos de língua-alvo para múltiplas línguas
source_language string Não Source language code. Default: "auto"

* Fornecer qualquer target_language ou target_languages, não ambos.

Processamento de Async: Lote pedidos retornar imediatamente com um job_id. Ensaio GET /api/v1/jobs/{job_id}/ até status é "completed", então ler result_data para traduções. progress_percentage Para acompanhar o progresso.

Tradução do documento

Traduzir documentos inteiros ao preservar a formatação. Suporta vários formatos de arquivo.

POST https://api.translateapi.ai/api/v1/translate/document/
Pedido (multipart/formulário)
Parâmetro Tipo Requerido Descrição
file file Sim O documento a traduzir (máx. 10MB)
target_language string Sim Target language code (e.g., "es", "fr", "de")
source_language string Não Source language code. Default: "auto" (auto-detect)
Tipos de Ficheiros Suportados
  • .txt - Ficheiros de texto simples
  • .docx - Documentos-chave
  • .pdf - Documentos PDF (incluindo escaneados)
  • .json - Arquivos JSON (traduzir os valores de string)
  • .xml - Ficheiros XML
  • .srt - Ficheiros de subtítulos
  • .po / .pot - Ficheiros de tradução do Gettext
  • .jpg / .jpeg - Imagens JPEG (OCR)
  • .png - Imagens PNG (OCR)
  • .tiff / .tif - Imagens TIFF (OCR)
  • .bmp - Imagens BMP (OCR)
  • .webp - Imagens WebP (OCR)
Suporte do OCR: Os arquivos de imagem e PDF digitalizados são processados com reconhecimento óptico de caracteres (OCR) para extrair texto antes da tradução. Para os melhores resultados, use imagens claras e de alta resolução.
Exemplo (cURL)
# Translate a Word document
curl -X POST https://api.translateapi.ai/api/v1/translate/document/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@document.docx" \
  -F "target_language=es" \
  -F "source_language=en"

# Translate text from an image (OCR)
curl -X POST https://api.translateapi.ai/api/v1/translate/document/ \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@scanned_page.jpg" \
  -F "target_language=es" \
  -F "source_language=en"
Os arquivos de imagem são processados com OCR para extrair texto antes da tradução. A saída traduzida é devolvida como um .txt arquivo.
Resposta
{
    "id": 123,
    "original_filename": "document.docx",
    "file_type": "docx",
    "source_language": "en",
    "target_language": "es",
    "status": "completed",
    "character_count": 5420,
    "translated_file_url": "/media/translated/document_es.docx",
    "created_at": "2024-01-15T10:30:00Z",
    "completed_at": "2024-01-15T10:30:05Z"
}
Valores de Estado
pending Ficheiro carregado, à espera de ser processado
processing Tradução em curso
completed Tradução completa, download disponível
failed A tradução falhou (verifique o erro_mensagem)
GET https://api.translateapi.ai/api/v1/translate/document/{id}/

Verifique o estado de tradução de um documento ou recupere a URL do download.

Resposta
{
    "id": 123,
    "original_filename": "document.docx",
    "status": "completed",
    "translated_file_url": "/media/translated/document_es.docx",
    "character_count": 5420
}

Detecção de Línguas

A detecção de idiomas é incorporada em cada pedido de tradução. source_language to "auto" (ou omitir) e a língua detectada é devolvida na resposta.

POST https://api.translateapi.ai/api/v1/translate/
Órgão de Pedido
{
    "text": "Bonjour, comment allez-vous?",
    "target_language": "en"
}
Resposta
{
    "translated_text": "Hello, how are you?",
    "source_language": "fr",
    "target_language": "en",
    "translations": {
        "en": "Hello, how are you?"
    },
    "character_count": 28,
    "translation_time": 0.52
}

O source_language campo na resposta mostra a linguagem detectada quando a autodetecção é utilizada.

Línguas Suportadas

Obtenha a lista de todas as línguas suportadas.

GET https://api.translateapi.ai/api/v1/translate/languages/
Resposta
{
    "count": 186,
    "results": [
        {"iso": "en", "name": "English", "en_label": "English"},
        {"iso": "es", "name": "Español", "en_label": "Spanish"},
        {"iso": "fr", "name": "Français", "en_label": "French"},
        ...
    ]
}

Modelos de Tradução

Utilizamos modelos de tradução de código aberto de última geração que funcionam em nossa própria infraestrutura GPU. Todos os modelos são licenciados comercialmente (Apache 2.0).

Modelo Línguas Melhor para
Helsinki-NLP/opus-mt 50+ pares de línguas Línguas comuns (EN, ES, FR, DE, IT, PT, RU, ZH, JA, etc.)
Google MADLAD-400 400+ línguas Línguas raras, cobertura abrangente

A API seleciona automaticamente o melhor modelo para o seu par de idiomas. Você pode opcionalmente especificar um engine parâmetro:

Motor Descrição
"auto" Por defeito. Tria HuggingFace primeiro, volta para MADLAD-400
"huggingface" Força HuggingFace/MarianMT (mais rápido, 50+ línguas)
"madlad" Força MADLAD-400 (400+ línguas)

Tratamento de Erros

A API usa códigos de estado HTTP padrão para indicar sucesso ou falha.

Código Descrição
200 Sucesso
400 Pedido Incorreto - Parâmetros inválidos
401 Não autorizado - Inválido ou faltando chave API
402 Pagamento exigido - Contingente de caráter diário excedido
429 Demasiados pedidos - limite de taxa excedido
503 Serviço não disponível - Motor de tradução temporariamente para baixo
Formato de Resposta de Erro
{
    "error": "daily_limit_exceeded",
    "credits_remaining": 0,
    "daily_limit": 100000
}

Limites de taxa

Os limites variam por plano. Preços Para detalhes completos:

Plano Características/Mes Preço
Grátis 250,000 $0 Inscreva-se gratuitamente
Início 2,500,000 $9/mo Subscrever
Pro 10,000,000 $29/mo Subscrever
Negócios 40,000,000 $79/mo Subscrever
Escala 125,000,000 $199/mo Subscrever

Quando exceder o seu limite, você receberá um 429 Too Many Requests resposta até o próximo mês ou você atualiza.

Auto-Scaling Cloud Infrastructure

TranslateAPI runs on dedicated NVIDIA A100 GPU instances with automatic horizontal scaling. When demand increases, additional GPU instances are launched within minutes to maintain fast response times. This means our API can handle virtually unlimited concurrent requests without degradation — from a single request to thousands per minute.

Avaliar esta página
Obrigado pela sua classificação!
/5 baseado em Notas