Introduktion

Velkommen til i18n-agent Translation API! AI-drevet oversættelsestjeneste med kulturel tilpasning

Denne API-dokumentation giver omfattende oplysninger om alle tilgængelige slutpunkter, godkendelses-metoder, anmodnings-/svareformater og fejlkoder.

Basis-URL'er

Miljø	URL
Udvikling	`http://localhost:8000`
Produktion	`https://api.i18nagent.ai`

Nøglefunktioner

🌐 Multisprogs-understøttelse - Oversæt indhold til 10+ sprog med kulturel tilpasning
🚀 Realtidsstreaming - Server-Sendt Hændelser til statusopdateringer
📁 Filoversættelse - Understøttelse af JSON, YAML, XML, CSV og mere
🔐 Sikker Godkendelse - API-nøgle-baseret godkendelse
💳 Kreditsystem - Betal-efter-forbrug prismodel
🤖 AI-Drevet - Bruger avancerede LLM'er til nøjagtige oversættelser

Godkendelse

For at godkende, brug denne kode:

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

Sørg for at erstatte i18n_your_api_key_here med din API-nøgle.

i18n-agent API'en bruger API-nøgler til at tillade adgang til API'en. Du kan få din API-nøgle fra din kontoadashboard.

API-nøglen skal inkluderes i alle API-anmodninger til serveren i en header, der ser ud som følgende:

Authorization: Bearer i18n_your_api_key_here

Du skal erstatte i18n_your_api_key_here med din personlige API-nøgle.

Endepunkter

Kreditter

Hent teamkreditter

GET /credits

Hent aktuel kreditbalance for det autentificerede team

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Sprog

Liste over understøttede sprog

GET /languages

Få en liste over alle understøttede sprog med kvalitetsvurderinger

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Response Fields

Field	Type	Description
languages	array

Oversættelsesjob

Hent oversættelseshistorik

GET /translations

Få pagineret liste over oversættelsesjob med valgfrie filtre for status, type, målsprog og datointerval

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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

Hent oversættelsesdetaljer

GET /translations/{id}

Hent detaljer om en specifik oversættelse efter 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()
}

Ovenstående kommando returnerer JSON-struktureret som følger:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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

Hent oversættelsesstatus

GET /translations/{id}/status

Hent realtidsstatus for en oversættelsesopgave med detaljeret fremdriftssporing, herunder: fremdriftsprocent, medgået tid, estimeret resterende tid, kontrolpunktinformation, delvis fuldførelse for flersproget oversættelse og forudunderskrevet URLs til fuldførte resultater.

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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)

Download oversættelsesresultat

GET /translations/{id}/result

Download det oversatte indhold

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
id	Yes	Translation ID
language	No	Language code for specific language result

Download originalfil

GET /translations/{id}/original

Download den oprindelige uploadede fil

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
id	Yes	Translation ID

Genoptag oversættelse fra kontrolpunkt

POST /translations/{id}/resume

Genoptag en mislykket eller afbrudt oversættelse fra et specifikt kontrolpunkt eller automatisk fra det seneste succesfulde kontrolpunkt

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

Ovenstående kommando returnerer JSON-struktureret som følger:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
id	Yes	Translation ID

Anmodningsbrødparametre

Parameter	Type	Påkrævet	Beskrivelse
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

Hent aktive oversættelsesopgaver

GET /translations/jobs/active

Hent liste over aktuelt aktive oversættelsesopgaver

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

Ovenstående kommando returnerer JSON struktureret som følger:

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

Download oversættelsesresultater

POST /translations/{jobId}/download

Download fuldførte oversættelsesresultater. Returnerer forudunderskrevne download URLs organiseret efter sprog. URLs udløber efter 24 timer.

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

Ovenstående kommando returnerer JSON struktureret som følger:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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

Download oversættelsesfil for specifikt sprog

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

Download en enkelt oversættelsesfil for et specifikt målsprog. Returnerer filindholdet direkte med passende Content-Type-header.

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

Ovenstående kommando returnerer JSON-struktureret som følger:

"string"

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
jobId	Yes	Translation job ID
language	Yes	Target language code (e.g., 'es', 'fr', 'ja')

Opret oversættelse med streaming-fremgang

