എപിഐ സഹായക്കുറിപ്പുകള്‍

നിങ്ങളുടെ അപേക്ഷകളില്‍ ശക്തിയേറിയ പരിഭാഷയെ ചേര്‍ത്തുനിര്‍ത്തുക......നമ്മുടെ ലളിതമായ ആര്‍ട്ടിസ്റ്റ് എപിഐ ഉപയോഗിച്ച്.

തുടക്കമിടുന്നു

180+ ഭാഷകള്‍ക്കിടയിലെ പദാവലി പരിഭാഷപ്പെടുത്തുന്നതിനുള്ള ലളിതമായ ഇന്റര്‍ഫെയിസ് ലഭ്യമാണു്. എല്ലാ API പോയിന്‍റുകള്‍ക്കും ജോസണ്‍ മറുപടി നല്‍കുന്നു.

അടിസ്ഥാന യുആര്‍എല്‍: 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 കീ ഉപയോഗിച്ച് നിങ്ങളുടെ ആവശ്യങ്ങള്‍ ഉറപ്പാക്കുക. നിങ്ങള്‍ക്ക് എപിഐ കീകള്‍ നിങ്ങളുടെ കയ്യില്‍ നിന്നും ഉണ്ടാക്കാം ഡാഷ്ബോര്‍ഡ്.

തലക്കെട്ടിനുള്ള ആധികാരികത ഉറപ്പാക്കല്‍ (Recommand)
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 അതെ പരിഭാഷപ്പെടുത്തേണ്ട പദാവലി (8,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
}

സബ്ടൈറ്റില്‍ പരിഭാഷ

ഒന്നിനു പുറകെ ഒന്നായി പല പാഠങ്ങള്‍ പരിഭാഷപ്പെടുത്തുക. ഫലങ്ങള്‍ക്കായി ഒരു സബ്ലിറ്റും ഇന്‍സ്റ്റാളും ചേര്‍ക്കുക.

