Referência da API

A API RAVIRA oferece acesso programático a traduções de nível profissional, com terminologia consistente. Autentique-se com um token Bearer e comece a traduzir em poucos minutos.

URL basehttps://ravira.dev/api/v1

Início rápido

Três passos para a sua primeira tradução:

  1. 1. Crie uma conta em ravira.dev/register
  2. 2. Compre um pacote de caracteres e gere uma chave de API em Configurações → API
  3. 3. Faça sua primeira solicitação:
curl -X POST https://ravira.dev/api/v1/translate \
  -H "Authorization: Bearer rk_live_YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"text": "Hello, world!", "source_lang": "en", "target_lang": "ro"}'

Resposta:

{
  "translated_text": "Bună ziua, lume!",
  "characters_charged": 13,
  "source_lang": "en",
  "target_lang": "ro"
}

Autenticação

Todas as solicitações à API exigem um token Bearer no cabeçalho Authorization da solicitação. As chaves de API começam com rk_live_ e são geradas nas configurações da sua conta.

Importante: A sua chave de API é apresentada apenas uma vez, quando é criada. Guarde-a num local seguro: não é possível recuperá-la.
Authorization: Bearer rk_live_YOUR_API_KEY

Endpoints

POST/api/v1/translate

Traduz texto. Requer autenticação. Os caracteres são cobrados apenas quando a solicitação é bem-sucedida.

ParâmetroTipoObrigatórioDescrição
textstringSimTexto a traduzir (máx. 100.000 caracteres)
source_langstringNãoCódigo do idioma de origem. Padrão: auto
target_langstringNãoCódigo do idioma de destino. Padrão: en
GET/api/v1/usage

Retorna o saldo e o uso atuais de caracteres. Requer autenticação.

curl https://ravira.dev/api/v1/usage \
  -H "Authorization: Bearer rk_live_YOUR_API_KEY"
{
  "characters_balance": 500000,
  "characters_used": 12500,
  "characters_expires_at": "2027-01-01T00:00:00"
}
GET/api/v1/languages

Retorna a lista de idiomas suportados. Não requer autenticação.

curl https://ravira.dev/api/v1/languages

Exemplos de código

Python

import requests

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def translate(text, target_lang="ro", source_lang="auto"):
    response = requests.post(
        f"{BASE_URL}/translate",
        headers={"Authorization": f"Bearer {API_KEY}"},
        json={"text": text, "source_lang": source_lang, "target_lang": target_lang}
    )
    response.raise_for_status()
    return response.json()["translated_text"]

result = translate("Hello, world!", target_lang="ro")
print(result)  # Bună ziua, lume!

JavaScript

const API_KEY = "rk_live_YOUR_API_KEY";
const BASE_URL = "https://ravira.dev/api/v1";

