Introduction

Bienvenue à l'API de traduction i18n-agent ! Service de traduction alimenté par l'IA avec adaptation culturelle

Cette documentation API fournit des informations complètes sur tous les points de terminaison disponibles, les méthodes d'authentification, les formats de requête/réponse et les codes d'erreur.

Base URLs

Environnement	URL
Développement	`http://localhost:8000`
Production	`https://api.i18nagent.crédits** - Modèle de tarification pay-as-you-go

🤖 Alimenté par l'IA - Utilise des LLM avancés pour des traductions précises

Authentification

Pour vous authentifier, utilisez ce code :

# 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()
}

Assurez-vous de remplacer i18n_your_api_key_here par votre clé API.

L'API i18n-agent utilise des clés API pour permettre l'accès à l'API. Vous pouvez obtenir votre clé API depuis votre tableau de bord du compte.

La clé API doit être incluse dans toutes les requêtes API au serveur dans un en-tête qui ressemble à ce qui suit :

Authorization: Bearer i18n_your_api_key_here

Vous devez remplacer i18n_your_api_key_here par votre clé API personnelle.

Points de terminaison

Crédits

Obtenir les crédits de l'équipe

GET /credits

Obtenir le solde de crédit actuel pour l'équipe authentifiée

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()
}

La commande ci-dessus renvoie du JSON structuré comme ceci :

{
  "success": true,
  "data": {
    "teamId": "team_123",
    "teamName": "My Team",
    "credits": 125.5,
    "userId": "user_456"
  },
  "metadata": {
    "timestamp": "2024-01-15T12:00:00.000Z"
  }
}

Response Fields

Field	Type	Description
success	boolean	Whether the request was successful
data	object
data.teamId	string	Team identifier
data.teamName	string	Team name
data.credits	number	Current credit balance
data.userId	string	User identifier
metadata	object
metadata.timestamp	string	Response timestamp

Langues

Lister les langues prises en charge

GET /languages

Obtenir une liste de toutes les langues prises en charge avec des évaluations de qualité

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()
}

La commande ci-dessus renvoie du JSON structuré comme ceci :

{
  "languages": [
    {
      "code": "es",
      "name": "Spanish",
      "quality": "high"
    }
  ]
}

Response Fields

Field	Type	Description
languages	array

Tâches de traduction

Obtenir l'historique des traductions

GET /translations

Obtenir une liste paginée des tâches de traduction avec des filtres optionnels pour le statut, le type, les langues cibles et la plage de dates

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()
}

La commande ci-dessus renvoie du JSON structuré comme ceci :

{
  "translations": [
    {
      "id": "translation_job_id",
      "type": "TEXT",
      "fileName": "file_name_(for_file_translations)",
      "fileType": "file_type_(for_file_translations)",
      "targetLanguages": [
        "string"
      ],
      "status": "PENDING",
      "progress": 0,
      "wordCount": 0,
      "creditsRequired": 0,
      "createdAt": "2024-01-15T12:00:00.000Z",
      "startedAt": "2024-01-15T12:00:00.000Z",
      "completedAt": "2024-01-15T12:00:00.000Z",
      "user": {}
    }
  ],
  "pagination": {
    "page": 0,
    "limit": 0,
    "total": 0,
    "totalPages": 0
  }
}

Paramètres de requête

Paramètre	Obligatoire	Description
page	No	Page number for pagination
limit	No	Number of items per page
status	No	Filter by translation status
type	No	Filter by translation type
targetLanguages	No	Comma-separated list of target language codes to filter by
fromDate	No	Filter translations created after this date
toDate	No	Filter translations created before this date

Response Fields

Field	Type	Description
translations	array
pagination	object
pagination.page	integer
pagination.limit	integer
pagination.total	integer
pagination.totalPages	integer

Obtenir les détails de la traduction

GET /translations/{id}

Obtenir les détails d'une traduction spécifique par 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()
}

La commande ci-dessus renvoie du JSON structuré comme ceci :

{
  "id": "translation_job_id",
  "type": "TEXT",
  "fileName": "original_file_name_(for_file_translations)",
  "fileType": "file_type_(json,_yaml,_etc",
  "fileSize": 0,
  "targetLanguages": [
    "string"
  ],
  "context": "translation_context_or_instructions",
  "wordCount": 0,
  "creditsRequired": 0,
  "status": "PENDING",
  "progress": 0,
  "errorMessage": "error_message_if_translation_failed",
  "translatedFiles": {},
  "createdAt": "2024-01-15T12:00:00.000Z",
  "startedAt": "2024-01-15T12:00:00.000Z",
  "completedAt": "2024-01-15T12:00:00.000Z",
  "user": {}
}

Paramètres de requête

Paramètre	Obligatoire	Description
id	Yes	Translation ID

Response Fields

Field	Type	Description
id	string	Translation job ID
type	string	Type of translation job
fileName	string	Original file name (for file translations)
fileType	string	File type (json, yaml, etc.)
fileSize	integer	File size in bytes
targetLanguages	array	Target languages for translation
context	string	Translation context or instructions
wordCount	integer	Number of words in source content
creditsRequired	number	Credits required for this translation
status	string	Current status of the translation
progress	integer	Progress percentage (0-100)
errorMessage	string	Error message if translation failed
translatedFiles	object	Translated file data (when completed)
createdAt	string	When the job was created
startedAt	string	When processing started
completedAt	string	When the job was completed
user	object	User who created the translation

Obtenir le statut de la traduction

GET /translations/{id}/status

Obtenez le statut en temps réel d'un travail de traduction avec un suivi détaillé de la progression, incluant : le pourcentage de progression, le temps écoulé, le temps restant estimé, les informations de point de contrôle, l'achèvement partiel pour les traductions multilingues, et les URLs de téléchargement présignés pour les résultats terminés.

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()
}

La commande ci-dessus renvoie un JSON structuré comme ceci :

{
  "id": "translation_job_id",
  "status": "PENDING",
  "statusText": "localized_human-readable_status_message",
  "progress": 0,
  "elapsedTime": "120 seconds",
  "estimatedTimeRemaining": "45 seconds",
  "message": "Translation in progress... 65% complete",
  "chunks": {
    "completed": 0,
    "total": 0
  },
  "lastCheckpointId": "opaque_checkpoint_id_for_the_last_saved_checkpoint_(can_be_used_to_resume)",
  "checkpointDescription": "Localization (65% complete, chunk 60%)",
  "completedLanguages": [
    "es",
    "fr",
    "de"
  ],
  "partialCompletionMessage": "3 language(s) completed: es, fr, de",
  "downloadUrls": {},
  "createdAt": "2024-01-15T12:00:00.000Z",
  "startedAt": "2024-01-15T12:00:00.000Z",
  "completedAt": "2024-01-15T12:00:00.000Z",
  "metadata": {},
  "result": {},
  "error": "error_message_(only_when_failed)"
}

Paramètres de requête

Paramètre	Obligatoire	Description
id	Yes	Translation ID

Response Fields

Field	Type	Description
id	string	Translation job ID
status	string	Current status
statusText	string	Localized human-readable status message
progress	integer	Progress percentage (0-100)
elapsedTime	string	Time elapsed since job started processing
estimatedTimeRemaining	string	Estimated time remaining for completion
message	string	Status message or error details
chunks	object	Batch/chunk processing progress (for large translations)
chunks.completed	integer	Number of chunks completed
chunks.total	integer	Total number of chunks
lastCheckpointId	string	Opaque checkpoint ID for the last saved checkpoint (can be used to resume)
checkpointDescription	string	Human-readable description of current checkpoint progress
completedLanguages	array	Array of language codes that have been completed (for multi-language translations with partial completion)
partialCompletionMessage	string	Message describing partial completion status
downloadUrls	object	Presigned download URLs for completed translations, organized by language code. Example: {"es": "https://...", "fr": "https://..."}. URLs expire after 1 hour. This is the primary method for accessing completed translation files.
createdAt	string	When the job was created
startedAt	string	When the job started processing
completedAt	string	When the job was completed
metadata	object	Additional metadata about the translation
result	object	Translation result (only when completed)
error	string	Error message (only when failed)

Télécharger le résultat de la traduction

GET /translations/{id}/result

Télécharger le contenu traduit

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

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

Paramètres de requête

Paramètre	Requis	Description
id	Yes	Translation ID
language	No	Language code for specific language result

Télécharger le fichier original

GET /translations/{id}/original

Télécharger le fichier original uploadé

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

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

Paramètres de requête

Paramètre	Requis	Description
id	Yes	Translation ID

Reprendre la traduction à partir du point de contrôle

POST /translations/{id}/resume

Reprendre une traduction échouée ou interrompue à partir d'un point de contrôle spécifique ou automatiquement à partir du dernier point de contrôle réussi

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()
}

La commande ci-dessus renvoie un JSON structuré comme ceci :

{
  "success": true,
  "message": "Translation resume initiated",
  "id": "translation_job_id",
  "checkpointId": "the_checkpoint_id_from_which_the_translation_is_resuming",
  "description": "Resuming from last checkpoint",
  "status": "PROCESSING"
}

Paramètres de requête

Paramètre	Obligatoire	Description
id	Yes	Translation ID

Paramètres du corps de la requête

Paramètre	Type	Obligatoire	Description
checkpointId	string	No	Opaque checkpoint ID to resume from (obtained from status endpoint). If not provided and autoDetect is true, will resume from last successful checkpoint.
continueToEnd	boolean	No	Whether to continue processing all remaining content after resuming (default: true)
autoDetect	boolean	No	Automatically detect and resume from the last successful checkpoint if checkpointId is not provided (default: true)

Response Fields

Field	Type	Description
success	boolean	Whether the resume was successfully initiated
message	string	Status message
id	string	Translation job ID
checkpointId	string	The checkpoint ID from which the translation is resuming
description	string	Human-readable description of the resume action
status	string	Current status of the translation after resuming

Obtenir les travaux de traduction actifs

GET /translations/jobs/active

Obtenir la liste des travaux de traduction actuellement actifs

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "activeJobs": [
    {
      "id": "string",
      "type": "FILE",
      "fileName": "string",
      "fileType": "string",
      "text": "string",
      "targetLanguages": [
        "string"
      ],
      "status": "PENDING",
      "progress": 0,
      "wordCount": 0,
      "creditsRequired": 0,
      "createdAt": "string",
      "startedAt": "string",
      "originalPreview": "string",
      "user": {
        "id": "string",
        "name": "string",
        "email": "string"
      }
    }
  ]
}

Response Fields

Field	Type	Description
activeJobs	array

Télécharger les résultats de traduction

POST /translations/{jobId}/download

Télécharger les résultats de traduction terminés. Renvoie un téléchargement présigné URLs organisé par langue. URLs expire après 24 heures.

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "jobId": "translation_job_id",
  "fileName": "original_file_name",
  "targetLanguages": [
    "string"
  ],
  "requestedLanguages": [
    "string"
  ],
  "downloadUrls": {},
  "message": "Translation files ready for download. Use downloadUrls to access each language file.",
  "expiresIn": "24 hours",
  "partialFailure": true,
  "failedLanguages": [
    "string"
  ],
  "errorMessage": "error_message_for_failed_languages",
  "warning": "Translation completed partially. 2 of 5 language(s) failed: ja, zh-CN"
}

Paramètres de requête

Paramètre	Requis	Description
jobId	Yes	Translation job ID

Response Fields

Field	Type	Description
jobId	string	Translation job ID
fileName	string	Original file name
targetLanguages	array	Completed target languages available for download
requestedLanguages	array	Originally requested target languages
downloadUrls	object	Presigned download URLs organized by language code. Example: {"es": {"url": "https://...", "key": "..."}, "fr": {"url": "https://...", "key": "..."}}
message	string	Status or information message
expiresIn	string	Expiration time for download URLs
partialFailure	boolean	Indicates if some languages failed to translate
failedLanguages	array	Language codes that failed to translate
errorMessage	string	Error message for failed languages
warning	string	Warning message about partial completion

Télécharger le fichier de traduction pour une langue spécifique

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

Télécharger un fichier de traduction unique pour une langue cible spécifique. Renvoie directement le contenu du fichier avec l'en-tête Content-Type approprié.

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()
}

La commande ci-dessus renvoie une structure JSON comme suit :

"string"

Paramètres de requête

Paramètre	Requis	Description
jobId	Yes	Translation job ID
language	Yes	Target language code (e.g., 'es', 'fr', 'ja')

Créer une traduction avec progression en streaming

POST /translations/stream

Créer une traduction avec des événements Server-Sent (SSE) pour des mises à jour de progression en temps réel. Prend en charge uniquement la traduction de texte (pas de fichiers). Renvoie des mises à jour de progression en temps réel sous forme d'événements 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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

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

Paramètres du corps de la requête

Paramètre	Type	Requis	Description
texts	array	Yes	Array of texts to translate
targetLanguage	string	No	Target language code (e.g., 'es', 'fr', 'ja') - for single language translation
targetAudience	string	No	Target audience (e.g., 'general', 'technical', 'casual', 'formal') (default: general)
industry	string	No	Industry context (e.g., 'technology', 'healthcare', 'finance') (default: technology)
sourceLanguage	string	No	Source language code (auto-detected if not provided)
region	string	No	Specific region for localization (e.g., 'Spain', 'Mexico', 'Brazil')
targetLanguages	array	No	Array of target language codes (e.g., ['es', 'fr', 'zh-CN']) - for multi-language translation. Cannot be used together with targetLanguage.
context	string	No	Optional additional context or instructions for the translation (e.g., 'Keep technical terms in English', 'Use formal tone', 'Preserve brand names')
pseudoTranslation	boolean	No	Enable pseudo-translation mode for testing i18n implementations without AI translation and NO credit cost. Transforms text with accents, brackets, and optional CJK characters to identify untranslated strings and test UI layout. (default: false)
pseudoOptions	object	No	Configuration options for pseudo-translation (only used when pseudoTranslation is true)
skipWarnings	boolean	No	Skip source text quality warnings and proceed with translation (default: false). When false, warnings about problematic source text (e.g., hard-to-translate phrases, pluralization issues, text expansion concerns) will be returned in the response under 'validationSuggestions' field. When true, these warnings are suppressed for cleaner output. (default: false)

Obtenir une estimation du coût de traduction

POST /translations/estimate

Calculer le nombre de mots et les crédits nécessaires pour la traduction

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "wordCount": 0,
  "creditsRequired": 0,
  "fileType": "txt",
  "estimatedCostUSD": 0
}

Paramètres du corps de la requête

Paramètre	Type	Requis	Description
content	string	Yes	Content to analyze
fileType	string	No	File type for content analysis (default: txt)

Response Fields

Field	Type	Description
wordCount	integer	Number of words in the content
creditsRequired	number	Credits required for translation
fileType	string	File type used for analysis
estimatedCostUSD	number	Estimated cost in USD

Analyse

Validate source text for translation readiness

POST /analyze

Lightweight validation of source text to identify potential issues before translation. Returns validation results with error codes for programmatic access. This endpoint does NOT consume credits - it runs fast, deterministic validation without AI/LLM calls.

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()
}

The above command returns JSON structured like this:

{
  "success": true,
  "isValid": true,
  "hasWarnings": true,
  "wordCount": 0,
  "issues": [
    {
      "code": "EMPTY_CONTENT",
      "severity": "info",
      "message": "human-readable_description_of_the_issue",
      "suggestion": "suggested_fix_for_the_issue",
      "affectedCount": 0,
      "examples": [
        "string"
      ]
    }
  ],
  "totalIssues": 0,
  "summary": {
    "errors": 0,
    "warnings": 0,
    "info": 0
  },
  "errorCodes": {
    "EMPTY_CONTENT": "string",
    "ENCODING_ISSUES": "string",
    "UNCLOSED_PLACEHOLDER": "string",
    "NESTED_PLACEHOLDERS": "string",
    "INCONSISTENT_PLACEHOLDER_FORMAT": "string",
    "HARDCODED_PLURALS": "string",
    "VERY_LONG_STRINGS": "string",
    "INVISIBLE_CHARACTERS": "string",
    "EMPTY_JSON_VALUES": "string",
    "INVALID_JSON": "string",
    "HARDCODED_VALUES": "string"
  }
}

Request Body Parameters

Parameter	Type	Required	Description
content	string	Yes	Content to validate (text or JSON string)
fileType	string	No	File type hint for validation (auto-detected if not provided) (default: auto)

Response Fields

Field	Type	Description
success	boolean	Whether validation completed (same as isValid)
isValid	boolean	Whether content passed validation (no errors)
hasWarnings	boolean	Whether content has warnings (but no blocking errors)
wordCount	integer	Number of words in the content
issues	array	List of validation issues found
totalIssues	integer	Total number of issues found
summary	object	Summary counts by severity
summary.errors	integer	Number of error-level issues
summary.warnings	integer	Number of warning-level issues
summary.info	integer	Number of info-level issues
errorCodes	object	Reference enum of all possible error codes for programmatic access
errorCodes.EMPTY_CONTENT	string
errorCodes.ENCODING_ISSUES	string
errorCodes.UNCLOSED_PLACEHOLDER	string
errorCodes.NESTED_PLACEHOLDERS	string
errorCodes.INCONSISTENT_PLACEHOLDER_FORMAT	string
errorCodes.HARDCODED_PLURALS	string
errorCodes.VERY_LONG_STRINGS	string
errorCodes.INVISIBLE_CHARACTERS	string
errorCodes.EMPTY_JSON_VALUES	string
errorCodes.INVALID_JSON	string
errorCodes.HARDCODED_VALUES	string

Namespace Translations

Télécharger le fichier de traduction pour la réutilisation de l'espace de noms

POST /namespaces/{namespace}/translations/upload

Télécharger un fichier de traduction existant vers un espace de noms pour une réutilisation future. Cela permet l'optimisation des coûts en réutilisant des chaînes précédemment traduites. Le fichier est traité et les paires de traduction sont extraites pour la mise en cache.

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()
}

La commande ci-dessus renvoie une structure JSON comme suit :

{
  "success": true,
  "fileId": "string",
  "pairsStored": 0,
  "pairsUpdated": 0,
  "message": "string"
}

Paramètres de requête

Paramètre	Requis	Description
namespace	Yes	Namespace identifier (3-50 chars, alphanumeric + hyphens/underscores only)

Response Fields

Field	Type	Description
success	boolean
fileId	string
pairsStored	integer	Number of new translation pairs stored
pairsUpdated	integer	Number of existing translation pairs updated
message	string

Obtenir les statistiques de traduction de l'espace de noms

GET /namespaces/{namespace}/translations/stats

Obtenir des statistiques sur les fichiers de traduction téléchargés et la réutilisation du cache pour un espace de noms

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "namespaceId": "string",
  "namespaceName": "string",
  "totalFiles": 0,
  "files": [
    {
      "id": "string",
      "baseFileName": "string",
      "sourceLocale": "string",
      "targetLocale": "string",
      "pairsExtracted": 0,
      "createdAt": "2024-01-15T12:00:00.000Z"
    }
  ],
  "cacheStatistics": [
    {
      "sourceLocale": "string",
      "targetLocale": "string",
      "pairCount": 0,
      "totalReuses": 0
    }
  ]
}

Paramètres de requête

Paramètre	Requis	Description
namespace	Yes	Namespace identifier

Response Fields

Field	Type	Description
namespaceId	string
namespaceName	string
totalFiles	integer
files	array
cacheStatistics	array

Lister les fichiers de traduction téléchargés dans l'espace de noms

GET /namespaces/{namespace}/translations/files

Obtenir une liste paginée des fichiers de traduction téléchargés pour un espace de noms

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "namespaceId": "string",
  "namespaceName": "string",
  "totalFiles": 0,
  "limit": 0,
  "offset": 0,
  "files": [
    {
      "id": "string",
      "baseFileName": "string",
      "originalFileName": "string",
      "fileType": "string",
      "fileSize": 0,
      "sourceLocale": "string",
      "targetLocale": "string",
      "pairsExtracted": 0,
      "status": "string",
      "uploadedBy": "string",
      "createdAt": "2024-01-15T12:00:00.000Z",
      "updatedAt": "2024-01-15T12:00:00.000Z"
    }
  ]
}

Paramètres de requête

Paramètre	Requis	Description
namespace	Yes	Namespace identifier
limit	No	Maximum number of files to return
offset	No	Number of files to skip for pagination

Response Fields

Field	Type	Description
namespaceId	string
namespaceName	string
totalFiles	integer
limit	integer
offset	integer
files	array

Supprimer le fichier de traduction téléchargé

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

Supprimer un fichier de traduction téléchargé et tous les paires de traduction associées du cache

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "success": true,
  "fileName": "string",
  "pairsDeleted": 0,
  "message": "string"
}

Paramètres de requête

Paramètre	Requis	Description
namespace	Yes	Namespace identifier
fileId	Yes	File ID to delete

Response Fields

Field	Type	Description
success	boolean
fileName	string
pairsDeleted	integer
message	string

Téléverser des fichiers de traduction parallèle

POST /translations/upload-parallel

Téléverser les fichiers source et cible en parallèle pour l'extraction de paire de traduction et la mise en cache. Les deux fichiers doivent avoir la même structure et le même type de fichier.

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

{
  "success": true,
  "fileId": "string",
  "pairsStored": 0,
  "pairsUpdated": 0,
  "message": "string"
}

Response Fields

Field	Type	Description
success	boolean
fileId	string
pairsStored	integer	Number of new translation pairs stored
pairsUpdated	integer	Number of existing translation pairs updated
message	string

Fichiers

Télécharger le fichier depuis le stockage

GET /files/{filePath}

Sert les fichiers depuis le stockage local (développement) ou S3 (production). Utilisé pour accéder aux fichiers téléchargés et traduits.

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()
}

La commande ci-dessus renvoie une structure JSON comme ceci :

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

Paramètres de requête

Paramètre	Requis	Description
filePath	Yes	File path including any subdirectories (e.g., 'uploads/test-file.json' or 'translations/result.json')

Erreurs

L'API i18n-agent utilise les codes d'erreur suivants :

Code d'erreur	Signification
400	Bad Request -- Your request is invalid.
401	Unauthorized -- Your API key is invalid.
402	Payment Required -- Insufficient credits in your account.
403	Forbidden -- Your API key is inactive or team not found.
404	Not Found -- The specified resource could not be found.
500	Internal Server Error -- We had a problem with our server. Try again later.
503	Service Unavailable -- We're temporarily offline for maintenance. Please try again later.

Format de réponse d'erreur

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

Analyser le contenu pour la préparation à la traduction

POST /analyze

Validation légère du texte source pour identifier les problèmes potentiels avant la traduction. Renvoie les résultats de validation avec des codes d'erreur pour un accès programmatique. Ce endpoint ne consomme PAS de crédits - il exécute une validation rapide et déterministe sans appels 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()
}

La commande ci-dessus renvoie du JSON structuré comme ceci :

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

Paramètres du corps de la requête

Paramètre	Type	Obligatoire	Description
targetLanguage	string	Oui	Code de langue cible pour la traduction
targetAudience	string	Non	Public cible (par défaut : général)
industry	string	Non	Contexte industriel (par défaut : général)
sourceLanguage	string	Non	Code de langue source (détecté automatiquement si non fourni)
region	string	Non	Région spécifique pour la localisation
content	object	Oui	Contenu à analyser (texte, tableau de textes ou objet structuré)
fileType	string	Non	Type de fichier optionnel si le contenu provient d'un fichier

Traductions de l'espace de noms

Choisir un point de terminaison :

Sélectionnez un point de terminaison ci-dessus pour commencer le test

Authentification

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

Traduire du texte

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

Traduire un fichier

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"

Authentification

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'
};

Traduire du texte

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);

Traduire un fichier

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();

Authentification

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'
}

Traduire du texte

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'])

Traduire un fichier

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()