დოკუმენტაცია

ინტეგრირეთ ძლიერი თარგმნა თქვენს პროგრამებში ჩვენი მარტივი REST API- ით.

დაწყება

TranslateAPI გთავაზობთ მარტივ REST ინტერფეისს ტექსტის თარგმნისთვის 180+ ენაზე. ყველა API დასასრული იძლევა JSON პასუხს.

ძირითადი URL: https://api.translateapi.ai/api/v1/
სწრაფი გაშვებაComment

შექმენით თქვენი პირველი თარგმნის მოთხოვნა:

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

ავთენტიფიკაცია

თქვენი მოთხოვნების ავთენტიფიკაცია API გასაღების გამოყენებით. თქვენ შეგიძლიათ შექმნათ API გასაღები თქვენი დისპლეი.

თავსართის ავთენტიფიკაცია (რეკომენდებულია)
Authorization: Bearer ta_your_api_key_here
კითხვის პარამეტრები
https://api.translateapi.ai/api/v1/translate/?api_key=ta_your_api_key_here
დპთზთ ჟვ ჱა რგჲთრვ API კლძფჲგვ! არ გამოაქვეყნოთ ისინი კლიენტის მხარის კოდში ან საჯარო საცავებში.

ტექსტის თარგმნა

ტექსტის თარგმნა ერთ ენაზე.

POST https://api.translateapi.ai/api/v1/translate/
მოთხოვნის სხეული
პარამეტრები ტიპი აუცილებელი აღწერა
text string - ეა. თარგმნილი ტექსტი (50, 000 სიმბოლომდე)
target_language string ეა* Target language code (e.g., "es", "fr", "de")
source_language string ნვ. Source language code. Default: "auto" (auto-detect)

* გამოყენება target_language (სტრიქონი) ერთი ენის ან target_languages (მასივი) მრავალჯერადი. იხილეთ მრავალმიმართული თარგმნა.

პასუხი
{
    "translated_text": "Hola, mundo!",
    "source_language": "en",
    "target_language": "es",
    "translations": {
        "es": "Hola, mundo!"
    },
    "character_count": 13,
    "translation_time": 0.45
}

მრავალმიმართული თარგმნა

ტექსტის თარგმნა მრავალ ენაზე ერთი მოთხოვნით. იყენებს ერთსა და იმავე დასასრული პუნქტს, როგორც ერთი თარგმანი.

ტიპი: თქვენ შეგიძლიათ გადათარგმნოთ 50 ენაზე ერთ მოთხოვნაში.
POST https://api.translateapi.ai/api/v1/translate/
მოთხოვნის სხეული
{
    "text": "Hello, world!",
    "target_languages": ["es", "fr", "de", "ja"],
    "source_language": "en"
}

გამოყენება target_languages (მასივი) target_language (სტრიქონი) მრავალჯერადი მიზნებისთვის.

პასუხი
{
    "source_language": "en",
    "translations": {
        "es": "Hola, mundo!",
        "fr": "Bonjour, monde!",
        "de": "Hallo, Welt!",
        "ja": "こんにちは、世界!"
    },
    "character_count": 52,
    "translation_time": 2.31
}

თარგმნა

მრავალი ტექსტის ერთდროულად თარგმნა ასინქრონული დამუშავების საშუალებით. შედეგების შესამოწმებლად ჩააგზავნეთ პაკეტი და გამოკითხვა.

