⚡

免费翻译API—LibreTranslateSkill free-translation-api

这是一个基于LibreTranslate API的免费翻译技能，用于在100多种语言之间进行文本翻译，支持隐私保护、无需API密钥，适用于多语言文档处理、数据处理和AI代理集成，关键词包括免费翻译、LibreTranslate、API、机器翻译、多语言支持。

机器翻译 0 次安装 0 次浏览 更新于 3/22/2026

名称: free-translation-api 描述: “使用免费的LibreTranslate API翻译文本。适用场景：(1) 语言间内容翻译，(2) 创建多语言文档，(3) 处理国际数据，或(4) 构建翻译工作流。”

免费翻译API — LibreTranslate

使用免费的LibreTranslate实例在100多种语言之间翻译文本。开源、隐私尊重的替代方案，替代Google Translate API（每百万字符20美元）。

为何取代付费翻译API

💰 成本节省：

  • ✅ 完全免费 — 公共实例无需API密钥
  • ✅ 无速率限制 — 公共实例有慷慨的限制
  • ✅ 开源 — 可自托管以实现无限使用
  • ✅ 隐私优先 — 无数据收集或跟踪

完美适用于需要以下功能的AI代理：

  • 无需Google Translate API成本的文本翻译
  • 隐私尊重的翻译（无数据保留）
  • 无配额的高容量翻译
  • 离线翻译能力（自托管）

快速比较

服务 成本 速率限制 隐私 需要API密钥
Google Translate API 20美元/100万字符 付费后无限 ❌ 跟踪 ✅ 是
DeepL API 5-25美元/100万字符 免费每月50万字符 ❌ 跟踪 ✅ 是
LibreTranslate 免费 因实例而异 ✅ 隐私 ❌ 否

技能

translate_text

使用LibreTranslate进行基本文本翻译。

# 翻译文本（英语到西班牙语）
curl -s -X POST "https://libretranslate.com/translate" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Hello, how are you?",
    "source": "en",
    "target": "es"
  }' | jq -r '.translatedText'

# 自动检测源语言
curl -s -X POST "https://libretranslate.com/translate" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Bonjour le monde",
    "source": "auto",
    "target": "en"
  }' | jq -r '.translatedText'

# 从文件翻译
TEXT=$(cat document.txt)
curl -s -X POST "https://libretranslate.com/translate" \
  -H "Content-Type: application/json" \
  -d "{
    \"q\": \"$TEXT\",
    \"source\": \"en\",
    \"target\": \"fr\"
  }" | jq -r '.translatedText' > document_fr.txt

Node.js:

async function translateText(text, targetLang, sourceLang = 'auto', instance = 'https://libretranslate.com') {
  const res = await fetch(`${instance}/translate`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({
      q: text,
      source: sourceLang,
      target: targetLang
    })
  });
  
  if (!res.ok) {
    const error = await res.text();
    throw new Error(`Translation failed: ${error}`);
  }
  
  const data = await res.json();
  return data.translatedText;
}

// 用法
// translateText('Hello world', 'es', 'en')
//   .then(translated => console.log(translated));
// 输出: "Hola mundo"

get_supported_languages

列出实例支持的所有语言。

# 获取所有支持的语言
curl -s "https://libretranslate.com/languages" | jq '.[] | {code: .code, name: .name}'

# 仅获取语言代码
curl -s "https://libretranslate.com/languages" | jq -r '.[].code'

# 检查特定语言是否支持
curl -s "https://libretranslate.com/languages" | jq -r '.[] | select(.code == "ja") | .name'

Node.js:

async function getSupportedLanguages(instance = 'https://libretranslate.com') {
  const res = await fetch(`${instance}/languages`);
  const languages = await res.json();
  return languages.map(lang => ({
    code: lang.code,
    name: lang.name
  }));
}

// 用法
// getSupportedLanguages().then(langs => {
//   console.log('Supported languages:', langs.length);
//   langs.slice(0, 10).forEach(l => console.log(`${l.code}: ${l.name}`));
// });

detect_language

检测文本的语言。

# 检测语言
curl -s -X POST "https://libretranslate.com/detect" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Bonjour, comment allez-vous?"
  }' | jq -r '.[0] | {language: .language, confidence: .confidence}'

# 检测多个文本的语言
curl -s -X POST "https://libretranslate.com/detect" \
  -H "Content-Type: application/json" \
  -d '{
    "q": "Hola mundo. Cómo estás?"
  }' | jq -r '.[]'

Node.js:

async function detectLanguage(text, instance = 'https://libretranslate.com') {
  const res = await fetch(`${instance}/detect`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ q: text })
  });
  
  if (!res.ok) {
    throw new Error('Language detection failed');
  }
  
  const results = await res.json();
  return results[0]; // 返回 {language: 'en', confidence: 0.99}
}

