API RAVIRAv1
Gérer les clés API →

Référence de l’API

L’API RAVIRA vous donne accès par programmation à des traductions de qualité professionnelle, avec une terminologie cohérente. Authentifiez-vous avec un jeton Bearer et commencez à traduire en quelques minutes.

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

Démarrage rapide

Trois étapes pour obtenir votre première traduction:

  1. 1. Créez un compte sur ravira.dev/register
  2. 2. Achetez un pack de caractères et générez une clé API dans Paramètres → API
  3. 3. Effectuez votre première requête:
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éponse:

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

Authentification

Toutes les requêtes API nécessitent un jeton Bearer dans l’ Authorization en-tête. Les clés API commencent par rk_live_ et sont générés dans les paramètres de votre compte.

Important: Votre clé API ne s’affiche qu’une seule fois, lors de sa création. Conservez-la en lieu sûr: elle ne peut pas être récupérée.
Authorization: Bearer rk_live_YOUR_API_KEY

Points de terminaison

POST/api/v1/translate

Traduire le texte. Authentification requise. Les caractères sont facturés en cas de réussite.

ParamètreTypeObligatoireDescription
textechaîneOuiTexte à traduire (100 000 caractères max.)
source_langchaîneNonCode langage source. Valeur par défaut: auto
target_langchaîneNonCode langage cible. Valeur par défaut: en
GET/api/v1/usage

Renvoie le solde actuel de caractères et leur utilisation. Authentification requise.

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

Renvoie la liste des langues prises en charge. Aucune authentification requise.

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

Exemples de code

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!

Codes d’erreur

HTTPCode d’erreurDescription
401invalid_api_keyClé API manquante, invalide ou révoquée.
402insufficient_balanceLe compte n’a plus de caractères disponibles. Achetez-en davantage sur ravira.dev/topup.
429rate_limit_exceededTrop de requêtes. Ralentissez et réessayez après le délai indiqué par retry_after (secondes).
400erreur_de_validationParamètres de requête non valides.
500server_errorErreur interne du serveur. Réessayez après un court délai.

Limites de débit

Des limites de débit s’appliquent par compte, et non par clé API.

  • 60 requêtes/minute par compte, toutes clés API confondues
  • En cas de dépassement, l’API renvoie HTTP 429 avec un retry_after champ (secondes)
  • Jusqu’à 5 clés API par compte, pour l’organisation des projets

Cas d’utilisation

Commerce en ligne

Référencements de produits multilingues

Un vendeur sur Amazon ou eBay souhaite publier automatiquement ses produits dans 5 langues. Un appel API par langue, avec une terminologie cohérente sur tous les marchés.

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

Notifications utilisateur localisées

Une plateforme SaaS traduit tous les modèles de notification lorsqu’un nouvel utilisateur définit sa langue préférée. Aucun fichier de traduction statique: les traductions sont dynamiques et toujours à jour.

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);
});
Juridique

Pré-traduction de contrats

Un cabinet d’avocats reçoit des contrats en langues étrangères et a besoin d’une prétraduction rapide avant de les envoyer à un traducteur agréé. Une terminologie juridique cohérente réduit le temps de révision.

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

Veille de l’actualité internationale

Une rédaction surveille des sources internationales et traduit automatiquement les articles pertinents pour les journalistes. La tâche programmée s’exécute toutes les heures.

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
Ressources humaines

Offres d’emploi multilingues

Une entreprise qui publie des offres d’emploi dans toute l’Europe traduit automatiquement chaque annonce. Une seule source en anglais, publiée en 6 langues en quelques secondes.

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

Documentation logicielle

Un outil de développement traduit sa documentation pour toucher des utilisateurs internationaux. Les fichiers Markdown sont traduits, tandis que les blocs de code restent inchangés.

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])
Médical

Formulaires d’admission des patients

Une clinique traduit les formulaires d’admission des patients étrangers. Pour un usage interne et le confort des patients, les traductions sont toujours vérifiées par du personnel médical qualifié avant toute décision clinique.

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)

Prêt à commencer?

Générez votre clé API en quelques secondes. Aucun frais d’installation ni abonnement: payez uniquement les caractères que vous traduisez.

Obtenir votre clé API

Des questions? Écrivez-nous à humans@ravira.dev