परिचय

i18n-एजेंट अनुवाद API में आपका स्वागत है! सांस्कृतिक अनुकूलन के साथ AI-संचालित अनुवाद सेवा

यह API दस्तावेज़ सभी उपलब्ध एंडपॉइंट्स, प्रमाणीकरण विधियों, अनुरोध/प्रतिक्रिया प्रारूपों और त्रुटि कोड के बारे में व्यापक जानकारी प्रदान करता है।

आधार URL

वातावरण	URL
विकास	`http://localhost:8000`
उत्पादन	`https://api.i18nagent.ai`

मुख्य विशेषताएं

🌐 बहु-भाषा समर्थन - 10+ भाषाओं में सामग्री का सांस्कृतिक अनुकूलन के साथ अनुवाद
🚀 रीयल-टाइम स्ट्रीमिंग - प्रगति अपडेट के लिए सर्वर-भेजा गया घटना
📁 फ़ाइल अनुवाद - JSON, YAML, XML, CSV और अधिक के लिए समर्थन
🔐 सुरक्षित प्रमाणीकरण - API कुंजी-आधारित प्रमाणीकरण
💳 क्रेडिट प्रणाली - पे-एज-यू-गो मूल्य निर्धारण मॉडल
🤖 एआई-संचालित - सटीक अनुवादों के लिए उन्नत एलएलएम का उपयोग करता है

प्रमाणीकरण

प्रमाणीकरण के लिए, इस कोड का उपयोग करें:

# With shell, you can just pass the correct header with each request
curl "api_endpoint_here" \
  -H "Authorization: Bearer i18n_your_api_key_here"

const headers = {
  'Authorization': 'Bearer i18n_your_api_key_here',
  'Content-Type': 'application/json'
};

fetch('api_endpoint_here', { headers })
  .then(response => response.json())
  .then(data => console.log(data));

import requests

headers = {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
}

response = requests.get('api_endpoint_here', headers=headers)
print(response.json())

package main

import (
    "net/http"
)