async function translate(text, targetLang = "ro", sourceLang = "auto") {
  const response = await fetch(`${BASE_URL}/translate`, {
    method: "POST",
    headers: {
      "Authorization": `Bearer ${API_KEY}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ text, source_lang: sourceLang, target_lang: targetLang }),
  });
  if (!response.ok) throw new Error(`HTTP ${response.status}`);
  const data = await response.json();
  return data.translated_text;
}

const result = await translate("Hello, world!", "ro");
console.log(result); // Bună ziua, lume!

Aplicações de IA (MCP)

A RAVIRA executa um servidor Model Context Protocol (MCP). Aplicações de IA compatíveis com servidores MCP remotos, como Claude, ChatGPT, Cursor, VS Code e Claude Code, podem traduzir com a RAVIRA e a sua terminologia verificada diretamente num chat, editor ou terminal, usando o seu saldo RAVIRA.

URL do servidor

https://ravira.dev/mcp

Como estabelecer ligação

  1. Adicione https://ravira.dev/mcp como servidor MCP remoto (HTTP) na sua aplicação.
  2. O navegador abre a página de ligação da RAVIRA. Inicie sessão, se necessário.
  3. Verifique o domínio apresentado na página, reveja o acesso solicitado e autorize.
  4. A aplicação aparece no seu Perfil, no separador API, em Aplicações ligadas, onde pode desligar a ligação a qualquer momento.

Exemplos de configuração

Os menus podem mudar entre versões da aplicação; o URL do servidor é sempre o mesmo.

Claude (claude.ai e as aplicações Claude)

Definições, Conectores, Adicionar conector personalizado e, em seguida, cole o URL do servidor.

Claude Code (terminal)

claude mcp add --transport http ravira https://ravira.dev/mcp

Em seguida, execute /mcp no Claude Code para iniciar sessão.

Cursor

{
  "mcpServers": {
    "ravira": { "url": "https://ravira.dev/mcp" }
  }
}

VS Code (.vscode/mcp.json)

{
  "servers": {
    "ravira": { "type": "http", "url": "https://ravira.dev/mcp" }
  }
}

ChatGPT

Nas definições, abra Conectores (poderá ser necessário ativar o modo de programador) e crie um conector personalizado com o URL do servidor.

Ferramentas disponíveis

FerramentaO que fazPermissão
ravira_translateTraduz textos com terminologia verificada e o seu glossáriomcp_translate
ravira_usageApresenta o seu saldo de caracteresmcp_usage
ravira_languagesLista os idiomas suportadosmcp_languages
ravira_user_glossaryLê e edita o seu glossário pessoalmcp_glossary

Permissões e segurança

  • Cada aplicação recebe apenas o acesso que autorizar na página de ligação do RAVIRA.
  • As aplicações verificadas, como o Claude, ligam-se sem aviso. As outras são identificadas Não verificada e exigem confirmação explícita. As aplicações executadas no seu próprio computador (localhost), como editores e ferramentas de linha de comandos, são identificadas como tal.
  • As aplicações não verificadas não têm acesso ao seu glossário pessoal, a menos que o solicitem e que autorize o acesso.
  • Uma aplicação ligada só pode traduzir e ler o que as respetivas permissões permitem. Não pode gerir a sua conta, as chaves de API nem os pagamentos.
  • Ao repor a palavra-passe através de «Esqueceu-se da palavra-passe?», todas as aplicações são desligadas e todas as chaves de API são revogadas.

Em alternativa, use uma chave de API

As aplicações que permitem definir cabeçalhos personalizados podem usar uma chave de API em vez de iniciar sessão:

Authorization: Bearer rk_live_YOUR_API_KEY

As ligações feitas com uma chave de API não aparecem em Aplicações ligadas. Para as interromper, revogue a chave na lista de chaves de API.

Códigos de erro

HTTPCódigo de erroDescrição
401invalid_api_keyChave de API ausente, inválida ou revogada.
402insufficient_balanceA conta não tem mais caracteres disponíveis. Compre mais em ravira.dev/topup.
429rate_limit_exceededMuitas solicitações. Reduza o ritmo e tente novamente após o número de segundos indicado em retry_after.
400validation_errorParâmetros da solicitação inválidos.
500server_errorErro interno do servidor. Tente novamente após um breve intervalo.

Limites de uso

Os limites de uso são aplicados por conta, não por chave de API.

  • 60 solicitações/minuto por conta, em todas as chaves de API
  • Quando excedido, a API retorna HTTP 429 com o campo retry_after (em segundos)
  • Até 5 chaves de API por conta, para organizar projetos

Casos de uso

Comércio eletrônico

Anúncios de produtos multilíngues

Um vendedor na Amazon ou no eBay quer publicar produtos automaticamente em 5 idiomas. Uma chamada à API por idioma, com terminologia consistente em todos os mercados.

import requests

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def translate_product(product):
    languages = {"ro": "Romanian", "de": "German", "fr": "French", "es": "Spanish"}
    translations = {}
    for lang_code, lang_name in languages.items():
        response = requests.post(
            BASE_URL + "/translate",
            headers={"Authorization": "Bearer " + API_KEY},
            json={"text": product["title"] + "

" + product["description"],
                  "source_lang": "en", "target_lang": lang_code}
        )
        translations[lang_code] = response.json()["translated_text"]
    return translations

product = {
    "title": "Wireless Noise-Cancelling Headphones",
    "description": "Premium over-ear headphones with 30-hour battery."
}
result = translate_product(product)
SaaS

Notificações localizadas para usuários

Uma plataforma SaaS traduz todos os modelos de notificação quando um novo utilizador define o idioma preferido. Sem ficheiros de tradução estáticos: traduções dinâmicas e sempre atualizadas.

const API_KEY = "rk_live_YOUR_API_KEY";
const BASE_URL = "https://ravira.dev/api/v1";

async function localizeNotifications(userId, targetLang) {
  const templates = {
    welcome: "Welcome to our platform! Your account is ready.",
    trial_ending: "Your free trial ends in 3 days.",
    payment_success: "Payment confirmed. Thank you!",
    usage_alert: "You have used 80% of your monthly quota."
  };
  const localized = {};
  for (const [key, text] of Object.entries(templates)) {
    const res = await fetch(BASE_URL + "/translate", {
      method: "POST",
      headers: {
        "Authorization": "Bearer " + API_KEY,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({ text, source_lang: "en", target_lang: targetLang })
    });
    localized[key] = (await res.json()).translated_text;
  }
  return localized;
}

// New user from Romania
localizeNotifications("user_123", "ro").then(t => {
  console.log(t.welcome);
});
Legal

Pré-tradução de contratos

Um escritório de advocacia recebe contratos em línguas estrangeiras e precisa de uma pré-tradução rápida antes de enviá-los a um tradutor juramentado. A terminologia jurídica consistente reduz o tempo de revisão.

import requests

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def pretranslate_contract(contract_text, source_lang):
    """Pre-translate a contract for internal review."""
    response = requests.post(
        BASE_URL + "/translate",
        headers={"Authorization": "Bearer " + API_KEY},
        json={
            "text": contract_text,
            "source_lang": source_lang,
            "target_lang": "en"
        }
    )
    return response.json()["translated_text"]

# Translate a German contract for English-speaking lawyers
with open("vertrag_2026.txt", "r") as f:
    german_contract = f.read()

english_draft = pretranslate_contract(german_contract, "de")
print("Pre-translation ready for legal review.")
print(english_draft[:200])
Jornalismo

Monitoramento de notícias internacionais

Uma redação monitora fontes internacionais e traduz automaticamente artigos relevantes para os editores. O processo é executado como tarefa agendada a cada hora.

import requests
import schedule
import time

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def translate_article(article, source_lang):
    response = requests.post(
        BASE_URL + "/translate",
        headers={"Authorization": "Bearer " + API_KEY},
        json={"text": article, "source_lang": source_lang, "target_lang": "en"}
    )
    return response.json()["translated_text"]

def monitor_and_translate():
    # Fetch articles from your news source here
    articles = [
        {"text": "Neue Wirtschaftsdaten zeigen starkes Wachstum...", "lang": "de"},
        {"text": "Les negociations commerciales reprennent...", "lang": "fr"},
    ]
    for article in articles:
        translated = translate_article(article["text"], article["lang"])
        print("Translated:", translated[:80] + "...")

# Run every hour
schedule.every().hour.do(monitor_and_translate)
monitor_and_translate()  # Run immediately on start
RH

Anúncios de vagas multilíngues

Uma empresa que publica vagas em toda a Europa traduz automaticamente cada anúncio. Um conteúdo original em inglês, publicado em 6 idiomas em segundos.

const API_KEY = "rk_live_YOUR_API_KEY";
const BASE_URL = "https://ravira.dev/api/v1";

const TARGET_MARKETS = ["de", "fr", "es", "it", "pl", "ro"];

async function publishJobPosting(jobDescription) {
  const postings = {};
  for (const lang of TARGET_MARKETS) {
    const res = await fetch(BASE_URL + "/translate", {
      method: "POST",
      headers: {
        "Authorization": "Bearer " + API_KEY,
        "Content-Type": "application/json"
      },
      body: JSON.stringify({
        text: jobDescription,
        source_lang: "en",
        target_lang: lang
      })
    });
    postings[lang] = (await res.json()).translated_text;
  }
  console.log("Published in " + Object.keys(postings).length + " languages");
  return postings;
}

const job = "Senior Backend Engineer. Remote. Competitive salary.";
publishJobPosting(job);
Técnico

Documentação do software

Uma ferramenta para desenvolvedores traduz sua documentação para alcançar usuários internacionais. Os arquivos Markdown são traduzidos, enquanto os blocos de código permanecem intactos.

import requests
import re

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def translate_markdown(md_text, target_lang):
    """Translate markdown, preserving code blocks."""
    # Extract code blocks before translation
    code_blocks = {}
    def save_code(match):
        key = f"CODE_BLOCK_{len(code_blocks)}"
        code_blocks[key] = match.group(0)
        return key
    protected = re.sub(r"```[\s\S]*?```", save_code, md_text)
    # Translate text only
    response = requests.post(
        BASE_URL + "/translate",
        headers={"Authorization": "Bearer " + API_KEY},
        json={"text": protected, "source_lang": "en", "target_lang": target_lang}
    )
    translated = response.json()["translated_text"]
    # Restore code blocks
    for key, block in code_blocks.items():
        translated = translated.replace(key, block)
    return translated

with open("README.md") as f:
    readme = f.read()
translated_readme = translate_markdown(readme, "ro")
print(translated_readme[:300])
Medicina

Formulários de admissão de pacientes

Uma clínica traduz formulários de admissão de pacientes internacionais. Para uso interno e conforto dos pacientes, o conteúdo é sempre revisto por profissionais médicos qualificados antes de qualquer decisão clínica.

import requests

API_KEY = "rk_live_YOUR_API_KEY"
BASE_URL = "https://ravira.dev/api/v1"

def translate_intake_form(form_data, patient_lang):
    """
    Translate patient intake form for non-English speaking patients.
    For internal use only. Always reviewed by qualified medical staff.
    """
    fields_to_translate = [
        "chief_complaint", "medical_history", "current_medications", "allergies"
    ]
    translated = {}
    for field in fields_to_translate:
        if field in form_data:
            response = requests.post(
                BASE_URL + "/translate",
                headers={"Authorization": "Bearer " + API_KEY},
                json={
                    "text": form_data[field],
                    "source_lang": patient_lang,
                    "target_lang": "en"
                }
            )
            translated[field] = response.json()["translated_text"]
    return translated

patient_form = {
    "chief_complaint": "Durere puternica in piept de 2 zile",
    "allergies": "Penicilina, Ibuprofen"
}
english_form = translate_intake_form(patient_form, "ro")
print("For medical staff review:", english_form)

Pronto para começar?

Gere a sua chave de API em segundos. Sem taxas de configuração nem subscrições: paga apenas pelos caracteres traduzidos.

Dúvidas? Escreva-nos para humans@ravira.dev