API દસ્તાવેજ

આપણા સરળ REST API સાથે તમારા કાર્યક્રમોમાં મજબૂત અનુવાદને એકીકૃત કરો.

શરૂ કરી રહ્યા છીએ

TranslateAPI 180+ ભાષાઓ વચ્ચે લખાણનું ભાષાંતર કરવા માટે સરળ REST ઇન્ટરફેસ પૂરુ પાડે છે. બધા API અંતબિંદુઓ JSON જવાબો પાછા આપે છે.

આધાર URL: https://api.translateapi.ai/api/v1/
ઝડપી શરૂઆત

તમારી પહેલી ભાષાંતર વિનંતી કરો:

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 હા ભાષાંતર કરવાનું લખાણ (મહત્તમ ૫૦,૦૦૦ અક્ષરો)
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
}

મલ્ટી-લક્ષ્ય ભાષાંતર

એક સૂચનામાં ઘણાબધા ભાષાઓમાં લખાણનું ભાષાંતર કરો. એક જ અંતબિંદુને એક જ ભાષાંતર તરીકે વાપરે છે.

પ્રકાર: તમે એક જ અરજીમાં ૫૦ ભાષાઓનું ભાષાંતર કરી શકો છો.
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
}

બેચ ભાષાંતર

અસુમેળ પ્રક્રિયા સાથે એક જ સમયે ઘણાબધા લખાણોનું ભાષાંતર કરો. પરિણામો માટે બેચ અને પોલ રજૂ કરો.