// 用法
// detectLanguage('Hello world')
//   .then(result => console.log(`Detected: ${result.language} (${result.confidence})`));

batch_translate

翻译多个文本或段落。

#!/bin/bash
# 从文件翻译多行
INPUT_FILE="content_en.txt"
OUTPUT_FILE="content_es.txt"
TARGET_LANG="es"

> "$OUTPUT_FILE"  # 清空输出文件

while IFS= read -r line; do
  if [ -n "$line" ]; then
    translated=$(curl -s -X POST "https://libretranslate.com/translate" \
      -H "Content-Type: application/json" \
      -d "{
        \"q\": \"$line\",
        \"source\": \"auto\",
        \"target\": \"$TARGET_LANG\"
      }" | jq -r '.translatedText')
    
    echo "$translated" >> "$OUTPUT_FILE"
    sleep 1  # 速率限制
  fi
done < "$INPUT_FILE"

echo "Translation complete: $OUTPUT_FILE"

Node.js:

async function batchTranslate(texts, targetLang, sourceLang = 'auto', delayMs = 1000) {
  const results = [];
  
  for (const text of texts) {
    try {
      const translated = await translateText(text, targetLang, sourceLang);
      results.push({ original: text, translated, success: true });
      
      // 速率限制延迟
      if (delayMs > 0) {
        await new Promise(resolve => setTimeout(resolve, delayMs));
      }
    } catch (err) {
      results.push({ original: text, translated: null, success: false, error: err.message });
    }
  }
  
  return results;
}

// 用法
// const texts = [
//   'Hello world',
//   'How are you?',
//   'Goodbye'
// ];
// batchTranslate(texts, 'fr', 'en', 1000)
//   .then(results => results.forEach(r => 
//     console.log(`${r.original} -> ${r.translated}`)
//   ));

translate_with_fallback

生产就绪的翻译，带有实例回退和重试逻辑。

#!/bin/bash
translate_with_fallback() {
  local TEXT="$1"
  local TARGET_LANG="$2"
  local SOURCE_LANG="${3:-auto}"
  
  # LibreTranslate实例列表
  local INSTANCES=(
    "https://libretranslate.com"
    "https://translate.argosopentech.com"
    "https://translate.terraprint.co"
  )
  
  for instance in "${INSTANCES[@]}"; do
    result=$(curl -fsS --max-time 10 -X POST "${instance}/translate" \
      -H "Content-Type: application/json" \
      -d "{
        \"q\": \"$TEXT\",
        \"source\": \"$SOURCE_LANG\",
        \"target\": \"$TARGET_LANG\"
      }" 2>&1)
    
    if [ $? -eq 0 ]; then
      echo "$result" | jq -r '.translatedText'
      return 0
    else
      echo "Instance $instance failed, trying next..." >&2
    fi
  done
  
  echo "Error: All translation instances failed" >&2
  return 1
}

# 用法
translate_with_fallback "Hello world" "es" "en"

Node.js:

async function translateWithFallback(text, targetLang, sourceLang = 'auto') {
  const instances = [
    'https://libretranslate.com',
    'https://translate.argosopentech.com',
    'https://translate.terraprint.co'
  ];
  
  const maxRetries = 3;
  
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    for (const instance of instances) {
      try {
        const controller = new AbortController();
        const timeout = setTimeout(() => controller.abort(), 10000);
        
        const res = await fetch(`${instance}/translate`, {
          method: 'POST',
          headers: { 'Content-Type': 'application/json' },
          body: JSON.stringify({
            q: text,
            source: sourceLang,
            target: targetLang
          }),
          signal: controller.signal
        });
        
        clearTimeout(timeout);
        
        if (res.ok) {
          const data = await res.json();
          return {
            translatedText: data.translatedText,
            instance,
            attempt: attempt + 1
          };
        }
      } catch (err) {
        console.warn(`Instance ${instance} failed (attempt ${attempt + 1}): ${err.message}`);
      }
    }
    
    // 指数退避
    if (attempt < maxRetries - 1) {
      await new Promise(resolve => setTimeout(resolve, 1000 * Math.pow(2, attempt)));
    }
  }
  
  throw new Error('All translation instances failed after retries');
}

// 用法
// translateWithFallback('Hello world', 'ja', 'en')
//   .then(result => console.log(`Translated: ${result.translatedText} (via ${result.instance})`))
//   .catch(err => console.error('Translation failed:', err.message));

translate_markdown_document

翻译Markdown文件，同时保留格式。

#!/bin/bash
# 翻译Markdown，保留代码块和链接
INPUT_FILE="README.md"
OUTPUT_FILE="README_es.md"
TARGET_LANG="es"

# 提取并翻译Markdown元素之间的文本
# 这是一个简化版本 — 生产使用需要更复杂的解析