ლიმიტები: მაქსიმუმ 500 ტექსტი ჯგუფში, მაქსიმუმ 750 ელემენტი საერთოდ (ტექსტი × მიზნობრივი ენა). დავალება 30 წუთით ადრე მთავრდება დამუშავების დაწყებიდან (რიგის ლოდინის დრო არ ითვლება).
პროცესის ხანგრძლივობა განსხვავდება ენის მიხედვით: გავრცელებული ენები (ესპანური, ფრანგული, გერმანული და ა. შ.) იყენებენ სწრაფ მოდელებს (~0. 1 წამი ტექსტზე), ხოლო ნაკლებად გავრცელებული ენები იყენებენ ჩვენს დიდ მრავალენიან მოდელებს (~ 1- 3 წამი ტექსტზე). 100- ტექსტიანი პაკეტი ჩვეულებრივ დასრულდება 10- 30 წამში გავრცელებული ენებისთვის, ან 2- 5 წუთში ნაკლებად გავრცელებული ენებისთვის. საუკეთესო შედეგების მისაღებად, გაგზავნეთ 1 მიზნობრივი ენა პაკეტის მოთხოვნაზე და შეინარჩუნეთ პაკეტის ზომა 50 ტექსტზე ნაკლები.
POST https://api.translateapi.ai/api/v1/translate/batch/
ნაბიჯი 1: ჯგუფის გაგზავნა
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"
}'
პასუხი (HTTP 202 მიღებულია)
{
    "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/"
}
ნაბიჯი 2: შედეგების გამოკითხვა
GET https://api.translateapi.ai/api/v1/jobs/{job_id}/
გამოკითხვის მაგალითი (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)
პასუხი (შემდგომი - რიგი, გრაფიკული პროცესორის მოლოდინი)
{
    "job_id": "67535b2b-...",
    "status": "pending",
    "processed_texts": 0,
    "total_texts": 3,
    "progress_percentage": 0.0,
    "queue_position": 3
}
პასუხი (დამუშავებისას)
{
    "job_id": "67535b2b-...",
    "status": "processing",
    "processed_texts": 1,
    "total_texts": 3,
    "progress_percentage": 33.33,
    "queue_position": null
}
პასუხი (დასრულდა)
{
    "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
    }
}
რეალურ დროში პროგრესის მონიტორინგი

ყველა გამოკითხვის პასუხი მოიცავს რეალურ დროში მიმდინარეობის ველებს, ასე რომ თქვენ შეგიძლიათ აკონტროლოთ ზუსტად რა ხდება თქვენს ჯგუფთან:

ველი აღწერა
status მიმდინარე დავალების მდგომარეობა: pending (რეისში, გრაფიკული პროცესორის მოლოდინში), processing (აქტიურად თარგმნის), completed, failed
processed_texts დასრულებული ინდივიდუალური თარგმნების რაოდენობა. ყოველი ტექსტის თარგმნისას რეალურ დროში განახლება.
total_texts მთარგმნელთა საერთო რაოდენობა ამ პაკეტში (ტექსტი × მიზნობრივი ენა).
progress_percentage დასრულების პროცენტი (0- 100). გამოითვლება processed_ texts / total_ texts- დან.
queue_position თქვენი პოზიცია რიგში, როდესაც სტატუსი არის "გამორიცხული" (1 = შემდეგი). ნულოვანი, როდესაც პროცესი ან დასრულებულია. გამოიყენეთ ეს ლოდინის დროის დასადგენად და რიგის სტატუსის საჩვენებლად თქვენს მომხმარებლებს.
processing_time დამუშავების საერთო დრო წამებში (შესაძლებელია დასრულების შემდეგ).
ტიპი: კჲდა status არის "pending", GPU- ს მუშაკები სხვა პაკეტებით არიან დაკავებულნი. queue_position იმისათვის, რომ ნახოთ რამდენი დავალებაა თქვენს წინ (1 = თქვენ ხართ შემდეგი). თქვენი დავალება ავტომატურად დაიწყება - არანაირი მოქმედება არ არის საჭირო, უბრალოდ კითხვის გაგრძელება.
დიდი სამუშაო დატვირთვის საუკეთესო პრაქტიკა
  • 1 მიზნობრივი ენის გაგზავნა პაკეტის მოთხოვნაზე. ეს აჩქარებს ყველა პაკეტს და აადვილებს პროგრესის დათვალიერებას.
  • 50- დან 100- მდე ტექსტის შენახვა ჯგუფებში. მცირე ჯგუფები უფრო სწრაფად მთავრდება და უფრო ხშირად გთავაზობთ პროგრესის განახლებას.
  • მაქსიმუმ 2 ერთდროული პაკეტის დავალების შესრულება. გრაფიკული პროცესორი 2 პაკეტს ამუშავებს პარალელურად - დამატებითი დავალებები ელოდება და არ დაიწყება სწრაფად.
  • დროის გასვლისას, იგივე job_id-ის გადამოწმება ახალი პაკეტის გაგზავნის ნაცვლად. ორიგინალური დავალება შესაძლოა ჯერ კიდევ GPU-ზე მუშავდება.
  • გამოკითხვა ყოველ 3- 5 წამში. უფრო ხშირი გამოკითხვა არ აჩქარებს პროცესს.
მრავალენოვანი პაკეტი

