# MyMemory Translation Scraper (`parseforge/mymemory-translation-scraper`) Actor

Query MyMemory, the world's largest translation memory, with billions of human and machine translations. Translate text across 100+ languages with quality match scores, source attribution, and reference segments. Export to JSON, CSV, or Excel for localization and language research.

- **URL**: https://apify.com/parseforge/mymemory-translation-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Automation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 result items

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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🌐 MyMemory Translation Scraper

> 🚀 **Translate text across 70+ language pairs in seconds.** Submit a batch of strings, pick source and target languages, and get translations plus alternative matches with quality scores, subject tags, and contributor info from MyMemory's **1,000,000,000+** translation memory. No login required for small jobs.

> 🕒 **Last updated:** 2026-05-23 · **📊 19 fields** per record · **🌐 70+ language codes** · **🧠 1B+ translation memory** · **🆓 10k chars/day anonymous**

The **MyMemory Translation Scraper** queries the MyMemory shared translation memory and returns **19 structured fields per translation**, including the best match, alternative matches, quality scores, subject area, contributor handle, usage count, creation and update timestamps, and quota status. MyMemory is the world's largest shared translation memory and aggregates contributions from professional translators and global community members.

The service supports **70+ language codes**, including regional variants like English (UK/US), Portuguese (PT/BR), Spanish (ES), and Chinese (Simplified/Traditional). This Actor turns a batch of strings into a tabular dataset in seconds with all alternatives returned per row.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Mobile and web app builders, ESL and EdTech teams, content i18n teams, marketing localization agencies, indie developers, translation researchers | Bulk UI string translation, ESL flashcard generation, content localization for blogs and stores, A/B testing of translated copy, translation memory seeding |

---

### 📋 What the MyMemory Translation Scraper does

A single batch translation workflow:

- 📝 **Bulk text input.** Submit an array of strings, each becomes one record.
- 🌐 **Source language selection.** Pick from 70+ ISO codes including regional variants.
- 🎯 **Target language selection.** Same 70+ code list.
- 📧 **Optional quota uplift.** Pass an email to raise the anonymous daily character quota.

Each record includes the source text, best translation, source and target language codes, match score (0-1), best match source and target text, quality grade, subject area, usage count, contributor handle, creation and last-update dates, the full list of alternative matches, plus quota status and response details.

> 💡 **Why it matters:** MyMemory is a free, broad-coverage shared translation memory that powers everything from quick UI localization to large content workflows. Building your own bulk runner against it means handling quotas, retries, and result merging by hand. This Actor returns clean structured rows in one pass.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded translation batch._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td>maxItems</td><td>integer</td><td>10</td><td>Translations to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td>texts</td><td>array</td><td>5-phrase sampler</td><td>Strings to translate. Each becomes one record.</td></tr>
<tr><td>sourceLanguage</td><td>string</td><td>"en"</td><td>ISO source language code. 70+ options.</td></tr>
<tr><td>targetLanguage</td><td>string</td><td>"es"</td><td>ISO target language code. 70+ options.</td></tr>
<tr><td>notifyEmail</td><td>string</td><td>""</td><td>Optional email. Raises the daily anonymous quota.</td></tr>
</tbody>
</table>

**Example: translate 5 travel phrases from English to Japanese.**