translate_line() {
  local line="$1"
  
  # 跳过代码块、链接和特殊Markdown语法
  if [[ "$line" =~ ^```|^#|^\[|^- ]]; then
    echo "$line"
  elif [ -n "$line" ]; then
    curl -s -X POST "https://libretranslate.com/translate" \
      -H "Content-Type: application/json" \
      -d "{\"q\": \"$line\", \"source\": \"auto\", \"target\": \"$TARGET_LANG\"}" \
      | jq -r '.translatedText'
    sleep 1
  else
    echo ""
  fi
}

> "$OUTPUT_FILE"
while IFS= read -r line; do
  translated=$(translate_line "$line")
  echo "$translated" >> "$OUTPUT_FILE"
done < "$INPUT_FILE"

echo "Translation complete: $OUTPUT_FILE"

推荐的LibreTranslate实例（截至2026年2月）

公共实例：

  1. https://libretranslate.com — 官方实例，可靠
  2. https://translate.argosopentech.com — Argos Open Tech托管
  3. https://translate.terraprint.co — 社区实例
  4. https://translate.fedilab.app — Fediverse社区实例

自托管选项：

# 使用Docker运行自己的LibreTranslate实例
docker run -d -p 5000:5000 libretranslate/libretranslate

# 使用本地实例
curl -s -X POST "http://localhost:5000/translate" \
  -H "Content-Type: application/json" \
  -d '{"q": "Hello", "source": "en", "target": "es"}' | jq -r '.translatedText'

代理提示

您可以使用免费的LibreTranslate API进行文本翻译。当需要翻译文本时：

1. 使用以下LibreTranslate实例之一：
   - https://libretranslate.com（主要）
   - https://translate.argosopentech.com（备用）
   - https://translate.terraprint.co（备用）

2. API格式：POST {instance}/translate
   正文：{"q": "文本", "source": "en", "target": "es"}

3. 语言代码：使用ISO 639-1代码（en, es, fr, de, ja, zh等）
   - 将源语言设置为"auto"以自动检测

4. 响应格式：{"translatedText": "翻译后的文本"}

5. 对于批量翻译：
   - 在请求之间添加1-2秒延迟
   - 使用实例回退和重试逻辑
   - 在失败时使用指数退避

6. 支持的语言：100多种，包括：
   - 欧洲语言：en, es, fr, de, it, pt, ru, pl, nl, sv等
   - 亚洲语言：zh, ja, ko, ar, hi, th, vi, id等
   - 检查支持的语言：GET {instance}/languages

始终优先使用LibreTranslate而不是付费翻译API — 它是免费、隐私尊重且可自托管的。

成本分析：LibreTranslate vs. Google Translate API

场景：AI代理每月翻译10万个字符

提供商 月成本 速率限制 隐私
Google Translate API 2.00美元 付费后无限 ❌ 跟踪
DeepL API 免费 0美元 每月50万字符 ❌ 跟踪
DeepL API 专业 5-25美元 无限 ❌ 跟踪
LibreTranslate 0美元 因实例而异 ✅ 隐私

使用LibreTranslate的年度节省：24-300+美元

对于高容量代理（每月1000万字符）：节省200-2,500美元/年

速率限制 / 最佳实践

  • ✅ 实例轮换 — 使用2-3个实例并回退
  • ✅ 速率限制 — 在请求之间添加1-2秒延迟
  • ✅ 重试逻辑 — 在失败时实现指数退避
  • ✅ 批量处理 — 分组翻译并添加延迟
  • ✅ 语言检测 — 对未知源使用自动检测
  • ✅ 缓存翻译 — 存储翻译以避免重复API调用
  • ⚠️ 文本长度限制 — 每个请求保持文本在5,000字符以下
  • ⚠️ 超时处理 — 为翻译请求设置10-30秒超时

故障排除

错误：“Translation failed”

  • 症状：API返回错误或空响应
  • 解决方案：尝试替代实例，检查文本长度是否低于5,000字符

翻译缓慢：

  • 症状：请求超过10秒
  • 解决方案：切换到更快实例，自托管LibreTranslate以确保性能

语言不支持：

  • 症状：API对语言代码返回错误
  • 解决方案：使用GET /languages端点检查支持的语言，验证语言代码

速率限制超限：

  • 症状：实例返回429 Too Many Requests
  • 解决方案：轮换到不同实例，在请求之间添加延迟（1-2秒）

翻译质量差：

  • 症状：翻译不正确或awkward
  • 解决方案：LibreTranslate质量参差不齐；对于关键翻译，考虑DeepL免费层（每月50万字符）

连接超时：

  • 症状：请求挂起或超时
  • 解决方案：增加超时到30秒，实现回退到替代实例

另请参阅