API RAVIRAv1
Gestionează cheile API →

Referință API

API-ul RAVIRA îți oferă acces programatic la servicii de traducere de nivel profesional, cu terminologie consecventă. Autentifică-te cu un token Bearer și începe să traduci în câteva minute.

URL de bazăhttps://ravira.dev/api/v1

Pornire rapidă

Trei pași până la prima traducere:

  1. 1. Creează un cont la ravira.dev/register
  2. 2. Cumpără un pachet de caractere și generează o cheie API în Setări → API
  3. 3. Trimite prima cerere:
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"}'

Răspuns:

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

Autentificare

Toate cererile API necesită un token Bearer în antetul Authorization . Cheile API încep cu rk_live_ și sunt generate în setările contului.

Important: Cheia API este afișată o singură dată, la creare. Păstreaz-o în siguranță — nu poate fi recuperată.
Authorization: Bearer rk_live_YOUR_API_KEY

Puncte finale

POST/api/v1/translate

Traduce text. Necesită autentificare. Caracterele sunt taxate numai dacă operațiunea reușește.

ParametruTipObligatoriuDescriere
textșirDaText de tradus (maximum 100.000 de caractere)
source_langșirNuCodul limbii sursă. Implicit: auto
target_langșirNuCodul limbii țintă. Implicit: en
GET/api/v1/usage

Returnează soldul curent de caractere și utilizarea. Necesită autentificare.

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

Returnează lista limbilor acceptate. Nu necesită autentificare.

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

Exemple de cod

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!

Coduri de eroare

HTTPCod de eroareDescriere
401invalid_api_keyCheia API lipsește, este invalidă sau a fost revocată.
402insufficient_balanceContul nu mai are caractere disponibile. Cumpără mai multe la ravira.dev/topup.
429rate_limit_exceededPrea multe solicitări. Încetiniți și încercați din nou după valoarea retry_after secunde.
400validation_errorParametri de solicitare nevalizi.
500server_errorEroare internă a serverului. Reîncearcă după o scurtă pauză.

Limite de utilizare

Limitele de frecvență se aplică per cont, nu per cheie API.

  • 60 de solicitări/minut per cont, pentru toate cheile API
  • La depășirea limitei, API-ul returnează HTTP 429 cu un câmp retry_after câmp secunde
  • Până la 5 chei API per cont, pentru organizarea proiectelor

Cazuri de utilizare

Comerț electronic

Anunțuri de produse în mai multe limbi

Un vânzător de pe Amazon sau eBay vrea să publice automat anunțuri de produse în 5 limbi. Câte un apel API pentru fiecare limbă — terminologie consecventă pe toate piețele.

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

Notificări localizate pentru utilizatori

O platformă SaaS traduce toate șabloanele de notificări când un utilizator nou își setează limba preferată. Fără fișiere statice de traducere — conținut dinamic, mereu actualizat.

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

Pretraducerea contractelor

O firmă de avocatură primește contracte în limbi străine și are nevoie de o pretraducere rapidă înainte de a le trimite unui traducător autorizat. Terminologia juridică consecventă reduce timpul de verificare.

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])
Jurnalism

Monitorizarea știrilor internaționale

O redacție monitorizează surse internaționale și traduce automat articolele relevante pentru editori. Procesul rulează ca o sarcină programată în fiecare oră.

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
Resurse umane

Anunțuri de angajare în mai multe limbi

O companie care publică anunțuri de angajare în toată Europa le traduce automat. Un singur text-sursă în engleză, publicat în 6 limbi în câteva secunde.

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);
Tehnologie

Documentație software

Un instrument pentru dezvoltatori își traduce documentația pentru a ajunge la utilizatori internaționali. Fișierele Markdown sunt traduse, în timp ce blocurile de cod rămân nemodificate.

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])
Medicină

Formulare de internare a pacienților

O clinică traduce formularele de internare pentru pacienții internaționali. Pentru uz intern și confortul pacienților — formularele sunt verificate întotdeauna de personal medical calificat înainte de luarea deciziilor clinice.

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)

Gata să începi?

Generează-ți cheia API în câteva secunde. Fără taxe de configurare, fără abonamente — plătești doar pentru caracterele pe care le traduci.

Obține cheia API

Ai întrebări? Scrie-ne la humans@ravira.dev