```json
{
    "maxItems": 5,
    "texts": ["Where is the train station?", "Two tickets please", "How much does it cost?", "Thank you very much", "I would like a coffee"],
    "sourceLanguage": "en",
    "targetLanguage": "ja"
}
````

**Example: translate UI strings from English (US) to Portuguese (BR).**

```json
{
    "maxItems": 20,
    "texts": ["Sign in", "Create an account", "Forgot password?", "Continue with Google", "By signing up you agree to our Terms"],
    "sourceLanguage": "en-US",
    "targetLanguage": "pt-BR",
    "notifyEmail": "you@example.com"
}
```

> ⚠️ **Good to Know:** the anonymous daily quota is 10,000 characters. Supplying an email raises it. For very large jobs split the work across days or use a paid translation provider downstream.

***

### 📊 Output

Each translation record contains **19 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 📝 `sourceText` | string | `"Hello, world!"` |
| 🌐 `translatedText` | string | `"¡Hola, mundo!"` |
| 🌍 `sourceLanguage` | string | `"en"` |
| 🎯 `targetLanguage` | string | `"es"` |
| 📊 `matchScore` | number | `1` |
| 🔎 `bestMatchSource` | string | `"Hello, world!"` |
| 🎯 `bestMatchTarget` | string | `"¡Hola, mundo!"` |
| ✅ `bestMatchQuality` | string | `"74"` |
| 🏷️ `bestMatchSubject` | string | `"All"` |
| 🔢 `bestMatchUsageCount` | number | `12` |
| 👤 `bestMatchCreatedBy` | string | `"MateCat"` |
| 📅 `bestMatchCreateDate` | string | `"2017-08-10 14:32:18"` |
| 🔁 `bestMatchLastUpdate` | string | `"2024-02-11 09:01:44"` |
| 🔢 `alternateMatchCount` | number | `4` |
| 🌍 `alternateMatches` | array | `[{"translation":"Hola mundo","quality":"70","subject":"Tech"}]` |
| 📡 `responseStatus` | number | `200` |
| ⚠️ `quotaFinished` | boolean | `false` |
| 💬 `responseDetails` | string | `""` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-23T00:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🇪🇸 English to Spanish greeting</strong></summary>

```json
{
    "sourceText": "Hello, world!",
    "translatedText": "¡Hola, mundo!",
    "sourceLanguage": "en",
    "targetLanguage": "es",
    "matchScore": 1,
    "bestMatchSource": "Hello, world!",
    "bestMatchTarget": "¡Hola, mundo!",
    "bestMatchQuality": "74",
    "bestMatchSubject": "All",
    "bestMatchUsageCount": 12,
    "bestMatchCreatedBy": "MateCat",
    "bestMatchCreateDate": "2017-08-10 14:32:18",
    "bestMatchLastUpdate": "2024-02-11 09:01:44",
    "alternateMatchCount": 3,
    "alternateMatches": [
        {"translation": "Hola mundo", "quality": "70", "subject": "Tech"},
        {"translation": "¡Hola, Mundo!", "quality": "65", "subject": "All"}
    ],
    "responseStatus": 200,
    "quotaFinished": false,
    "responseDetails": "",
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇯🇵 English to Japanese UI string</strong></summary>

```json
{
    "sourceText": "Sign in",
    "translatedText": "サインイン",
    "sourceLanguage": "en",
    "targetLanguage": "ja",
    "matchScore": 0.96,
    "bestMatchSource": "Sign in",
    "bestMatchTarget": "サインイン",
    "bestMatchQuality": "74",
    "bestMatchSubject": "Tech",
    "bestMatchUsageCount": 41,
    "bestMatchCreatedBy": "anonymous",
    "bestMatchCreateDate": "2014-04-30 11:01:08",
    "bestMatchLastUpdate": "2025-09-18 04:11:54",
    "alternateMatchCount": 5,
    "alternateMatches": [
        {"translation": "ログイン", "quality": "70", "subject": "Tech"}
    ],
    "responseStatus": 200,
    "quotaFinished": false,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇧🇷 English (US) to Portuguese (BR) marketing copy</strong></summary>

```json
{
    "sourceText": "Get started for free",
    "translatedText": "Comece de graça",
    "sourceLanguage": "en-US",
    "targetLanguage": "pt-BR",
    "matchScore": 0.82,
    "bestMatchSource": "Get started for free",
    "bestMatchTarget": "Comece de graça",
    "bestMatchQuality": "73",
    "bestMatchSubject": "Marketing",
    "bestMatchUsageCount": 8,
    "alternateMatchCount": 4,
    "alternateMatches": [
        {"translation": "Começar gratuitamente", "quality": "70", "subject": "Marketing"}
    ],
    "responseStatus": 200,
    "quotaFinished": false,
    "scrapedAt": "2026-05-23T00:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🌐 | **70+ language codes.** Major languages plus regional variants like en-GB, pt-BR, zh-TW. |
| 🎯 | **Alternative matches included.** Best match plus several alternatives with quality and subject. |
| 📊 | **Quality scores.** 0-1 match score and a numeric quality grade per row for downstream ranking. |
| 🆓 | **Free tier friendly.** Up to 10,000 characters per day anonymously, more with an email. |
| ⚡ | **Fast.** 10 translations in under 5 seconds, 1,000 in under a minute. |
| 🔁 | **Always live.** Every run hits the live shared translation memory. |
| 🚫 | **No login required.** Public translation memory, no key needed. |

> 📊 Shared translation memories are the cheapest way to localize copy, UI strings, and EdTech content at scale.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Quality | Setup |
|---|---|---|---|---|
| **⭐ MyMemory Translation Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **70+ language codes** | Crowd-curated with quality scores | ⚡ 2 min |
| Commercial machine translation | $20/1M chars | 130+ languages | Vendor-dependent | ⏳ Hours to wire up |
| Human translation services | $0.10-0.20/word | Any | Highest | 🐢 Days |
| Open-source MT models | Compute cost | Limited | Variable | ⏳ Days to deploy |

Pick this Actor when you want fast bulk translation with alternatives and quality scores attached to every row.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the MyMemory Translation Scraper page on the Apify Store.
3. 🎯 **Set input.** Paste your strings, pick source and target language codes, optionally supply an email.
4. 🚀 **Run it.** Click **Start** and let the Actor collect translations.
5. 📥 **Download.** Grab your results from the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 📱 App & Web Localization

- Bulk-translate UI strings before sending to a TMS
- Quick mock translations for design QA
- Localize legal, terms, and privacy copy drafts
- Pre-fill empty translation slots in i18n files

</td>
<td width="50%" valign="top">

#### 📚 ESL & EdTech

- Build flashcard decks with verified translations
- Generate bilingual example sentences for lessons
- Source vocabulary lists for placement tests
- Build quick reference glossaries per topic

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🛍️ Content i18n at Scale

- Translate product titles and descriptions across markets
- Localize blog excerpts and meta tags for SEO
- Build multilingual help-center stub articles
- A/B test translated headlines in marketing

</td>
<td width="50%" valign="top">

#### 🤖 Translation Memory Seeding

- Bootstrap a new TMS with a baseline TM
- Augment a domain TM with general-purpose matches
- Source candidate translations for human review
- Build training data for in-house MT projects

</td>
</tr>
</table>

***

### 🔌 Automating MyMemory Translation Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Daily refreshes keep a downstream localization pipeline topped up with fresh batch translations.

***

### 🌟 Beyond business use cases

Bulk translation powers more than commercial workflows. The same structured rows support research, education, civic projects, and personal initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Translation memory studies and dataset releases
- Cross-lingual NLP experiment prep
- Reproducible bilingual corpus generation
- Comparative translation-quality benchmarks

</td>
<td width="50%">

#### 🎨 Personal and creative

- Travel phrasebook generation for trip planning
- Bilingual journaling and diary apps
- Multilingual subtitle drafts for indie video
- Polyglot vocabulary tracker exports

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Translate aid materials into refugee languages
- Localize voter-information sheets for minority languages
- Provide free translations for community-language schools
- Build outreach materials for multilingual neighborhoods

</td>
<td width="50%">

#### 🧪 Experimentation

- Train translation-ranking models with quality grades
- Prototype browser-extension translators
- Benchmark TM quality across language pairs
- Test multilingual chatbot stubs in low-resource pairs

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20MyMemory%20Translation%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20MyMemory%20Translation%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20MyMemory%20Translation%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20MyMemory%20Translation%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Submit an array of strings, pick source and target language codes, click Start. The Actor returns one structured row per string with the best translation, several alternatives, and quality scores.

#### 📏 How accurate are the translations?

Quality varies by language pair. Common pairs like English-Spanish or English-French often return high-quality crowd-curated matches. Less common pairs lean on machine translation. Use the `matchScore` and `bestMatchQuality` fields to filter.

#### 🔁 How often is the translation memory updated?

MyMemory is updated continuously by its global contributor community. Every Actor run hits the live memory.

#### 🌐 Which languages are supported?

70+ language codes including English (UK/US), Spanish (ES), Portuguese (BR), Chinese (Simplified/Traditional), Japanese, Korean, Arabic, Hindi, and many more. The full enum is exposed in the input form.

#### 🆓 What is the free quota?

10,000 characters per day anonymously. Supplying an email raises it. For very large workloads split jobs across days or use a paid translation provider.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to trigger this Actor on any cron interval (daily, weekly).

#### ⚖️ Is this service legal to use?

Yes. MyMemory is a public shared translation memory. Honor its terms of service for very high-volume use.

#### 💼 Can I use the translations commercially?

Yes, for most use cases. The shared memory is permissive but always review MyMemory's own terms for your specific commercial scenario.

#### 💳 Do I need a paid Apify plan to use this Actor?

No. The free plan covers testing and small runs (10 records per run). A paid plan unlocks the higher cap, scheduling, and concurrency.

#### 🔁 What happens if a run fails or gets interrupted?

Apify retries transient errors automatically. If a run still fails, inspect the log, fix the input, and restart. Partial datasets are preserved.

#### 🆘 What if I need help?

Our support team is here. Use the Apify platform messaging or the Tally form linked below.

***

### 🔌 Integrate with any app

MyMemory Translation Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe translation data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes. Push fresh translations into your CMS or alert your localization team in Slack.

***

### 🔗 Recommended Actors

- [**🗣️ Tatoeba Sentence Corpus Scraper**](https://apify.com/parseforge/tatoeba-sentence-corpus-scraper) - 12M+ multilingual example sentences
- [**📚 LibriVox Audiobooks Scraper**](https://apify.com/parseforge/librivox-audiobooks-scraper) - Public-domain audiobooks
- [**🏛️ Library of Congress Scraper**](https://apify.com/parseforge/loc-gov-library-of-congress-scraper) - 170M+ digitized cultural records
- [**📰 ArXiv Scraper**](https://apify.com/parseforge/arxiv-scraper) - Academic preprints with metadata
- [**📖 Figshare Scraper**](https://apify.com/parseforge/figshare-scraper) - Open research datasets and figures

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by MyMemory or Translated S.r.l. All trademarks mentioned are the property of their respective owners. Only publicly available translation memory data is collected, under MyMemory's published terms of service.

# Actor input Schema

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## `texts` (type: `array`):

Array of strings to translate. Each string becomes one record. Defaults to a 10-phrase travel sampler when empty.

## `sourceLanguage` (type: `string`):

ISO language code (e.g. en, en-GB, es, fr).

## `targetLanguage` (type: `string`):

ISO language code for the target.

## `notifyEmail` (type: `string`):

Optional email passed to MyMemory. Adding a valid email raises the anonymous daily quota.

## Actor input object example

```json
{
  "maxItems": 10,
  "texts": [
    "Hello, world!",
    "Good morning",
    "How are you?",
    "Thank you very much",
    "See you soon"
  ],
  "sourceLanguage": "en",
  "targetLanguage": "es"
}
```

# Actor output Schema

## `overview` (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 = {
    "maxItems": 10,
    "texts": [
        "Hello, world!",
        "Good morning",
        "How are you?",
        "Thank you very much",
        "See you soon"
    ],
    "sourceLanguage": "en",
    "targetLanguage": "es"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/mymemory-translation-scraper").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 = {
    "maxItems": 10,
    "texts": [
        "Hello, world!",
        "Good morning",
        "How are you?",
        "Thank you very much",
        "See you soon",
    ],
    "sourceLanguage": "en",
    "targetLanguage": "es",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/mymemory-translation-scraper").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 '{
  "maxItems": 10,
  "texts": [
    "Hello, world!",
    "Good morning",
    "How are you?",
    "Thank you very much",
    "See you soon"
  ],
  "sourceLanguage": "en",
  "targetLanguage": "es"
}' |
apify call parseforge/mymemory-translation-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/mymemory-translation-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "MyMemory Translation Scraper",
        "description": "Query MyMemory, the world's largest translation memory, with billions of human and machine translations. Translate text across 100+ languages with quality match scores, source attribution, and reference segments. Export to JSON, CSV, or Excel for localization and language research.",
        "version": "1.0",
        "x-build-id": "7WO2BXfepQWpRB9RX"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~mymemory-translation-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-mymemory-translation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/parseforge~mymemory-translation-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-mymemory-translation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/parseforge~mymemory-translation-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-mymemory-translation-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    },
                    "texts": {
                        "title": "Texts to translate",
                        "type": "array",
                        "description": "Array of strings to translate. Each string becomes one record. Defaults to a 10-phrase travel sampler when empty.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "sourceLanguage": {
                        "title": "Source language",
                        "enum": [
                            "en",
                            "en-GB",
                            "en-US",
                            "es",
                            "es-ES",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "pt-BR",
                            "nl",
                            "ru",
                            "pl",
                            "tr",
                            "ar",
                            "he",
                            "ja",
                            "zh-CN",
                            "zh-TW",
                            "ko",
                            "hi",
                            "bn",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "fil",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "cs",
                            "sk",
                            "hu",
                            "ro",
                            "bg",
                            "uk",
                            "el",
                            "fa",
                            "ur",
                            "ta",
                            "te",
                            "ml",
                            "mr",
                            "gu",
                            "sw",
                            "af",
                            "sq",
                            "am",
                            "az",
                            "be",
                            "bs",
                            "ca",
                            "cy",
                            "et",
                            "eu",
                            "gl",
                            "hr",
                            "is",
                            "ka",
                            "kk",
                            "km",
                            "lt",
                            "lv",
                            "mk",
                            "mn",
                            "ne",
                            "sl",
                            "sr",
                            "uz",
                            "yi"
                        ],
                        "type": "string",
                        "description": "ISO language code (e.g. en, en-GB, es, fr)."
                    },
                    "targetLanguage": {
                        "title": "Target language",
                        "enum": [
                            "en",
                            "en-GB",
                            "en-US",
                            "es",
                            "es-ES",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "pt-BR",
                            "nl",
                            "ru",
                            "pl",
                            "tr",
                            "ar",
                            "he",
                            "ja",
                            "zh-CN",
                            "zh-TW",
                            "ko",
                            "hi",
                            "bn",
                            "th",
                            "vi",
                            "id",
                            "ms",
                            "fil",
                            "sv",
                            "no",
                            "da",
                            "fi",
                            "cs",
                            "sk",
                            "hu",
                            "ro",
                            "bg",
                            "uk",
                            "el",
                            "fa",
                            "ur",
                            "ta",
                            "te",
                            "ml",
                            "mr",
                            "gu",
                            "sw",
                            "af",
                            "sq",
                            "am",
                            "az",
                            "be",
                            "bs",
                            "ca",
                            "cy",
                            "et",
                            "eu",
                            "gl",
                            "hr",
                            "is",
                            "ka",
                            "kk",
                            "km",
                            "lt",
                            "lv",
                            "mk",
                            "mn",
                            "ne",
                            "sl",
                            "sr",
                            "uz",
                            "yi"
                        ],
                        "type": "string",
                        "description": "ISO language code for the target."
                    },
                    "notifyEmail": {
                        "title": "Email (optional, raises daily quota)",
                        "type": "string",
                        "description": "Optional email passed to MyMemory. Adding a valid email raises the anonymous daily quota."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