რამდენიმე ტექსტის ერთდროულად რამდენიმე ენაზე თარგმნა:

{
    "texts": ["Hello", "Goodbye"],
    "target_languages": ["es", "fr"],
    "source_language": "en"
}
დასრულებული შედეგის მონაცემები
{
    "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
}
მოთხოვნის პარამეტრები
პარამეტრები ტიპი აუცილებელი აღწერა
texts array - ეა. მთარგმნელის სტრიქონის მასივი
target_language string ეა* ერთი ენის კოდი
target_languages array ეა* რამდენიმე ენისთვის მიზნობრივი ენის კოდების მატრიცა
source_language string ნვ. Source language code. Default: "auto"

* მიეცით ან target_language ან target_languagesნვ თ ეგამარა.

ასინქრონული დამუშავება: პაკეტის მოთხოვნები დაუყოვნებლივ დაბრუნდება job_id. ხვრელები GET /api/v1/jobs/{job_id}/ სანამ status არის "completed", მაშინ წაიკითხე result_data მთარგმნელებისთვის. progress_percentage ჱა ეა ოპჲჟლვეწ ნაოპვეყკა.

დოკუმენტის თარგმანი

სრული დოკუმენტების თარგმნა ფორმატირების შენარჩუნების პირობებში. მხარს უჭერს მრავალ ფაილის ფორმატს.

POST https://api.translateapi.ai/api/v1/translate/document/
მოთხოვნა (მრავლობითი ნაწილები/ ფორმის მონაცემები)
პარამეტრები ტიპი აუცილებელი აღწერა
file file - ეა. თარგმნილი დოკუმენტი (max 10MB)
target_language string - ეა. Target language code (e.g., "es", "fr", "de")
source_language string ნვ. Source language code. Default: "auto" (auto-detect)
მხარდაჭერილი ფაილის ტიპები
  • .txt - ჩვეულებრივი ტექსტი
  • .docx - Word დოკუმენტები
  • .pdf - PDF დოკუმენტები (სკანირებულიც კი)
  • .json - JSON ფაილები (სტრიქონის მნიშვნელობის თარგმნა)
  • .xml - XML ფაილები
  • .srt - სუბტიტრების ფაილები
  • .po / .pot - თარგმნის ფაილები
  • .jpg / .jpeg - JPEG გამოსახულებები
  • .png - PNG გამოსახულებები
  • .tiff / .tif - TIFF გამოსახულებები
  • .bmp - BMP გამოსახულებები
  • .webp - WebP ნახატები (OCR)
OCR მხარდაჭერა: გამოსახულების ფაილები და გაშიფრული PDF- ები ოპტიკური სიმბოლოების აღქმით (OCR) იმუშავებენ ტექსტის ამოსაღებად თარგმნის წინ. საუკეთესო შედეგების მისაღებად გამოიყენეთ სუფთა, მაღალი რეზოლუციის გამოსახულებები.
მაგალითი (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"
გამოსახულების ფაილები OCR- ით იმუშავებენ ტექსტის ამოსაღებად თარგმნის წინ. თარგმნილი გამონატანი უკან ბრუნდება როგორც .txt ფაილი
პასუხი
{
    "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"
}
სტატუსის მნიშვნელობები
pending ფაილი ატვირთეს, ელოდება დამუშავებას
processing თარგმნა მიმდინარეობს
completed გადათარგმნა დასრულდა, შესაძლებელია ჩამოტვირთვა
failed თარგმნა ვერ შედგა (შეტყობინების შეცდომის შემოწმება)
GET https://api.translateapi.ai/api/v1/translate/document/{id}/

დოკუმენტის თარგმანის სტატუსის შემოწმება ან ჩამოტვირთვის URL- ის მიღება.

პასუხი
{
    "id": 123,
    "original_filename": "document.docx",
    "status": "completed",
    "translated_file_url": "/media/translated/document_es.docx",
    "character_count": 5420
}

ენის ამოცნობა

ენის ამოცნობა ჩაშენებულია ყველა თარგმნის მოთხოვნაში. Set source_language to "auto" (ან გამოტოვოთ იგი) და ამოცნობილი ენა პასუხში იქნება დაბრუნებული.

POST https://api.translateapi.ai/api/v1/translate/
მოთხოვნის სხეული
{
    "text": "Bonjour, comment allez-vous?",
    "target_language": "en"
}
პასუხი
{
    "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
}

თჱგთნვრვ. source_language პასუხის ეს ველი აჩვენებს ამოცნობილ ენას, როდესაც ავტოდადგენა გამოიყენება.

მხარდაჭერილი ენა

ყველა მხარდაჭერილი ენის სიის მიღება.

GET https://api.translateapi.ai/api/v1/translate/languages/
პასუხი
{
    "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"},
        ...
    ]
}

