Elarus provides high-performance, real-time translation services powered by Groq's LPU infrastructure. It offers a simple JSON API for AI-powered translations with smart caching and rate limiting.
The API is available at https://elarus.vercel.app/api with three main endpoints:
| Endpoint | Method | Description |
|---|---|---|
/translate |
POST | Standard translation with intelligent caching |
/retranslate |
POST | Force fresh translation (bypass cache) |
/health |
GET | System status and health check |
All translation endpoints accept JSON with:
{
"text": "Text to translate",
"target_lang": "Target language",
"source_lang": "Source language (optional)"
}Successful responses return:
{
"source_language": "EN",
"target_language": "Spanish",
"translated_text": "Texto traducido",
"status": "cached"
}# Basic translation
curl -X POST https://elarus.vercel.app/api/translate \
-H "Content-Type: application/json" \
-d '{"text": "Hello world", "target_lang": "Spanish"}'
# Force fresh translation
curl -X POST https://elarus.vercel.app/api/retranslate \
-H "Content-Type": application/json" \
-d '{"text": "Hello world", "target_lang": "French"}'
# Health check
curl https://elarus.vercel.app/api/healthimport requests
def translate_text(text, target_lang, force_refresh=False):
endpoint = "/api/retranslate" if force_refresh else "/api/translate"
response = requests.post(
f"https://elarus.vercel.app{endpoint}",
json={"text": text, "target_lang": target_lang}
)
return response.json()
# Usage examples
result = translate_text("Good morning", "Japanese")
print(f"Translation: {result['translated_text']}")
# Force fresh translation
fresh_result = translate_text("Thank you", "German", force_refresh=True)
print(f"Status: {fresh_result['status']}")class ElarusClient {
constructor(baseUrl = 'https://elarus.vercel.app') {
this.baseUrl = baseUrl;
}
async translate(text, targetLang, forceRefresh = false) {
const endpoint = forceRefresh ? '/api/retranslate' : '/api/translate';
const response = await fetch(`${this.baseUrl}${endpoint}`, {
method: 'POST',
headers: { 'Content-Type': 'a
8000
pplication/json' },
body: JSON.stringify({ text, target_lang: targetLang })
});
return await response.json();
}
async health() {
const response = await fetch(`${this.baseUrl}/api/health`);
return await response.json();
}
}
// Usage
const client = new ElarusClient();
client.translate('Hello world', 'Spanish')
.then(result => console.log(result.translated_text));import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import com.google.gson.Gson;
public class ElarusClient {
private static final String BASE_URL = "https://elarus.vercel.app";
private final HttpClient client = HttpClient.newHttpClient();
private final Gson gson = new Gson();
public TranslationResult translate(String text, String targetLang, boolean forceRefresh) throws Exception {
String endpoint = forceRefresh ? "/api/retranslate" : "/api/translate";
String json = gson.toJson(new TranslationRequest(text, targetLang));
HttpRequest request = HttpRequest.newBuilder()
.uri(URI.create(BASE_URL + endpoint))
.header("Content-Type", "application/json")
.POST(HttpRequest.BodyPublishers.ofString(json))
.build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
return gson.fromJson(response.body(), TranslationResult.class);
}
// Helper classes
static class TranslationRequest {
String text;
String target_lang;
TranslationRequest(String text, String targetLang) {
this.text = text;
this.target_lang = targetLang;
}
}
static class TranslationResult {
String source_language;
String target_language;
String translated_text;
String status;
}
}package main
import (
"bytes"
"encoding/json"
"fmt"
"net/http"
)
type TranslationRequest struct {
Text string `json:"text"`
TargetLang string `json:"target_lang"`
}
type TranslationResult struct {
SourceLanguage string `json:"source_language"`
TargetLanguage string `json:"target_language"`
TranslatedText string `json:"translated_text"`
Status string `json:"status"`
}
func Translate(text, targetLang string, forceRefresh bool) (*TranslationResult, error) {
endpoint := "/api/translate"
if forceRefresh {
endpoint = "/api/retranslate"
}
reqBody := TranslationRequest{Text: text, TargetLang: targetLang}
jsonData, _ := json.Marshal(reqBody)
resp, err := http.Post("https://elarus.vercel.app"+endpoint, "application/json", bytes.NewBuffer(jsonData))
if err != nil {
return nil, err
}
defer resp.Body.Close()
var result TranslationResult
err = json.NewDecoder(resp.Body).Decode(&result)
return &result, err
}
// Usage
func main() {
result, err := Translate("Hello world", "Spanish", false)
if err != nil {
panic(err)
}
fmt.Printf("Translation: %s\n", result.TranslatedText)
}- AI-Powered: Uses Groq's GPT-OSS-120B model for high-quality translations
- Smart Caching: Redis-based caching reduces latency for repeated and common translations
- Auto Language Detection: Automatically identifies source language
- JSON API: Consistent RESTful API with detailed error responses
- Multi-language Support: 100+ languages including English, Spanish, French, German, Chinese, Japanese, Arabic, and many more
- Fast Response Times: Typically responds within milliseconds to 5 seconds depending on text length and cache status
- Rate Limit: 1 request per 2 seconds for every IP address
- Token Limit: Maximum 300 tokens per request
- Text Length: Maximum 2000 characters per request
- Response Time: Typically between milliseconds and 5 seconds depending on text length and cache status
- Cached Responses: Near-instant response for repeated translations
All errors return consistent JSON format:
{
"error": "Error description",
"details": "Additional context",
"status_code": 400
}Common error codes:
400- Invalid request (missing fields, invalid format)429- Rate limit exceeded500- Internal server error
Test the API with our interactive playground: https://elarus.vercel.app