RAVIRA APIv1
Zarządzaj kluczami API →

Dokumentacja API

API RAVIRA zapewnia programowy dostęp do profesjonalnych tłumaczeń ze spójną terminologią. Uwierzytelnij się za pomocą tokenu Bearer i zacznij tłumaczyć w kilka minut.

Podstawowy adres URLhttps://ravira.dev/api/v1

Szybki start

Trzy kroki do pierwszego tłumaczenia:

  1. 1. Utwórz konto na ravira.dev/register
  2. 2. Kup pakiet znaków i wygeneruj klucz API w Ustawienia → API
  3. 3. Wykonaj pierwsze żądanie:
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"}'

Odpowiedź:

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

Uwierzytelnianie

Wszystkie żądania API wymagają tokenu Bearer w nagłówku Authorization nagłówek. Klucze API zaczynają się od rk_live_ i są generowane w ustawieniach konta.

Ważne: Klucz API jest wyświetlany tylko raz podczas tworzenia. Przechowuj go w bezpiecznym miejscu — nie można go odzyskać.
Authorization: Bearer rk_live_YOUR_API_KEY

Punkty końcowe

POST/api/v1/translate

Przetłumacz tekst. Wymaga uwierzytelnienia. Znaki są rozliczane po pomyślnym przetłumaczeniu.

ParametrTypWymaganeOpis
tekstciąg znakówTakTekst do przetłumaczenia (maks. 100,000 znaków)
source_langciąg znakówNieKod języka źródłowego. Domyślnie: auto
target_langciąg znakówNieKod języka docelowego. Domyślnie: en
GET/api/v1/usage

Zwraca aktualne saldo znaków i ich wykorzystanie. Wymaga uwierzytelnienia.

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

Zwraca listę obsługiwanych języków. Uwierzytelnianie nie jest wymagane.

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

Przykłady kodu

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!

Kody błędów

HTTPKod błęduOpis
401invalid_api_keyBrakujący, nieprawidłowy lub unieważniony klucz API.
402insufficient_balanceNa koncie nie pozostały żadne znaki. Kup więcej na ravira.dev/topup.
429rate_limit_exceededZbyt wiele żądań. Zwolnij i ponów próbę po upływie wartości retry_after (w sekundach).
400błąd_walidacjiNieprawidłowe parametry żądania.
500server_errorBłąd wewnętrzny serwera. Spróbuj ponownie za chwilę.

Limity liczby żądań

Obowiązują limity liczby żądań na konto, a nie na klucz API.

  • 60 żądań/minutę na konto dla wszystkich kluczy API
  • Po przekroczeniu limitu API zwraca HTTP 429 z a retry_after pole (sekundy)
  • Do 5 kluczy API na konto w ramach organizacji projektów

Zastosowania

Handel elektroniczny

Wielojęzyczne wystawianie produktów na sprzedaż

Sprzedawca na Amazonie lub eBayu chce automatycznie wystawiać produkty w 5 językach. Jedno wywołanie API na język — spójna terminologia na wszystkich rynkach.

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

Zlokalizowane powiadomienia dla użytkowników

Platforma SaaS tłumaczy wszystkie szablony powiadomień, gdy nowy użytkownik ustawia preferowany język. Bez statycznych plików tłumaczeń — tłumaczenia są dynamiczne i zawsze aktualne.

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

Wstępne tłumaczenie umowy

Kancelaria prawna otrzymuje umowy w językach obcych i potrzebuje szybkiego tłumaczenia wstępnego przed wysłaniem ich do tłumacza przysięgłego. Spójna terminologia prawnicza skraca czas weryfikacji.

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

Międzynarodowe monitorowanie wiadomości

Redakcja monitoruje zagraniczne źródła i automatycznie tłumaczy istotne artykuły dla redaktorów. Zadanie jest uruchamiane co godzinę zgodnie z harmonogramem.

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
HR

Wielojęzyczne oferty pracy

Firma publikująca oferty pracy w całej Europie tłumaczy każde ogłoszenie automatycznie. Jedno źródło po angielsku, publikacja w 6 językach w kilka sekund.

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

Dokumentacja oprogramowania

Narzędzie dla programistów tłumaczy dokumentację, aby dotrzeć do użytkowników z różnych krajów. Pliki Markdown są tłumaczone, a bloki kodu pozostają bez zmian.

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

Formularze przyjmowania pacjentów

Klinika tłumaczy formularze przyjęcia pacjentów zagranicznych. Na potrzeby wewnętrzne i dla komfortu pacjentów — przed podjęciem decyzji klinicznych tłumaczenia zawsze sprawdza wykwalifikowany personel medyczny.

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)

Gotowy do rozpoczęcia?

Wygeneruj klucz API w kilka sekund. Bez opłat konfiguracyjnych i abonamentów — płacisz tylko za tłumaczone znaki.

Uzyskaj klucz API

Masz pytania? Napisz do nas na adres humans@ravira.dev