# DeepL Bulk Text Translator (`mof1re/deepl-bulk-text-translator`) Actor

Translate a list of texts with DeepL, no API key needed. Set the source and target language once, translate hundreds of strings in one run. Auto-detects source language, trims free-tier text at sentence breaks, and returns original text, translation, and language pair per item.

- **URL**: https://apify.com/mof1re/deepl-bulk-text-translator.md
- **Developed by:** [Vladimir Efimenco](https://apify.com/mof1re) (community)
- **Categories:** Integrations, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 unit charges

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## 🌍 DeepL Bulk Text Translator

Batch translate text with DeepL, no API key needed. Give it a list of texts, pick a source and target language once, get every translation back as clean structured data.

### 🤔 What this does

This actor is a bulk text translator built on DeepL, so you don't need your own DeepL API key or subscription to translate text in bulk. Send a list of strings, choose the language to translate from (or let it auto detect), choose the language to translate to, and it returns each item translated and paired with the original.

No DeepL account to set up, no character limits to track yourself, no separate billing. You pay per character translated through your existing Apify account.

### 🎯 Who this is for

- Developers who need to batch translate scraped content, product descriptions, or reviews without wiring up the DeepL API directly
- Teams translating support tickets, user generated content, or datasets for NLP and localization work
- Anyone building an automation pipeline (Make, Zapier, n8n, custom scripts) who wants DeepL quality translation without managing API credentials
- People who want to try DeepL bulk translation before committing to a DeepL Pro plan

### ✅ Why use this instead of the raw DeepL API

- **No API key setup.** Skip creating a DeepL account, generating a key, and handling auth headers just to translate a batch of strings.
- **Pay only for what you translate.** No monthly base fee. You're charged per 100 characters, only when a translation succeeds.
- **Built in language list.** Over 30 languages selectable by name, not by looking up ISO codes.
- **Sentence aware trimming on the free tier.** If your text goes over the free limit, it gets cut at a sentence boundary instead of mid word.
- **Runs anywhere Apify runs.** Trigger it from the Apify API, schedule it, or chain it with other actors in your workflow.

### 💻 Usage examples

#### Python (apify-client)

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")

run_input = {
    "queries": [
        "Hello, how are you?",
        "Where is the nearest train station?",
    ],
    "fromLang": "Auto Detect",
    "toLang": "German",
}

run = client.actor("mof1re/deepl-bulk-text-translator").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["original"], "->", item["translated"])
```

#### Python (async, apify-client)

```python
import asyncio
from apify_client import ApifyClientAsync

async def main():
    client = ApifyClientAsync("<YOUR_API_TOKEN>")

    run_input = {
        "queries": ["Good morning", "See you tomorrow"],
        "fromLang": "English (American)",
        "toLang": "Spanish",
    }

    run = await client.actor("mof1re/deepl-bulk-text-translator").call(run_input=run_input)
    items = await client.dataset(run["defaultDatasetId"]).list_items()

    for item in items.items:
        print(item["original"], "->", item["translated"])

asyncio.run(main())
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/mof1re~deepl-bulk-text-translator/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["Hello world", "Thank you very much"],
    "fromLang": "Auto Detect",
    "toLang": "French"
  }'
```

### 📦 Input

| Field | Type | Description |
|---|---|---|
| `queries` | array of strings | The texts to translate, one item each |
| `fromLang` | string | Source language, or `Auto Detect` (default) |
| `toLang` | string | Target language (default: `English (American)`) |

### 📊 Dataset output

This actor produces a dataset of translated text, one row per item:

| Field | Description |
|---|---|
| `original` | The text you submitted |
| `translated` | The translated text |
| `from_lang` | Source language used |
| `to_lang` | Target language used |
| `units` | Billing units charged for this item (1 unit = 100 characters, rounded up) |

Export the translated dataset as JSON, CSV, Excel, or XML directly from Apify Console, or pull it through the API into your own app.

### 💰 Pricing

This actor uses Apify's pay-per-event pricing:

- **$0.0008 per unit**, where 1 unit = 100 characters translated
- Units are calculated per query, not per run. For each text: 1-100 characters = 1 unit, 101-200 characters = 2 units, and so on, rounding up.
- That works out to roughly **$8 per million characters translated**, well under most standalone translation API rates
- You're only charged for items that translate successfully. Failed or skipped items cost nothing
- No subscription, no monthly minimum, no DeepL account required on your side

### 🆓 Free tier limits

Try the bulk translator before you commit to paid usage:

- **3 runs per day**
- **Up to 5 texts per run**
- **Up to roughly 1,000 characters per text** (trimmed at the nearest sentence end, so you may get slightly more or less than exactly 1,000)

That's enough to confirm translation quality and check the output format fits your use case. For higher volume batch translation, run it under a paid Apify plan. No input changes needed, the actor detects your plan automatically and switches to full speed.

### ⚡ Performance

Paid runs translate through a pool of 5 concurrent workers pulling from a shared queue. As soon as one worker finishes a translation, it picks up the next item immediately, so throughput doesn't wait on the slowest item in a batch. Free tier runs process one text at a time.

### 🔧 Notes

- Auto detect works well for clearly single language text. For short or ambiguous strings, setting `fromLang` explicitly gives more consistent translation results.
- Whitespace and punctuation count toward character totals, same as DeepL's own billing rules.
- The actor never fails a whole run over a single bad item. Any translation error is logged and skipped so the rest of your batch still completes and gets pushed to the dataset.

Built for anyone who needs a DeepL bulk translator, batch text translation, or a no code way to translate a list of strings without touching the DeepL API directly.

### 🔗 See also

Need a scraper for another platform? Check out:

- [Tripadvisor Reviews Scraper](https://apify.com/mof1re/tripadvisor-reviews-scraper)
- [Booking.com Reviews Scraper](https://apify.com/mof1re/booking-reviews-scraper-browserless)
- [AirBnb Reviews Scraper](https://apify.com/mof1re/airbnb-reviews-scraper-browserless)
- [Trustpilot Reviews Scraper](https://apify.com/mof1re/trustpilot-scraper-fast-browserlessapif)
- [ULTA Reviews Scraper](https://apify.com/mof1re/ulta-reviews-scraper)
- [Zillow Listings Scraper](https://apify.com/mof1re/zillow-scraper)
- [Advanced Youtube Transcription Scraper(AI, Translations)](https://apify.com/mof1re/youtube-transcript-scraper-ai-translatiton)

# Actor input Schema

## `queries` (type: `array`):

List of text strings to translate. Each item is translated separately using the same source/target language settings below.

## `fromLang` (type: `string`):

Source language of the text. Leave as Auto Detect to let DeepL detect it automatically.

## `toLang` (type: `string`):

Target language for the translation.

## Actor input object example

```json
{
  "queries": [
    "Hello, how are you?",
    "Bonjour tout le monde"
  ],
  "fromLang": "Auto Detect",
  "toLang": "English (American)"
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "queries": [
        "Hello, how are you?",
        "Bonjour tout le monde"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("mof1re/deepl-bulk-text-translator").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "queries": [
        "Hello, how are you?",
        "Bonjour tout le monde",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("mof1re/deepl-bulk-text-translator").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "queries": [
    "Hello, how are you?",
    "Bonjour tout le monde"
  ]
}' |
apify call mof1re/deepl-bulk-text-translator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=mof1re/deepl-bulk-text-translator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/cHRSAMQ0YsWGtOZn4/builds/HPhlpyuQizSAM9FLc/openapi.json