POST /translations/stream

Opret oversættelse med Server-Sent Events (SSE) til realtidsfremskridtsopdateringer. Understøtter kun tekstoversættelse (ikke filer). Returnerer realtidsfremskridtsopdateringer som SSE-hændelser.

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

Ovenstående kommando returnerer JSON-struktureret som følger:

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

Anmodningsbrødparametrene

Parameter	Type	Påkrævet	Beskrivelse
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)

Få estimat for oversættelsesomkostninger

POST /translations/estimate

Beregn ordantal og kreditter, der kræves for oversættelsen

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

Ovenstående kommando returnerer JSON struktureret som følger:

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

Anmodningsparametrene

Parameter	Type	Påkrævet	Beskrivelse
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

Upload oversættelsesfil til namespace-genbrug

POST /namespaces/{namespace}/translations/upload

Upload eksisterende oversættelsesfil til et namespace til fremtidig genbrug. Dette muliggør omkostningsoptimering ved at genbruge tidligere oversatte strenge. Filen behandles, og oversættelsespar udtrækkes til caching.

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

Ovenstående kommando returnerer JSON-struktureret som følger:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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

Hent oversættelsesstatistik for namespace

GET /namespaces/{namespace}/translations/stats

Hent statistik om uploadede oversættelsesfiler og genbrug af cache for et namespace

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
namespace	Yes	Namespace identifier

Response Fields

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

Vis liste over uploadede oversættelsesfiler i namespace

GET /namespaces/{namespace}/translations/files

Hent pagineret liste over uploadede oversættelsesfiler for et namespace

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
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

Slet uploadet oversættelsesfil

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

Slet en uploadet oversættelsesfil og alle tilknyttede oversættelsespar fra cachen

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

Ovenstående kommando returnerer JSON struktureret sådan her:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
namespace	Yes	Namespace identifier
fileId	Yes	File ID to delete

Response Fields

Field	Type	Description
success	boolean
fileName	string
pairsDeleted	integer
message	string

Upload parallelle oversættelsesfiler

POST /translations/upload-parallel

Upload kildefiler og målfiler parallelt til oversættelsesparudtrækning og caching. Begge filer bør have samme struktur og filtype.

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Filer

Download fil fra lager

GET /files/{filePath}

Serverer filer fra lokalt lager (udvikling) eller S3 (produktion). Bruges til at få adgang til uploadede og oversatte filer.

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

Ovenstående kommando returnerer JSON struktureret som dette:

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

Forespørgselsparametre

Parameter	Påkrævet	Beskrivelse
filePath	Yes	File path including any subdirectories (e.g., 'uploads/test-file.json' or 'translations/result.json')

Fejl

i18n-agent API'en bruger følgende fejlkoder:

Fejlkode	Betydning
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.

Fejlsvarformat

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

Analyser indhold for oversættelsesparathed

POST /analyze

Let validering af kildetekst for at identificere potentielle problemer før oversættelse. Returnerer valideringsresultater med fejlkoder til programmatisk adgang. Dette endpoint forbruger IKKE kreditter - det kører hurtig, deterministisk validering uden AI/LLM-kald.

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

Ovenstående kommando returnerer JSON struktureret som følger:

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

Anmodningsparametrene i brødteksten

Parameter	Type	Påkrævet	Beskrivelse
targetLanguage	string	Ja	Målets sprogkode for oversættelse
targetAudience	string	Nej	Målgruppe (standard: generel)
industry	string	Nej	Branchekontekst (standard: generel)
sourceLanguage	string	Nej	Kildesprogkode (auto-detekteret hvis ikke angivet)
region	string	Nej	Specifik region til lokalisering
content	object	Ja	Indhold til analyse (tekst, array af tekster eller struktureret objekt)
fileType	string	Nej	Valgfri filtype, hvis indholdet er fra en fil

Namespace-oversættelser

Vælg slutpunkt:

Vælg et slutpunkt ovenfor for at starte testningen

Godkendelse

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

Oversæt tekst

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

Oversæt fil

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"

Godkendelse

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

Oversæt tekst

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

Oversæt fil

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

Godkendelse

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

Oversæt tekst

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

Oversæt fil

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