പരിധികള്‍: ഒരു ശേഖരത്തിലുളള 750 മൊത്തം ഇനങ്ങള്‍, കൂടിയ 750 മൊത്തം വസ്തുക്കള്‍ (texts exts translateds). പ്രവര്‍ത്തി ആരംഭിക്കുമ്പോള്‍ 30 മിനിറ്റ് സമയം അവസാനിക്കും (കുറച്ച് കാത്തിരിക്കുന്ന സമയം കണക്കാക്കുന്നില്ല).
ഭാഷ ഉപയോഗിച്ചു് സമയം മാറ്റുന്നു: സാധാരണ ഭാഷകള്‍ (സ്പാനീഷ്, ഫ്രെഞ്ച്, ജര്‍മ്മന്‍ തുടങ്ങിയവ), ചെറിയ ഭാഷകള്‍ ഉപയോഗിക്കുന്നു, സാധാരണ ഭാഷകള്‍ ഉപയോഗിക്കുന്നു, എന്നാല്‍ സാധാരണമായ ഭാഷകള്‍ ഉപയോഗിക്കുന്നു. 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"
}'
മറുപടി (എച്ച്ടിടിപി 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}/
പോളണ്ടിന്റെ ഉദാഹരണം (പിഥോണ്‍) 
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 ഈ സംഗ്രഹത്തിലെ മൊത്തം പരിഭാഷകള്‍ (texts × ലക്ഷ്യ ഭാഷകള്‍)
progress_percentage പൂര്‍ത്തിയാകുന്ന ശതമാനം (0- 100). പ്രവര്‍ത്തന_ പദാവലി / മൊത്ത_ പദാവലികളില്‍ നിന്നും കണക്കുകൂട്ടുന്നു.
queue_position "പറക്കേണ്ടത്" (1 = അടുത്തത് മുകളിലേക്ക്) വരയില്‍ നിങ്ങള്‍ക്കുള്ള സ്ഥാനം. പ്രവര്‍ത്തനം ചെയ്യുമ്പോള്‍ അല്ലെങ്കില്‍ പൂര്‍ത്തിയാകുമ്പോള്‍ നൂല്‍. ഇതു് നിങ്ങള്‍ക്ക് സമയപരിധി കാണിക്കാനും നിങ്ങളുടെ ഉപയോക്താക്കള്‍ക്ക് നിരയുടെ അവസ്ഥ കാണിക്കാനും ഉപയോഗിക്കുക.
processing_time പൂര്‍ത്തിയായ പ്രവര്‍ത്തന സമയം സെക്കന്‍ഡുകളില്‍ (സംഭാവന പൂര്‍ത്തിയായപ്പോള്‍).
സൂചന: എപ്പോള്‍ status ഉണ്ട് "pending"GPU ജോലിക്കാര്‍ മറ്റു ബാക്കെന്‍ഡുകളില്‍ തിരക്കിലാണ്. ചെക്ക് ചെയ്യുക. queue_position നിങ്ങളുടെ ജോലിക്കു മുന്നിൽ എത്ര ജോലികള്‍ ഉണ്ടെന്നറിയാന്‍. (1 = നിങ്ങള്‍ അടുത്തതാണ്.) നിങ്ങളുടെ ജോലി തനിയെ തുടങ്ങും.
വലിയ വേലയ്‌ക്കുള്ള ഏറ്റവും നല്ല രീതികൾ
  • ഓരോ കോഡ് ആവശ്യത്തിനും 1 ലക്ഷ്യ ഭാഷ അയയ്ക്കുക. ഇതു് ഓരോ സജ്ജീകരണവും വേഗത്തില്‍ സൂക്ഷിക്കുന്നു. ഇതു് എളുപ്പത്തില്‍ നിരീക്ഷിക്കാന്‍ എളുപ്പത്തില്‍ പ്രവര്‍ത്തിക്കുന്നു.
  • 50-100 പാഠങ്ങളില്‍ സജ്ജീകരിക്കുക. ചെറിയ കൂട്ടങ്ങള്‍ വേഗത്തില്‍ പൂര്‍ണ്ണമായി സജ്ജീകരിക്കുകയും നിങ്ങള്‍ക്ക് കൂടുതല്‍ പുരോഗതി വരുത്തുകയും ചെയ്യും.
  • മിക്കതും 2 ചേര്‍ച്ച നിര്‍മ്മിതമായ ജോലികളില്‍ പ്രവര്‍ത്തിപ്പിക്കുക. GPU പ്രക്രിയകള്‍ 2 തമ്മില്‍ ചേരുന്നു — കൂടുതല്‍ ജോലികള്‍ റെയിന്റ് ചെയ്യുന്നു, എന്നാല്‍ വേഗത്തില്‍ തുടങ്ങുന്നില്ല.
  • സമയപരിധിയില്‍, പുതിയൊരു ശേഖരം സമര്‍പ്പിക്കുന്നതിനു പകരം ഒരേ ജോലി വീണ്ടും _ഉറപ്പാക്കുക. യഥാര്‍ത്ഥ ജോലി ഇപ്പോഴും GPU-യില്‍ പ്രവര്‍ത്തിക്കുന്നതായിരിക്കും.
  • ഓരോ 3-5 സെക്കൻഡിലും പോക്ക് ചെയ്യും.
മള്‍ട്ടി-Language

ഒന്നിനു പുറകെ ഒന്നായി അനവധി പാഠങ്ങള്‍ പരിഭാഷപ്പെടുത്തുക:

{
    "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/
അപേക്ഷ (multiput/data)
പരാമീറ്റര്‍ തരം ആവശ്യമുണ്ട് വിവരണം
file file അതെ പരിഭാഷപ്പെടുത്തുവാനുള്ള രേഖ (മാക്സ് 10MB)
target_language string അതെ Target language code (e.g., "es", "fr", "de")
source_language string ഇല്ല Source language code. Default: "auto" (auto-detect)
പിന്തുണയുള്ള ഫയലിന്റെ തരങ്ങള്‍
  • .txt - നിരപ്പായ ടെക്സ്റ്റ് ഫയലുകള്‍
  • .docx - വാക്കിന്റെ രേഖകള്‍
  • .pdf - പിഡിഎഫ് രേഖകള്‍ (കുഴല്‍ ഉള്‍പ്പെടെ)
  • .json - Jcon ഫയലുകള്‍ (trants സ്ട്രിങ് മൂല്ല്യങ്ങള്‍)
  • .xml - XML ഫയലുകള്‍
  • .srt - സബ്ടൈറ്റില്‍ ഫയലുകള്‍
  • .po / .pot - ടെക്സ്റ്റ് പരിഭാഷാ ഫയലുകള്‍ ലഭ്യമാക്കുക
  • .jpg / .jpeg - JPEG ചിത്രങ്ങള്‍ (OCR)
  • .png - PNG ഇമേജുകള്‍ (OCR)
  • .tiff / .tif - TIFF ഇമേജുകള്‍ (OCR)
  • .bmp - BMP ഇമേജുകള്‍ (OCR)
  • .webp - വെബ്പി ചിത്രങ്ങള്‍ (OCR)
OCR പിന്തുണ: പരിഭാഷയ്ക്കു് മുന്‍പ് വാചകം പുറത്തെടുക്കാന്‍ ചിത്രങ്ങളും ഡിഫന്‍സിറ്റും അഭ്യാസം (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"
പരിഭാഷയ്ക്കു മുമ്പുള്ള പദാവലി പുറത്തെടുക്കാന്‍ ചിത്ര ഫയലുകള്‍ ഓCR ഉപയോഗിച്ചു് പ്രവര്‍ത്തിപ്പിയ്ക്കുന്നു. പരിഭാഷപ്പെടുത്തിയിരിക്കുന്ന ഔട്ട്പുട്ടുകള്‍ ഒരു പോലെ തിരികെ നല്‍കുന്നു. .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}/

രേഖയുടെ പരിഭാഷയുടെ സ്ഥാനം പരിശോധിക്കുക അല്ലെങ്കില്‍ ഡൌണ്‍ലോഡ് ചെയ്ത യുആര്‍എല്‍ വീണ്ടെടുക്കുക.

മറുപടി
{
    "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"},
        ...
    ]
}

പരിഭാഷാ മാതൃകകള്‍

ഞങ്ങളുടെ GPUU- ല്‍ പ്രവര്‍ത്തന സജ്ജീകരണ മോഡലുകള്‍ ഉപയോഗിക്കാം. എല്ലാ മോഡലുകള്‍ക്കും വാണിജ്യത്തില്‍ ലൈസന്‍സിന്റെ ലൈസന്‍സ്( Apache 2. 0) ആണ്.

മോഡ് ഭാഷകള്‍ ഏറ്റവും മികച്ചത്.
Helsinki-NLP/opus-mt 50+ ഭാഷാ ജോഡികള്‍ സാധാരണ ഭാഷകൾ (എൻ, എഎസ്‌, എഫ്‌ആർ, ഡി, ടി, പി.റ്റി, എസ്‌.
Google MADLAD-400 400+ ഭാഷകള്‍ റാറേ ഭാഷകള്‍, വിശദവിവരങ്ങള്‍

API സ്വയമായി നിങ്ങളുടെ ഭാഷാ ജോഡിയ്ക്കുള്ള ഏറ്റവും നല്ല മാതൃക തിരഞ്ഞെടുക്കുന്നു. നിങ്ങള്‍ക്കു് വേണമെങ്കില്‍ ഒരു വ്യക്തമാക്കാം engine പരാമീറ്റര്‍:

എഞ്ചിന്‍ വിവരണം
"auto" സഹജമായ. ഡ്രിസ് ഹാന്‍ഡ് ഫസ്റ്റ്, MADLAD- 24- ലേക്ക് തിരികെ വീഴുക
"huggingface" ബലം പ്രയോഗിക്കുകschannel/mariantT (fast, 50+ ഭാഷകള്‍)
"madlad" MADLAD- 2400 (400+ ഭാഷകള്‍) നിര്‍ബന്ധിതമാക്കുക

കൈകാര്യം ചെയ്യുന്നതില്‍ പിശക്

API സ്റ്റാന്‍ഡേര്‍ഡ് സ്റ്റാന്‍ഡേര്‍ഡ് അവസ്ഥ കോഡുകള്‍ വിജയമോ പരാജയമോ നിര്‍ണ്ണയിക്കുന്നതിനായി ഉപയോഗിക്കുന്നു.

കോഡ് വിവരണം
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 അടുത്ത മാസം അല്ലെങ്കില്‍ നിങ്ങള്‍ അപ്ഗ്രേഡ് ചെയ്യുന്നത് വരെ പ്രതികരിക്കുക.

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.

ഈ താളിന്‍റെ അനുബന്ധങ്ങള്‍ നല്‍കുക
നിന്‍റെ റേറ്ററിനു നന്ദി!
/5 അടിസ്ഥാനമാക്കി റേറ്ററുകള്‍