મર્યાદાઓ: મહત્તમ ૫૦૦ લખાણો પ્રતિ બેચ, મહત્તમ ૭૫૦ કુલ વસ્તુઓ (લખાણો × લક્ષ્ય ભાષાઓ). પ્રક્રિયા શરૂ થયા પછી કામનો સમય સમાપ્ત થાય છે ૩૦ મિનિટ (કતારનો રાહ જોવાનો સમય ગણવામાં આવતો નથી).
પ્રક્રિયા સમય ભાષા અનુસાર બદલાય છે: સામાન્ય ભાષાઓ (સ્પેનીશ, ફ્રેન્ચ, જર્મન, વગેરે) ઝડપી મોડેલો વાપરે છે (~0.1s પ્રતિ લખાણ), જ્યારે ઓછી સામાન્ય ભાષાઓ અમારું મોટું બહુભાષી મોડેલ વાપરે છે (~1-3s પ્રતિ લખાણ). 100-લખાણ બેચ સામાન્ય રીતે સામાન્ય ભાષાઓ માટે 10-30 સેકન્ડોમાં સમાપ્ત થાય છે, અથવા ઓછા સામાન્ય માટે 2-5 મિનિટ. શ્રેષ્ઠ પરિણામો માટે, બેચ સૂચના માટે 1 લક્ષ્ય ભાષા મોકલો અને બેચ માપ 50 લખાણો નીચે રાખો.
POST https://api.translateapi.ai/api/v1/translate/batch/
પગલું ૧: બેચ રજૂ કરો
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 ૨૦૨ સ્વીકારાયેલ)
{
    "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/"
}
પગલું ૨: પરિણામો માટે પોલ
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)
પ્રત્યુત્તર (વિલંબિત - કતારમાં, GPU માટે રાહ જુએ છે)
{
    "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 (કતારમાં, GPU કાર્યકર માટે રાહ જુએ છે), processing (સક્રિય રીતે ભાષાંતર કરે છે), completed, failed
processed_texts અત્યાર સુધી સમાપ્ત થયેલ વ્યક્તિગત ભાષાંતરોની સંખ્યા. દરેક લખાણનું ભાષાંતર કરવા માટે વાસ્તવિક સમયમાં સુધારાઓ.
total_texts આ બેચમાં ભાષાંતરોની કુલ સંખ્યા (લખાણો × લક્ષ્ય ભાષાઓ).
progress_percentage સમાપ્તિ ટકા (0-100). processed_texts / total_texts માંથી ગણાય છે.
queue_position જ્યારે સ્થિતિ "પેન્ડિંગ" હોય ત્યારે કતારમાં તમારી સ્થિતિ (૧ = આગળ). શૂન્ય જ્યારે પ્રક્રિયા થયેલ હોય અથવા સમાપ્ત થયેલ હોય. રાહ જોવાનો સમય અંદાજ કરવા અને તમારા વપરાશકર્તાઓને કતાર સ્થિતિ બતાવવા માટે આનો ઉપયોગ કરો.
processing_time સેકન્ડોમાં કુલ પ્રક્રિયા સમય (જ્યારે સમાપ્ત થાય ત્યારે ઉપલબ્ધ).
પ્રકાર: કયારે status છે "pending", GPU કામદારો અન્ય બેચ સાથે વ્યસ્ત છે. ચકાસો queue_position તમારી આગળ કેટલી કામગીરી છે તે જોવા માટે (૧ = તમે આગળ છો). તમારી કામગીરી આપોઆપ શરૂ થશે - કોઈ ક્રિયાની જરૂર નથી, ફક્ત પોલિંગ ચાલુ રાખો.
મોટા કાર્યભાર માટે શ્રેષ્ઠ પદ્ધતિઓ
  • બેચ સૂચના પ્રતિ ૧ લક્ષ્ય ભાષા મોકલો. આ દરેક બેચને ઝડપી રાખે છે અને પ્રગતિને ટ્રેક કરવા માટે સરળ બનાવે છે.
  • બેચને 50-100 લખાણો પર રાખો. નાના બેચ ઝડપથી સમાપ્ત થાય છે અને તમને વધુ વારંવાર પ્રગતિ સુધારાઓ આપે છે.
  • મહત્તમ ૨ એકસાથે બેચ કાર્યો ચલાવો. GPU ૨ બેચને સમકાલીન રીતે પ્રક્રિયા કરે છે - વધારાની કાર્યો કતારમાં છે અને ઝડપી શરૂ થશે નહિં.
  • સમયસમાપ્તિ પર, નવું બેચ રજૂ કરવાની જગ્યાએ સમાન job_id ને પુનઃપોલ કરો. મૂળભૂત કામ હજુ પણ GPU પર પ્રક્રિયા કરી શકે છે.
  • દર ૩-૫ સેકન્ડે પૂછો. વધુ વારંવાર પૂછવું પ્રક્રિયાને ઝડપી બનાવતું નથી.
બહુભાષી બેચ

એક જ સમયે ઘણાબધા ભાષાઓમાં ઘણાબધા લખાણનું ભાષાંતર કરો:

{
    "texts": ["Hello", "Goodbye"],
    "target_languages": ["es", "fr"],
    "source_language": "en"
}
સમાપ્ત થયેલ પરિણામ માહિતી (_d)
{
    "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 ભાષાંતરો માટે. Use progress_percentage પ્રગતિને ટ્રેક કરવા માટે.

દસ્તાવેજ ભાષાંતર

સંપૂર્ણ દસ્તાવેજોનું ભાષાંતર કરો જ્યારે બંધારણને સંગ્રહો. ઘણાબધા ફાઇલ બંધારણોને આધાર આપે છે.

POST https://api.translateapi.ai/api/v1/translate/document/
વિનંતી (બહુભાગી/ફોર્મ-માહિતી)
પરિમાણો પ્રકાર જરૂરી વર્ણન
file file હા ભાષાંતર કરવા માટેનું દસ્તાવેજ (મહત્તમ ૧૦MB)
target_language string હા Target language code (e.g., "es", "fr", "de")
source_language string નહી Source language code. Default: "auto" (auto-detect)
આધારભૂત ફાઇલ પ્રકારો
  • .txt - સાદા લખાણ ફાઇલો
  • .docx - વર્ડ દસ્તાવેજો
  • .pdf - PDF દસ્તાવેજો (સ્કેન થયેલને સમાવતા)
  • .json - JSON ફાઇલો (શબ્દમાળા કિંમતોનું અનુવાદ કરે છે)
  • .xml - XML ફાઇલો
  • .srt - ઉપશીર્ષક ફાઇલો
  • .po / .pot - Gettext ભાષાંતર ફાઇલો
  • .jpg / .jpeg - JPEG ચિત્રો (OCR)
  • .png - PNG ચિત્રો (OCR)
  • .tiff / .tif - TIFF ચિત્રો (OCR)
  • .bmp - BMP ચિત્રો (OCR)
  • .webp - WebP ચિત્રો (OCR)
OCR આધાર: ચિત્ર ફાઇલો અને સ્કેન થયેલ PDFs ઓપ્ટીકલ અક્ષર ઓળખ (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 ભાષાંતર નિષ્ફળ (error_message ચકાસો)
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
}

ભાષા શોધ

ભાષા શોધ એ દરેક ભાષાંતર વિનંતી માં સમાવેલ છે. સુયોજિત કરો 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 ઇન્ફ્રાસ્ટ્રક્ચર પર ચાલતા state-of-the-art ઓપન સ્ત્રોત અનુવાદ મોડેલો વાપરીએ છીએ. બધા મોડેલો વાણિજ્યિક લાઇસન્સ ધરાવે છે (Apache 2.0).

મોડેલ ભાષાઓ માટે શ્રેષ્ઠ
Helsinki-NLP/opus-mt 50+ ભાષા જોડાણો સામાન્ય ભાષાઓ (EN, ES, FR, DE, IT, PT, RU, ZH, JA, વગેરે)
Google MADLAD-400 400+ ભાષાઓ અસામાન્ય ભાષાઓ, વિસ્તૃત કવરેજ

API આપોઆપ તમારી ભાષા જોડી માટે શ્રેષ્ઠ મોડેલ પસંદ કરે છે. તમે વૈકલ્પિક રીતે સ્પષ્ટ કરી શકો છો engine પરિમાણ:

એન્જિન વર્ણન
"auto" મૂળભૂત. HuggingFace પહેલેથી પ્રયત્ન કરે છે, MADLAD-400 પર પાછા ફરે છે
"huggingface" HuggingFace/MarianMT દબાણ કરો (ઝડપી, ૫૦+ ભાષાઓ)
"madlad" 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 આ પર આધારિત રેટિંગ્સ