# FluentRead Translation Services: Complete Guide to Supported Providers and APIs

> Discover FluentRead translation services. Connect to 30+ providers including Google, DeepL, OpenAI, Gemini, and Claude for seamless multilingual content.

- Repository: [ThinkStu/fluentread](https://github.com/bistutu/fluentread)
- Tags: api-reference
- Published: 2026-02-26

---

**FluentRead supports over 30 translation backends, including traditional machine translation APIs (Google, DeepL, Microsoft) and modern LLM-based AI services (OpenAI, Gemini, Claude, DeepSeek), all managed through a centralized registry in [`src/entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/src/entrypoints/utils/option.ts).**

The [bistutu/fluentread](https://github.com/bistutu/fluentread) repository is an open-source browser extension that provides immersive bilingual reading experiences. Understanding which translation services are supported by FluentRead is essential for configuring the optimal backend for your specific language pairs and quality requirements.

## Overview of FluentRead Translation Services

FluentRead implements a **unified service architecture** that abstracts the differences between traditional machine translation engines and generative AI models. The extension categorizes providers into two main groups: conventional MT services optimized for speed and cost, and large language model (LLM) services offering contextual, nuanced translations.

All service identifiers, human-readable names, and capability flags are defined in the centralized registry at [`src/entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/src/entrypoints/utils/option.ts), while concrete implementations reside in [`src/entrypoints/service/_service.ts`](https://github.com/bistutu/fluentread/blob/main/src/entrypoints/service/_service.ts) and individual service modules.

## Complete List of Supported Translation Providers

### Traditional Machine Translation Services

FluentRead integrates with established machine translation APIs that prioritize speed and affordability:

- **Microsoft Translator** (`microsoft`) – Enterprise-grade neural machine translation
- **DeepL** (`deepL`) – High-quality European language specialist
- **DeepLX** (`deeplx`) – Community alternative for DeepL API access
- **Google Translate** (`google`) – Broad language coverage and reliability
- **Xiaoniu** (`xiaoniu`) – 小牛翻译, Chinese MT specialist
- **Youdao** (`youdao`) – 有道翻译, popular Chinese-English translation
- **Tencent Cloud** (`tencent`) – 腾讯云翻译, enterprise Chinese MT
- **Chrome Translator** (`chromeTranslator`) – Chrome内置 AI 翻译, leveraging browser-native capabilities

### AI and Large Language Model Translation Services

For context-aware, high-quality translations, FluentRead supports major LLM providers:

- **OpenAI** (`openai`) – GPT-4, GPT-3.5-turbo models
- **Azure OpenAI** (`azureOpenai`) – Enterprise OpenAI deployment
- **Gemini** (`gemini`) – Google's multimodal AI models
- **Wenxin Yiyan** (`yiyan`) – 文心一言, Baidu's LLM
- **Tongyi** (`tongyi`) – 阿里通义, Alibaba's Qwen models
- **Zhipu** (`zhipu`) – 智谱清言, ChatGLM models
- **Moonshot** (`moonshot`) – Kimi AI assistant
- **Claude** (`claude`) – Anthropic's Claude models
- **DeepSeek** (`deepseek`) – DeepSeek's cost-effective LLMs
- **Grok** (`grok`) – X.AI's Grok models
- **Custom** (`custom`) – User-defined OpenAI-compatible endpoints
- **Additional providers**: Infini (无向芯穹), Baichuan (百川智能), Lingyi (零一万物), MiniMax, Jieyue (阶跃星辰), Groq, Coze (国际/国内), HuanYuan (腾讯混元), Doubao (字节豆包), SiliconCloud (硅基流动), OpenRouter, NewAPI

## How FluentRead Manages Translation Services

### Centralized Service Registry

The extension uses a **single source of truth** for all supported backends. In [`src/entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/src/entrypoints/utils/option.ts), the `services` constant enumerates every available provider:

```typescript
import { services } from '@/entrypoints/utils/option';

// Access service identifiers
console.log(services.google);    // 'google'
console.log(services.openai);  // 'openai'

```

This registry includes human-readable labels, default configurations, and feature classifications that the UI consumes to render service selection dropdowns.

### Dynamic Service Dispatch

Concrete implementations are mapped to identifiers in [`src/entrypoints/service/_service.ts`](https://github.com/bistutu/fluentread/blob/main/src/entrypoints/service/_service.ts). The `_service` object acts as a dispatcher:

```typescript
import { _service } from '@/entrypoints/service/_service';
import { services } from '@/entrypoints/utils/option';

// Dynamic invocation
const translate = _service[services.deepL];
const result = await translate({ text: 'Hello', to: 'zh-Hans' });

```

This architecture decouples the UI and translation logic from specific provider implementations, allowing new services to be added by simply creating a handler module and registering it in the dispatcher.

### Feature Flags and Service Classification

FluentRead categorizes services by capabilities using helper sets in [`option.ts`](https://github.com/bistutu/fluentread/blob/main/option.ts):

- **`servicesType.useToken`**: Services requiring API keys (OpenAI, DeepL, etc.)
- **`servicesType.useProxy`**: Services requiring proxy configuration
- **`servicesType.useCustomUrl`**: Services supporting custom endpoints (Custom, DeepLX, etc.)

These classifications enable the settings UI to conditionally display configuration fields based on the selected service.

## Configuring Translation Services in FluentRead

### Selecting a Default Service

Configure the active translation backend by modifying the `defaultOption` object:

```typescript
import { defaultOption, services } from '@/entrypoints/utils/option';

// Set Microsoft Translator as default
defaultOption.service = services.microsoft;

// Or use an AI model like Gemini
defaultOption.service = services.gemini;

```

### Using the Translation Queue

FluentRead implements a concurrency-controlled queue to manage translation requests. Here's how to enqueue a translation task:

```typescript
import { enqueueTranslation } from '@/entrypoints/utils/translateQueue';
import { _service } from '@/entrypoints/service/_service';
import { services } from '@/entrypoints/utils/option';

const text = 'Hello world';
const targetLang = 'zh-Hans';
const chosenService = services.google;

// Wrap the service call for queue management
const task = () => _service[chosenService]({ text, to: targetLang });

enqueueTranslation(task)
  .then(result => console.log('Translation:', result))
  .catch(err => console.error('Failed:', err));

```

The queue respects `config.maxConcurrentTranslations` (defaulting to 6) to prevent rate limiting.

### Configuring Custom Endpoints

For OpenAI-compatible APIs or self-hosted solutions, use the `custom` service:

```typescript
defaultOption.service = services.custom;
defaultOption.custom = 'https://my.custom.api/v1/translate';

```

The `custom` service is classified under `servicesType.useCustomUrl`, ensuring the UI exposes the custom URL input field when selected.

## Key Implementation Files

| File | Purpose |
|------|---------|
| [`entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/utils/option.ts) | Defines the `services` registry, `defaultOption`, and capability classification sets |
| [`entrypoints/service/_service.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/service/_service.ts) | Maps service identifiers to concrete implementation functions |
| `entrypoints/service/*.ts` | Individual backend implementations (e.g., [`google.ts`](https://github.com/bistutu/fluentread/blob/main/google.ts), [`openai.ts`](https://github.com/bistutu/fluentread/blob/main/openai.ts), [`deepl.ts`](https://github.com/bistutu/fluentread/blob/main/deepl.ts)) |
| [`entrypoints/utils/translateQueue.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/utils/translateQueue.ts) | Concurrency-controlled queue for managing translation requests |
| [`components/SelectionTranslator.vue`](https://github.com/bistutu/fluentread/blob/main/components/SelectionTranslator.vue) | UI component for service selection dropdown |

## Summary

- FluentRead supports **30+ translation services** ranging from traditional machine translation APIs to modern LLM providers.
- The **centralized registry** in [`entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/utils/option.ts) serves as the single source of truth for available backends.
- **Dynamic dispatch** through [`entrypoints/service/_service.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/service/_service.ts) decouples the UI from specific provider implementations.
- Services are classified by capabilities (token usage, proxy requirements, custom URL support) to drive UI configuration options.
- The translation queue manages concurrency to prevent rate limiting when using multiple services.

## Frequently Asked Questions

### How do I add a new translation service to FluentRead?

To add a new backend, create a TypeScript module in `entrypoints/service/` that exports a translation function matching the signature `(params: {text: string, to: string, ...}) => Promise<string>`. Then register the service identifier in [`entrypoints/utils/option.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/utils/option.ts) under the `services` constant, and map the identifier to your implementation in [`entrypoints/service/_service.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/service/_service.ts). The UI will automatically pick up the new service if you add it to the appropriate capability sets (e.g., `useToken` if it requires an API key).

### Does FluentRead support local or self-hosted translation models?

Yes, FluentRead supports custom endpoints through the `custom` service identifier. Configure `defaultOption.service = services.custom` and set `defaultOption.custom` to your local API URL (e.g., `http://localhost:5000/translate`). The custom service expects an OpenAI-compatible interface, making it compatible with self-hosted solutions like Ollama, LocalAI, or vLLM.

### What is the difference between DeepL and DeepLX in FluentRead?

**DeepL** (`deepl`) uses the official DeepL API with proper authentication and rate limits, requiring a valid API key. **DeepLX** (`deeplx`) is a community-maintained alternative that provides access to DeepL's translation capabilities without requiring an official API key, often used for personal or low-volume scenarios. DeepLX is classified under `servicesType.useCustomUrl` because it typically requires specifying a custom endpoint URL.

### How does FluentRead handle rate limiting when using multiple translation services?

FluentRead implements a concurrency-controlled translation queue in [`entrypoints/utils/translateQueue.ts`](https://github.com/bistutu/fluentread/blob/main/entrypoints/utils/translateQueue.ts) that limits simultaneous requests to `config.maxConcurrentTranslations` (defaulting to 6). When you trigger a translation, the service call is wrapped in a task function and enqueued. The queue ensures that even if you rapidly switch between services or translate large volumes of text, no more than 6 concurrent requests hit the APIs at once, preventing rate limit errors and respecting provider quotas.