თარგმნის მოდელი

ჩვენ ვიყენებთ თანამედროვე ღია კოდის თარგმნის მოდელს, რომელიც მუშაობს ჩვენი GPU- ს ინფრასტრუქტურაზე. ყველა მოდელი კომერციულად ლიცენზირებულია (Apache 2. 0).

მოდელი ენა საუკეთესო
Helsinki-NLP/opus-mt 50+ ენა Common languages (EN, ES, FR, DE, IT, PT, RU, ZH, JA, და ა.შ.)
Google MADLAD-400 400+ ენა ნწკჲლკჲ ვჱთკა, გჟთფკჲ ჱა ჟვბვ ჟთ.

API ავტომატურად აირჩევს საუკეთესო მოდელს თქვენი ენის წყვილისთვის. თქვენ ასევე შეგიძლიათ მიუთითოთ engine პარამეტრები:

ძრავა აღწერა
"auto" ოყპგჲ ჲოთრგა ჟვ ეა ოპთგლვფვ ლთუვრჲ, ჟლვე რჲგა ჟვ გყპნა ნა MADLAD- 400
"huggingface" HuggingFace/MarianMT-ის იძულება (ყველაზე სწრაფი, 50+ ენა)
"madlad" Force MADLAD-400 (400+ ენა)

შეცდომის დამუშავება

API იყენებს სტანდარტულ HTTP სტატუსის კოდებს წარმატების ან წარუმატებლობის დასადგენად.

კოდი აღწერა
200 წარმატება
400 არასწორი მოთხოვნა - არასწორი პარამეტრები
401 არაავტორიზებული - არასწორი ან არარსებული API გასაღები
402 გადახდა აუცილებელია - ყოველდღიური სიმბოლოების კოტირება გადაჭარბებულია
429 ზედმეტად ბევრი მოთხოვნა - სიჩქარის ლიმიტი გადაჭარბებულია
503 სერვისი არ არის ხელმისაწვდომი - თარგმნის მოდული დროებით გამორთულია
პასუხის შეცდომის ფორმატი
{
    "error": "daily_limit_exceeded",
    "credits_remaining": 0,
    "daily_limit": 100000
}

სიჩქარის საზღვრები

დპანთუთრვ ჟვ პაჱლთფარ ოჲ ოლანჲრ. გთზ ფასი სრული დეტალებისთვის:

გეგმა სიმბოლოები/თვე ფასი
თავისუფალი 250,000 $0 რეგისტრაცია
გაშვება 2,500,000 $9/თვე დარეგისტრირება
პროფესიული 10,000,000 $29/თვე დარეგისტრირება
ბიზნეს 40,000,000 $79/თვე დარეგისტრირება
მასშტაბირება 125,000,000 $199/თვე დარეგისტრირება

კჲდარჲ ოპვგყჱჳჲეთრვ ლთმთრა ჟთ, ღვ ოჲლსფთრვ 429 Too Many Requests ჲრდჲგჲპ ეჲ ჟლვეგაღთწ მვჟვუ თლთ ღვ ჟვ ჲბნჲგთქ.

ავტომატური მასშტაბის ღრუბლის ინფრასტრუქტურა

TranslateAPI მუშაობს განკუთვნილ NVIDIA A100 GPU ექსპანსიებზე ავტომატური ჰორიზონტალური მასშტაბირებით. როდესაც მოთხოვნა იზრდება, დამატებითი GPU ექსპანსიები რამდენიმე წუთში იწყება, რათა შეინარჩუნოს სწრაფი პასუხის დრო. ეს ნიშნავს, რომ ჩვენი API შეუძლია უზრუნველყოს პრაქტიკულად უსაზღვრო ერთდროული მოთხოვნები დაქვეითების გარეშე — ერთი მოთხოვნიდან ათასობით წუთში.

ამ გვერდის შეფასება
ბლადჲეაპწ ჱა ჲუვნკარა!
/5 დაფუძნებულია რეიტინგები