Dokumentacja API

Integruj potężne tłumaczenie do aplikacji z naszym prostym REST API.

Rozpoczęcie

TranslateAPI zapewnia prosty interfejs REST do tłumaczenia tekstu między 180+ językami. Wszystkie punkty końcowe API zwracają odpowiedzi JSON.

Podstawowy URL: https://api.translateapi.ai/api/v1/
Szybki start

Zapytaj o pierwsze tłumaczenie:

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!"
    }
}

Uwierzytelnienie

Uwierzytelniaj swoje żądania za pomocą klucza API. Możesz utworzyć klawisze API z Twojego Panel.

Uwierzytelnianie nagłówka (zalecane)
Authorization: Bearer ta_your_api_key_here
Parametr zapytania
https://api.translateapi.ai/api/v1/translate/?api_key=ta_your_api_key_here
Trzymaj klucze API bezpieczne! Nie ujawniać ich w kodie klienta ani w składniach publicznych.

Przetłumacz tekst

Przetłumacz tekst na jeden język docelowy.

POST https://api.translateapi.ai/api/v1/translate/
Organ wniosku
Parametr Rodzaj Wymagane Opis
text string Tak. Tekst do przetłumaczenia (max 50 000 znaków)
target_language string Tak* Target language code (e.g., "es", "fr", "de")
source_language string Nie. Source language code. Default: "auto" (auto-detect)

* Użyj target_language (wiersz) dla jednego języka lub target_languages (masy) dla wielokrotnego. Patrz Tłumaczenie Multi-Target.

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

Tłumaczenie Multi-Target

Przetłumacz tekst na wiele języków w jednym żądaniu. Używa tego samego punktu końcowego co pojedyncze tłumaczenie.

Wskazówka: Można przetłumaczyć do 50 języków w jednym żądaniu.
POST https://api.translateapi.ai/api/v1/translate/
Organ wniosku
{
    "text": "Hello, world!",
    "target_languages": ["es", "fr", "de", "ja"],
    "source_language": "en"
}

Użyj target_languages (Ras) zamiast target_language (string) dla wielu celów.

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

Tłumaczenie serii

Przetłumacz kilka tekstów naraz przy przetwarzaniu async. Wyślij partię i ankiet o wyniki.

Ograniczenia: maksymalnie 500 tekstów na serię, maksymalnie 750 pozycji całkowitych (teksty × języki docelowe). Czas pracy wygasł 30 minut po rozpoczęciu przetwarzania (czas oczekiwania nie jest liczony).
Czas przetwarzania jest różny w zależności od języka: wspólne języki (szpańskie, francuskie, niemieckie itp.) używają szybkich modeli (~0,1s na tekst), a mniej powszechne języki używają naszego dużego wielojęzycznego modelu (~1-3s na tekst). Seria 100-tekstowa zazwyczaj zakończa się w 10-30 sekund dla wspólnych języków, lub 2-5 minut dla mniej powszechnych. Dla najlepszych rezultatów wyślij 1 język docelowy na zapytanie partii i zachowaj rozmiary partii poniżej 50 tekstów.
POST https://api.translateapi.ai/api/v1/translate/batch/
Krok 1: Wyślij serię
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"
}'
Odpowiedź (HTTP 202 akceptowana)
{
    "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/"
}
Krok 2: Analiza wyników
GET https://api.translateapi.ai/api/v1/jobs/{job_id}/
Przykład badania (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)
Odpowiedź (w kolejce – w kolejce, czeka na GPU)
{
    "job_id": "67535b2b-...",
    "status": "pending",
    "processed_texts": 0,
    "total_texts": 3,
    "progress_percentage": 0.0,
    "queue_position": 3
}
Odpowiedź (w trakcie przetwarzania)
{
    "job_id": "67535b2b-...",
    "status": "processing",
    "processed_texts": 1,
    "total_texts": 3,
    "progress_percentage": 33.33,
    "queue_position": null
}
Odpowiedź (zakończona)
{
    "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
    }
}
Śledzenie postępów w czasie rzeczywistym

Każda odpowiedź na badania obejmuje pola postępu w czasie rzeczywistym, więc można dokładnie monitorować, co się dzieje z partią:

Pole Opis
status Aktualny stan pracy: pending (polecony, czekający na pracownika GPU), processing (aktywnie tłumaczenie), completed, failed
processed_texts Liczba indywidualnych tłumaczeń zakończonych dotychczas. Aktualizacje w czasie rzeczywistym, jak każdy tekst jest tłumaczony.
total_texts Łączna liczba tłumaczeń w tej serii (teksty × języki docelowe).
progress_percentage Odsetek zakończeń (0-100). Wyliczony z przetworzonych_tekstów / total_texts.
queue_position Twoja pozycja w kolejce, gdy status jest "wstrzymujący" (1 = następny). Null po przetwarzaniu lub zakończeniu. Użyj tego, aby oszacować czas poczekania i pokazać status kolejki użytkownikom.
processing_time Całkowity czas przetwarzania w sekundach (dostępny po zakończeniu).
Wskazówka: Kiedy status jest "pending"Pracownicy GPU są zajęci innymi partiami. queue_position aby zobaczyć ile miejsc pracy jest przed Twoim (1 = jesteś następny). Twoja praca rozpocznie się automatycznie – nie potrzeba działania, po prostu kontynuuj ankietowanie.
Najlepsze praktyki dla dużych obciążeń roboczych
  • Wyślij 1 język docelowy na zapytanie serii. Utrzymuje to każdą partię szybko i łatwo śledzić postępy.
  • Przechowywać partie na 50-100 tekstów. Mniejsze partie zakończą się szybciej i zapewniają częstsze aktualizacje postępów.
  • Uruchom co najmniej 2 równoległe zadania serii. GPU procesuje 2 partii równolegle — dodatkowe kolejki zadań i nie rozpoczyna się szybciej.
  • Po przekroczeniu czasu, ponownie pobrać ten sam job_id zamiast składać nową partię. Oryginalne zadanie może nadal przetwarzać na GPU.
  • Badanie co 3-5 sekund. Bardziej częste badania nie przyspiesza przetwarzania.
Seria wielojęzyczna

Przetłumacz wiele tekstów na wiele języków naraz:

{
    "texts": ["Hello", "Goodbye"],
    "target_languages": ["es", "fr"],
    "source_language": "en"
}
Zakończone wyniki_ danych
{
    "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
}
Parametry żądania
Parametr Rodzaj Wymagane Opis
texts array Tak. Array strun do przetłumaczenia
target_language string Tak* Kod języka docelowego dla jednego języka
target_languages array Tak* Przestrzeń kodów języka docelowego dla wielu języków
source_language string Nie. Source language code. Default: "auto"

* Upewnić się, że którykolwiek z nich target_language lub target_languagesNie oboje.

Przetwarzanie asynchroniczne: Wnioski o serię zwracają się natychmiast z job_id. Badanie GET /api/v1/jobs/{job_id}/ do czasu status jest "completed", a następnie przeczytaj result_data do tłumaczenia. Użyj progress_percentage Do śledzenia postępów.

Tłumaczenie dokumentu

Przetłumacz całe dokumenty przy zachowaniu formatu. Obsługuje wiele formatów plików.

POST https://api.translateapi.ai/api/v1/translate/document/
Wniosek (multipart/form-data)
Parametr Rodzaj Wymagane Opis
file file Tak. Dokument do przetłumaczenia (max. 10MB)
target_language string Tak. Target language code (e.g., "es", "fr", "de")
source_language string Nie. Source language code. Default: "auto" (auto-detect)
Obsługiwane typy plików
  • .txt - Pliki tekstowe
  • .docx - Dokumenty słowowe
  • .pdf - Dokumenty PDF (w tym skanowane)
  • .json - Pliki JSON (tłumaczone wartości stringowe)
  • .xml - Pliki XML
  • .srt - Pliki napisów
  • .po / .pot - Pliki tłumaczeń Gettext
  • .jpg / .jpeg - Zdjęcia JPEG (OCR)
  • .png - Zdjęcia PNG (OCR)
  • .tiff / .tif - Obrazy TIFF (OCR)
  • .bmp - Zdjęcia BMP (OCR)
  • .webp - Zdjęcia WebP (OCR)