func main() {
    client := &http.Client{}
    req, _ := http.NewRequest("GET", "api_endpoint_here", nil)
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

सुनिश्चित करें कि i18n_your_api_key_here को अपनी API कुंजी से बदल दें।

i18n-agent API, API तक पहुंच की अनुमति देने के लिए API कुंजियों का उपयोग करता है। आप अपनी API कुंजी अपने खाता डैशबोर्ड. से प्राप्त कर सकते हैं

API कुंजी को सर्वर को किए जाने वाले सभी API अनुरोधों में एक हेडर में शामिल किया जाना चाहिए जो निम्नलिखित जैसा दिखता है:

Authorization: Bearer i18n_your_api_key_here

आपको i18n_your_api_key_here को अपनी व्यक्तिगत API कुंजी से बदलना होगा।

एंडपॉइंट्स

क्रेडिट्स

टीम क्रेडिट्स प्राप्त करें

GET /credits

प्रमाणित टीम के लिए वर्तमान क्रेडिट शेष प्राप्त करें

curl -X GET "https://api.i18nagent.ai/credits" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/credits', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/credits',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/credits", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह से JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

भाषाएँ

समर्थित भाषाओं की सूची

GET /languages

गुणवत्ता रेटिंग के साथ सभी समर्थित भाषाओं की सूची प्राप्त करें

curl -X GET "https://api.i18nagent.ai/languages" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/languages', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/languages',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/languages", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह से JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

अनुवाद कार्य

अनुवाद इतिहास प्राप्त करें

GET /translations

स्थिति, प्रकार, लक्ष्य भाषाओं और तिथि सीमा के लिए वैकल्पिक फ़िल्टर के साथ अनुवाद कार्यों की पृष्ठित सूची प्राप्त करें

curl -X GET "https://api.i18nagent.ai/translations" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह से JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
page	नहीं	पृष्ठांकन के लिए पृष्ठ संख्या
limit	संख्या	प्रति पृष्ठ आइटमों की संख्या
status	संख्या	अनुवाद स्थिति के अनुसार फ़िल्टर करें
type	संख्या	अनुवाद प्रकार के अनुसार फ़िल्टर करें
targetLanguages	संख्या	फ़िल्टर करने के लिए लक्ष्य भाषा कोड की अल्पविराम से अलग की गई सूची
fromDate	संख्या	इस तिथि के बाद बनाए गए अनुवादों को फ़िल्टर करें
toDate	संख्या	इस तिथि से पहले बनाए गए अनुवादों को फ़िल्टर करें

अनुवाद विवरण प्राप्त करें

GET /translations/{id}

ID द्वारा किसी विशिष्ट अनुवाद का विवरण प्राप्त करें

curl -X GET "https://api.i18nagent.ai/translations/{id}" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{id}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/{id}',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/{id}", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस तरह से संरचित JSON लौटाता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
id	हाँ	अनुवाद आईडी

अनुवाद स्थिति प्राप्त करें

GET /translations/{id}/status

अनुवाद कार्य की वास्तविक समय की स्थिति को विस्तृत प्रगति ट्रैकिंग के साथ प्राप्त करें जिसमें शामिल हैं: प्रगति प्रतिशत, बीता समय, अनुमानित शेष समय, चेकपॉइंट जानकारी, बहु-भाषा अनुवादों के लिए आंशिक पूर्णता, और पूर्ण परिणामों के लिए प्रीसाइन्ड डाउनलोड यूआरएल।

curl -X GET "https://api.i18nagent.ai/translations/{id}/status" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{id}/status', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/{id}/status',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/{id}/status", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह के JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
id	हाँ	अनुवाद आईडी

अनुवाद परिणाम डाउनलोड करें

GET /translations/{id}/result

अनुवादित सामग्री डाउनलोड करें

curl -X GET "https://api.i18nagent.ai/translations/{id}/result" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{id}/result', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/{id}/result',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/{id}/result", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस प्रकार संरचित JSON वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
id	हाँ	अनुवाद ID
language	नहीं	विशिष्ट भाषा परिणाम के लिए भाषा कोड

मूल फ़ाइल डाउनलोड करें

GET /translations/{id}/original

मूल अपलोड की गई फ़ाइल डाउनलोड करें

curl -X GET "https://api.i18nagent.ai/translations/{id}/original" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{id}/original', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/{id}/original',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/{id}/original", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस प्रकार संरचित JSON वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
id	हाँ	अनुवाद ID

चेकपॉइंट से अनुवाद जारी रखें

POST /translations/{id}/resume

किसी विशिष्ट चेकपॉइंट से या स्वचालित रूप से अंतिम सफल चेकपॉइंट से विफल या बीच में रुका हुआ अनुवाद जारी रखें

curl -X POST "https://api.i18nagent.ai/translations/{id}/resume" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/translations/{id}/resume', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/translations/{id}/resume',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/translations/{id}/resume", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस प्रकार JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
id	हाँ	अनुवाद आईडी

अनुरोध बॉडी पैरामीटर

पैरामीटर	प्रकार	आवश्यक	विवरण
checkpointId	string	नहीं	अपारदर्शी चेकपॉइंट आईडी जिससे जारी रखना है (स्थिति एंडपॉइंट से प्राप्त)। यदि प्रदान नहीं किया गया है और autoDetect सही है, तो अंतिम सफल चेकपॉइंट से जारी रखेगा।
continueToEnd	boolean	नहीं	क्या सभी शेष सामग्री को प्रोसेस करना जारी रखना है (डिफ़ॉल्ट: सही)
autoDetect	boolean	नहीं	स्वचालित रूप से अंतिम सफल चेकपॉइंट से पता लगाएं और फिर से शुरू करें यदि checkpointId प्रदान नहीं किया जाता है (डिफ़ॉल्ट: सही)

सक्रिय अनुवाद कार्य प्राप्त करें

GET /translations/jobs/active

वर्तमान में सक्रिय अनुवाद कार्यों की सूची प्राप्त करें

curl -X GET "https://api.i18nagent.ai/translations/jobs/active" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/jobs/active', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/jobs/active',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/jobs/active", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह के JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

अनुवाद परिणाम डाउनलोड करें

POST /translations/{jobId}/download

पूर्ण अनुवाद परिणाम डाउनलोड करें। भाषा द्वारा व्यवस्थित प्रीसाइन्ड डाउनलोड URL वापस करता है। URL 24 घंटों के बाद समाप्त हो जाते हैं।

curl -X POST "https://api.i18nagent.ai/translations/{jobId}/download" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{jobId}/download', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/translations/{jobId}/download',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/translations/{jobId}/download", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर दिया गया कमांड इस तरह के JSON संरचित करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
jobId	हाँ	अनुवाद कार्य आईडी

विशिष्ट भाषा के लिए अनुवाद फ़ाइल डाउनलोड करें

GET /translations/{jobId}/files/{language}

किसी विशिष्ट लक्ष्य भाषा के लिए एक अनुवाद फ़ाइल डाउनलोड करें। उचित कंटेंट-टाइप हेडर के साथ सीधे फ़ाइल सामग्री को वापस करता है।

curl -X GET "https://api.i18nagent.ai/translations/{jobId}/files/{language}" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/translations/{jobId}/files/{language}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/translations/{jobId}/files/{language}',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/translations/{jobId}/files/{language}", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर का कमांड इस तरह से JSON संरचित करके वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
jobId	हाँ	अनुवाद कार्य आईडी
language	हाँ	लक्ष्य भाषा कोड (जैसे, 'es', 'fr', 'ja')

स्ट्रीमिंग प्रगति के साथ अनुवाद बनाएं

POST /translations/stream

वास्तविक समय की प्रगति अपडेट के लिए सर्वर-सेंट इवेंट्स (SSE) के साथ अनुवाद बनाएं। केवल पाठ अनुवाद का समर्थन करता है (फ़ाइलों का नहीं)। SSE इवेंट्स के रूप में वास्तविक समय की प्रगति अपडेट देता है।

curl -X POST "https://api.i18nagent.ai/translations/stream" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/translations/stream', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/translations/stream',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/translations/stream", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस तरह से JSON संरचित देता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

अनुरोध बॉडी पैरामीटर

पैरामीटर	प्रकार	आवश्यक	विवरण
texts	array	हाँ	अनुवाद करने के लिए पाठों का एरे
targetLanguage	string	नहीं	लक्ष्य भाषा कोड (उदाहरण के लिए, 'es', 'fr', 'ja') - एकल भाषा अनुवाद के लिए
targetAudience	string	नहीं	लक्ष्य दर्शक (उदाहरण के लिए, 'सामान्य', 'तकनीकी', 'अनौपचारिक', 'औपचारिक') (डिफ़ॉल्ट: सामान्य)
industry	string	नहीं	उद्योग संदर्भ (उदाहरण के लिए, 'टेक्नोलॉजी', 'हेल्थकेयर', 'फाइनेंस') (डिफ़ॉल्ट: टेक्नोलॉजी)
sourceLanguage	string	नहीं	स्रोत भाषा कोड (यदि प्रदान नहीं किया गया है तो स्वतः पता लगाया जाएगा)
region	string	नहीं	स्थानीयकरण के लिए विशिष्ट क्षेत्र (उदाहरण के लिए, 'स्पेन', 'मेक्सिको', 'ब्राजील')
targetLanguages	array	नहीं	लक्ष्य भाषा कोडों का ऐरे (उदाहरण के लिए, ['es', 'fr', 'zh-CN']) - बहु-भाषा अनुवाद के लिए। targetLanguage के साथ उपयोग नहीं किया जा सकता है।
context	string	नहीं	अनुवाद के लिए वैकल्पिक अतिरिक्त संदर्भ या निर्देश (उदाहरण के लिए, 'तकनीकी शब्दों को अंग्रेजी में रखें', 'औपचारिक लहजे का उपयोग करें', 'ब्रांड नामों को सुरक्षित रखें')
pseudoTranslation	boolean	नहीं	AI अनुवाद के बिना और बिना किसी क्रेडिट लागत के i18n कार्यान्वयन के परीक्षण के लिए स्यूडो-अनुवाद मोड सक्षम करें। यह बिना अनुवादित स्ट्रिंग की पहचान करने और UI लेआउट का परीक्षण करने के लिए एक्सेंट, ब्रैकेट और वैकल्पिक CJK वर्णों के साथ टेक्स्ट को रूपांतरित करता है। (डिफ़ॉल्ट: false)
pseudoOptions	object	नहीं	छद्म-अनुवाद के लिए कॉन्फ़िगरेशन विकल्प (केवल तब उपयोग किया जाता है जब pseudoTranslation सच है)
skipWarnings	boolean	नहीं	स्रोत पाठ गुणवत्ता चेतावनियों को छोड़ें और अनुवाद के साथ आगे बढ़ें (डिफ़ॉल्ट: गलत)। जब गलत होता है, तो समस्याग्रस्त स्रोत पाठ (जैसे, कठिन-से-अनुवाद वाक्यांश, बहुवचन संबंधी मुद्दे, पाठ विस्तार चिंताएं) के बारे में चेतावनियां 'validationSuggestions' फ़ील्ड में वापस की जाएंगी। जब सच होता है, तो ये चेतावनियां साफ़ आउटपुट के लिए दबा दी जाती हैं। (डिफ़ॉल्ट: गलत)

अनुवाद लागत अनुमान प्राप्त करें

POST /translations/estimate

शब्द संख्या की गणना करें और अनुवाद के लिए आवश्यक क्रेडिट

curl -X POST "https://api.i18nagent.ai/translations/estimate" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/translations/estimate', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/translations/estimate',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/translations/estimate", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर का कमांड इस तरह से JSON संरचित करके वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

अनुरोध बॉडी पैरामीटर

पैरामीटर	प्रकार	आवश्यक	विवरण
content	string	हाँ	विश्लेषण करने के लिए सामग्री
fileType	string	नहीं	सामग्री विश्लेषण के लिए फ़ाइल प्रकार (डिफ़ॉल्ट: txt)

विश्लेषण

अनुवाद की तत्परता के लिए सामग्री का विश्लेषण करें

POST /analyze

अनुवाद से पहले संभावित समस्याओं की पहचान के लिए स्रोत पाठ का हल्का सत्यापन। प्रोग्रामेटिक एक्सेस के लिए त्रुटि कोड के साथ सत्यापन परिणाम लौटाता है। यह endpoint क्रेडिट का उपभोग नहीं करता - यह AI/LLM कॉल के बिना तेज़, निर्धारणवादी सत्यापन चलाता है।

curl -X POST "https://api.i18nagent.ai/analyze" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/analyze', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/analyze',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/analyze", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

ऊपर का कमांड इस तरह के JSON संरचना लौटाता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

अनुरोध बॉडी पैरामीटर

पैरामीटर	प्रकार	आवश्यक	विवरण
targetLanguage	string	हाँ	अनुवाद के लिए लक्ष्य भाषा कोड
targetAudience	string	नहीं	लक्ष्य दर्शक (डिफ़ॉल्ट: सामान्य)
industry	string	नहीं	उद्योग संदर्भ (डिफ़ॉल्ट: सामान्य)
sourceLanguage	string	नहीं	स्रोत भाषा कोड (स्वचालित रूप से पहचाना जाता है यदि प्रदान नहीं किया गया है)
region	string	नहीं	स्थानीयकरण के लिए विशिष्ट क्षेत्र
content	object	हाँ	विश्लेषण के लिए सामग्री (पाठ, पाठ की सरणी, या संरचित वस्तु)
fileType	string	नहीं	यदि सामग्री फ़ाइल से है तो वैकल्पिक फ़ाइल प्रकार

नेमस्पेस अनुवाद

नेमस्पेस पुन: उपयोग के लिए अनुवाद फ़ाइल अपलोड करें

POST /namespaces/{namespace}/translations/upload

नेमस्पेस के लिए मौजूदा अनुवाद फ़ाइल अपलोड करें भविष्य में पुन: उपयोग के लिए। यह पहले से अनुवादित स्ट्रिंग्स को कैश करके लागत अनुकूलन को सक्षम बनाता है। फ़ाइल को संसाधित किया जाता है और अनुवाद जोड़े निकाले जाते हैं।

curl -X POST "https://api.i18nagent.ai/namespaces/{namespace}/translations/upload" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/namespaces/{namespace}/translations/upload', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/namespaces/{namespace}/translations/upload',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/namespaces/{namespace}/translations/upload", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड JSON संरचना जैसा दिखता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
namespace	हाँ	नेमस्पेस पहचानकर्ता (3-50 वर्ण, केवल अल्फ़ान्यूमेरिक + हाइफ़न/अंडरस्कोर)

नेमस्पेस अनुवाद के आँकड़े प्राप्त करें

GET /namespaces/{namespace}/translations/stats

किसी नेमस्पेस के लिए अपलोड की गई अनुवाद फ़ाइलों और कैश के पुनः उपयोग के बारे में आँकड़े प्राप्त करें

curl -X GET "https://api.i18nagent.ai/namespaces/{namespace}/translations/stats" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/namespaces/{namespace}/translations/stats', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/namespaces/{namespace}/translations/stats',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/namespaces/{namespace}/translations/stats", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस तरह से JSON संरचित डेटा देता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
namespace	हाँ	नेमस्पेस पहचानकर्ता

नेमस्पेस में अपलोड की गई अनुवाद फ़ाइलों को सूचीबद्ध करें

GET /namespaces/{namespace}/translations/files

किसी नेमस्पेस के लिए अपलोड की गई अनुवाद फ़ाइलों की पृष्ठ-वार सूची प्राप्त करें

curl -X GET "https://api.i18nagent.ai/namespaces/{namespace}/translations/files" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/namespaces/{namespace}/translations/files', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/namespaces/{namespace}/translations/files',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/namespaces/{namespace}/translations/files", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस प्रकार संरचित JSON लौटाता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
namespace	हाँ	नेमस्पेस पहचानकर्ता
limit	नहीं	लौटाने के लिए फ़ाइलों की अधिकतम संख्या
offset	नहीं	पृष्ठांकन के लिए छोड़ी जाने वाली फ़ाइलों की संख्या

अपलोड की गई अनुवाद फ़ाइल हटाएँ

DELETE /namespaces/{namespace}/translations/files/{fileId}

अपलोड की गई अनुवाद फ़ाइल और कैश से सभी संबंधित अनुवाद जोड़े हटाएँ

curl -X DELETE "https://api.i18nagent.ai/namespaces/{namespace}/translations/files/{fileId}" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/namespaces/{namespace}/translations/files/{fileId}', {
  method: 'DELETE',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.delete(
    'https://api.i18nagent.ai/namespaces/{namespace}/translations/files/{fileId}',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("DELETE", "https://api.i18nagent.ai/namespaces/{namespace}/translations/files/{fileId}", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस प्रकार संरचित JSON लौटाता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
namespace	हाँ	नेमस्पेस पहचानकर्ता
fileId	हाँ	हटाने के लिए फ़ाइल ID

समानांतर अनुवाद फ़ाइलें अपलोड करें

POST /translations/upload-parallel

अनुवाद जोड़ी निष्कर्षण और कैशिंग के लिए समानांतर में स्रोत और लक्ष्य फ़ाइलें अपलोड करें। दोनों फ़ाइलों में एक ही संरचना और फ़ाइल प्रकार होना चाहिए।

curl -X POST "https://api.i18nagent.ai/translations/upload-parallel" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
  "texts": [
    "Hello, world!",
    "Welcome to our service"
  ],
  "targetLanguage": "es",
  "targetAudience": "general",
  "industry": "technology",
  "sourceLanguage": "en",
  "region": "Mexico",
  "notes": "Keep technical terms in English, use formal tone"
}'

const response = await fetch('https://api.i18nagent.ai/translations/upload-parallel', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    })
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.post(
    'https://api.i18nagent.ai/translations/upload-parallel',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    },
    json={
        "texts": [
            "Hello, world!",
            "Welcome to our service"
        ],
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
        "sourceLanguage": "en",
        "region": "Mexico",
        "notes": "Keep technical terms in English, use formal tone"
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    data := map[string]interface{}{
        "texts": []string{"Hello, world!", "Welcome to our service"},
        "targetLanguage": "es",
        "targetAudience": "general",
        "industry": "technology",
    }
    jsonData, _ := json.Marshal(data)
    
    req, _ := http.NewRequest("POST", "https://api.i18nagent.ai/translations/upload-parallel", bytes.NewBuffer(jsonData))
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस तरह के JSON को वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

फ़ाइलें

स्टोरेज से फ़ाइल डाउनलोड करें

GET /files/{filePath}

स्थानीय स्टोरेज (विकास) या S3 (उत्पादन) से फ़ाइलें प्रदान करता है। अपलोड और अनुवादित फ़ाइलों तक पहुंचने के लिए उपयोग किया जाता है।

curl -X GET "https://api.i18nagent.ai/files/{filePath}" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json"

const response = await fetch('https://api.i18nagent.ai/files/{filePath}', {
  method: 'GET',
  headers: {
    'Authorization': 'Bearer i18n_your_api_key_here',
    'Content-Type': 'application/json'
  }
});

const data = await response.json();
console.log(data);

import requests
import json

response = requests.get(
    'https://api.i18nagent.ai/files/{filePath}',
    headers={
        'Authorization': 'Bearer i18n_your_api_key_here',
        'Content-Type': 'application/json'
    }
)

print(response.json())

package main

import (
    "bytes"
    "encoding/json"
    "net/http"
)

func main() {
    client := &http.Client{}
    
    req, _ := http.NewRequest("GET", "https://api.i18nagent.ai/files/{filePath}", )
    req.Header.Add("Authorization", "Bearer i18n_your_api_key_here")
    req.Header.Add("Content-Type", "application/json")
    
    resp, _ := client.Do(req)
    defer resp.Body.Close()
}

उपरोक्त कमांड इस तरह के JSON को वापस करता है:

{
  "translations": [
    {
      "original": "Hello, world!",
      "translated": "¡Hola, mundo!",
      "confidence": 0.98
    }
  ],
  "metadata": {
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "wordCount": 2,
    "creditsUsed": 0.002,
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

क्वेरी पैरामीटर

पैरामीटर	आवश्यक	विवरण
filePath	हाँ	फ़ाइल पथ किसी भी उप-निर्देशिका को शामिल करते हुए (जैसे, 'अपलोड/test-file.json' या 'अनुवाद/result.json')

त्रुटियाँ

i18n-एजेंट API निम्नलिखित त्रुटि कोड का उपयोग करता है:

त्रुटि कोड	अर्थ
400	गलत अनुरोध -- आपका अनुरोध अमान्य है।
401	अधिकार-रहित -- आपकी API कुंजी अमान्य है।
402	भुगतान आवश्यक -- आपके खाते में अपर्याप्त क्रेडिट।
403	निषिद्ध -- आपकी API कुंजी निष्क्रिय है या टीम नहीं मिली।
404	नहीं मिला -- निर्दिष्ट संसाधन नहीं मिल सका।
500	आंतरिक सर्वर त्रुटि -- हमारे सर्वर में समस्या थी। बाद में फिर से प्रयास करें।
503	सेवा अनुपलब्ध -- हम अभी अनुरक्षण के लिए अस्थायी रूप से ऑफ़लाइन हैं। कृपया बाद में फिर से प्रयास करें।

त्रुटि प्रतिक्रिया प्रारूप

{
  "error": "Detailed error message describing what went wrong",
  "success": false
}

एंडपॉइंट चुनें:

परीक्षण शुरू करने के लिए ऊपर एक एंडपॉइंट का चयन करें

प्रमाणीकरण

# Add your API key to requests
curl -X GET "https://api.i18nagent.ai/" \
  -H "Authorization: Bearer i18n_your_api_key_here"

पाठ अनुवाद

curl -X POST "https://api.i18nagent.ai/translate" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -H "Content-Type: application/json" \
  -d '{
    "texts": ["Hello, world!", "Welcome to our service"],
    "targetLanguage": "es",
    "targetAudience": "general",
    "industry": "technology"
  }'

फ़ाइल अनुवाद

curl -X POST "https://api.i18nagent.ai/translate_file" \
  -H "Authorization: Bearer i18n_your_api_key_here" \
  -F "[email protected]" \
  -F "targetLanguage=es" \
  -F "targetAudience=general"

प्रमाणीकरण

const API_KEY = 'i18n_your_api_key_here';
const BASE_URL = 'https://api.i18nagent.ai';

const headers = {
  'Authorization': `Bearer ${API_KEY}`,
  'Content-Type': 'application/json'
};

पाठ अनुवाद

const response = await fetch(`${BASE_URL}/translate`, {
  method: 'POST',
  headers,
  body: JSON.stringify({
    texts: ['Hello, world!', 'Welcome to our service'],
    targetLanguage: 'es',
    targetAudience: 'general',
    industry: 'technology'
  })
});

const result = await response.json();
console.log(result.translatedTexts);

फ़ाइल अनुवाद

const formData = new FormData();
formData.append('file', fileInput.files[0]);
formData.append('targetLanguage', 'es');
formData.append('targetAudience', 'general');

const response = await fetch(`${BASE_URL}/translate_file`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${API_KEY}`
  },
  body: formData
});

const result = await response.json();

प्रमाणीकरण

import requests

API_KEY = 'i18n_your_api_key_here'
BASE_URL = 'https://api.i18nagent.ai'

headers = {
    'Authorization': f'Bearer {API_KEY}',
    'Content-Type': 'application/json'
}

पाठ अनुवाद

response = requests.post(f'{BASE_URL}/translate', 
    headers=headers,
    json={
        'texts': ['Hello, world!', 'Welcome to our service'],
        'targetLanguage': 'es',
        'targetAudience': 'general',
        'industry': 'technology'
    }
)

result = response.json()
print(result['translatedTexts'])

फ़ाइल अनुवाद

files = {'file': open('document.json', 'rb')}
data = {
    'targetLanguage': 'es',
    'targetAudience': 'general'
}

response = requests.post(f'{BASE_URL}/translate_file',
    headers={'Authorization': f'Bearer {API_KEY}'},
    files=files,
    data=data
)

result = response.json()