Wsparcie OCR: Pliki obrazów i skanowane PDF są przetwarzane z optyczną rozpoznawczością znaków (OCR), aby wyciągnąć tekst przed tłumaczeniem. Dla najlepszych wyników, użyj czyste, wysokiej rozdzielczości obrazy.
Przykład (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"
Pliki obrazów są przetwarzane z OCR, aby wyciągnąć tekst przed tłumaczeniem. Przetłumaczone wyjście jest zwracane jako .txt Pliki.
Odpowiedź
{
    "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"
}
Wartości stanu
pending Plik wysłany, czekający na przetwarzanie
processing Tłumaczenie w toku
completed Tłumaczenie zakończone, pobierz dostępne
failed Tłumaczenie nie powiodło się (poprawka błędu_ wiadomości)
GET https://api.translateapi.ai/api/v1/translate/document/{id}/

Sprawdź stan tłumaczenia dokumentu lub odbierz URL pobierania.

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

Wykrywanie języka

Wykrywanie języka jest wbudowane w każdy wniosek o tłumaczenie. Set source_language to "auto" (lub opuścić) i wykryty język zostaje zwrócony w odpowiedzi.

POST https://api.translateapi.ai/api/v1/translate/
Organ wniosku
{
    "text": "Bonjour, comment allez-vous?",
    "target_language": "en"
}
Odpowiedź
{
    "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
}

CZĘŚĆ CZĘŚĆ CZĘŚCIOWOŚĆ CZĘŚCIOWOŚCI source_language pole w odpowiedzi pokazuje wykryty język podczas używania automatycznego wykrywania.

Języki obsługiwane

Pobierz listę wszystkich obsługiwanych języków.

GET https://api.translateapi.ai/api/v1/translate/languages/
Odpowiedź
{
    "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"},
        ...
    ]
}

Modele tłumaczenia

Używamy najnowocześniejszych modeli tłumaczenia otwartego źródła działających na naszej własnej infrastrukturze GPU. Wszystkie modele są licencjonowane komercyjne (Apache 2.0).

Wzór Języki Najlepsze dla
Helsinki-NLP/opus-mt 50+ par językowych Języki wspólne (EN, ES, FR, DE, IT, PT, RU, ZH, JA itp.)
Google MADLAD-400 400+ języków Rzadkie języki, kompleksowy zakres

API automatycznie wybiera najlepszy model dla pary języków. Można opcjonalnie określić engine parametr:

Silnik Opis
"auto" Domyślnie. Próbuje najpierw HuggingFace, zwraca się do MADLAD-400
"huggingface" Force HuggingFace/MarianMT (najszybsze, 50+ języków)
"madlad" Siła MADLAD-400 (400+ języków)

Rozwiązanie błędów

API wykorzystuje standardowe kody stanu HTTP, aby wskazywać sukces lub porażkę.

Kod Opis
200 Sukces
400 Zły wniosek - nieprawidłowe parametry
401 Nieuprawniony - nieprawidłowy lub brakuje klucza API
402 Wymagana płatność - Kontyngent dzienny
429 Zbyt wiele zapytań - limit stawki przekroczony
503 Usługa Niedostępna - Silnik tłumaczeń tymczasowo obniżony
Format odpowiedzi na błąd
{
    "error": "daily_limit_exceeded",
    "credits_remaining": 0,
    "daily_limit": 100000
}

Ograniczenia stawki

Ograniczenia różnią się w zależności od planu. Zob. ceny Szczegółowe informacje:

Plan Znaki/miesiąc Cena
Darmowe 250,000 $0 Zarejestruj się za darmo
Rozpoczynacz 2,500,000 $9/Mo Subskrypcja
Prof. 10,000,000 $29/Mo Subskrypcja
Biznes 40,000,000 $79/Mo Subskrypcja
Skaluj 125,000,000 $199/Mo Subskrypcja

Kiedy przekroczysz granicę, otrzymasz 429 Too Many Requests Odpowiedź do następnego miesiąca lub uaktualnij.

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.

Oszacuj tę stronę
Dziękuję za ocenę!
/5 w oparciu o: ratingi