# Wiktionary Definitions Scraper (`parseforge/wiktionary-definitions-scraper`) Actor

Scrapes Wiktionary definitions for a list of words from 10 language editions. Returns each word and language pair as a flat row with part of speech, pronunciation, etymology, and examples.

- **URL**: https://apify.com/parseforge/wiktionary-definitions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Developer tools, Other
- **Stats:** 1 total users, 0 monthly users, 89.7% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.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/actors/running/actors-in-store.md#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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### Wiktionary Definitions Scraper

**Scrape Wiktionary definitions for any word list, in 10 languages, up to a million per run.** Each record includes the part of speech, pronunciation, etymology, and usage examples. No API key or login. Export to CSV, JSON, Excel, or XML.

Wiktionary has no official API, and scraping its pages by hand means parsing messy HTML for every word. This actor queries the public Wiktionary editions directly, looks up each word you provide, and returns one clean record per word and language pair found. It works across English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, and Korean editions.

| Who uses it | What they scrape Wiktionary for |
|---|---|
| Linguists and lexicographers | Building a corpus of word senses and etymologies across languages |
| Language learners and teachers | Generating vocabulary lists with definitions and examples |
| NLP engineers | Creating training data for word sense disambiguation or translation models |
| Content creators | Enriching articles or apps with dictionary entries |

### What it does

This actor collects Wiktionary definitions for a list of words you provide, from the language edition you choose, and returns each match as a flat row.

- 🌍 **10 language editions:** query en, es, fr, de, it, pt, ru, zh, ja, or ko Wiktionary.
- 📚 **Batch word lookup:** paste a list of words and get one record per word and language pair found.
- 🔢 **Scalable collection:** set a maximum from 1 to 1,000,000 definitions per run.
- 📄 **Flat output:** every definition arrives as a single row, ready for CSV, JSON, Excel, or XML export.

Results export to CSV, JSON, Excel, or XML, or straight from the API.

### What you can do with Wiktionary data

**📖 Build a multilingual dictionary dataset.**

A lexicographer runs the actor on a list of 500 technical terms across the English, French, and German editions to compare definitions and usage.

**🧠 Create training data for NLP models.**

An NLP engineer collects definitions and parts of speech for 10,000 common words to train a word sense disambiguation model.

**🎓 Generate vocabulary study lists.**

A language teacher scrapes definitions and example sentences for a weekly vocabulary list in Spanish and Italian.

**✍️ Enrich content with dictionary entries.**

A content creator pulls definitions and etymologies for a series of articles on word origins.

### Why choose this scraper

| | What you get |
|---|---|
| **No API key** | Reads the public Wiktionary pages directly, no registration or OAuth. |
| **Cross-language coverage** | One actor for 10 major Wiktionary editions, including Chinese, Japanese, and Korean. |
| **Clean structured data** | Each record is a flat row with part of speech, pronunciation, etymology, and examples. |
| **Batch processing** | Look up hundreds or thousands of words in a single run. |

### How it compares

No other Store actor targets Wiktionary the same way, so the honest comparison is with the alternatives teams actually weigh.

| | Wiktionary Definitions Scraper | Build it in-house | By hand |
|---|---|---|---|
| Setup | Run it now, zero config | Days of engineering | None, but hours per pull |
| When Wiktionary changes | Maintained for you | You fix it | You re-learn the page |
| Proxies, retries, anti-bot | Built in | Your problem | Browser only |
| Output | Fixed JSON schema, CSV/Excel export | Whatever you build | Copy-paste |
| Cost | Pay per result | Engineering time | Analyst hours |

### Configure the run

Drive the actor with a list of words and a source language edition. The maximum definitions limit caps how many records are returned per run. The Input tab lists every parameter.

A first run with the defaults:

```json
{
 "maxItems": 10,
 "words": [
 "hello",
 "world",
 "etymology",
 "lexicon",
 "polyglot"
 ],
 "language": "en"
}
```

A larger pull:

```json
{
 "maxItems": 200,
 "words": [
 "hello",
 "world",
 "etymology",
 "lexicon",
 "polyglot"
 ],
 "language": "en"
}
```

### Pricing

Pay-per-result: **$0.012 per result** collected. You pay only for the results written to your dataset.

| Results collected | Approximate cost |
|---|---|
| 100 results | $1.20 |
| 1,000 results | $12.00 |
| 10,000 results | $120.00 |

New Apify accounts start with $5 in free credit.

### Free users

Free-plan runs return up to 10 results as a preview. [Upgrade your Apify plan](https://console.apify.com/sign-up?fpr=vmoqkp) to collect up to 1,000,000 results per run.

### Run it

1. [Create a free Apify account with $5 in credit](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the [Wiktionary Definitions Scraper](https://apify.com/parseforge/wiktionary-definitions-scraper?fpr=vmoqkp).
3. Set your inputs and any filters, then click **Start**.
4. Export the results as CSV, Excel, JSON, or XML from the **Dataset** tab.

Run it programmatically through the [Apify API](https://docs.apify.com/api/v2) (`run-sync-get-dataset-items`) or the [ApifyClient](https://docs.apify.com/api/client/js) for JavaScript and Python.

### Use with AI agents (MCP)

Give an AI agent live access to Wiktionary through the Model Context Protocol. Add the Actor to Claude, Cursor, or any MCP client:

```bash
claude mcp add --transport http apify "https://mcp.apify.com/?tools=parseforge/wiktionary-definitions-scraper"
```

Then prompt it in plain language to run the scraper and read back the results.

### Troubleshooting

**Why am I getting no results?**

Check that the words are spelled correctly and exist in the selected language edition. Also ensure the 'Maximum definitions' is set to at least 1.

**Why are some words missing from the output?**

The actor only returns records for words that have a Wiktionary page in the chosen edition. Words without a page are skipped.

**The run is taking too long.**

Reduce the number of words or lower the 'Maximum definitions' limit. The actor processes each word sequentially.

**I need definitions from multiple language editions.**

Run the actor once per edition with the same word list, then merge the datasets. There is no multi-edition mode in a single run.

**The output contains HTML tags or formatting artifacts.**

The actor extracts plain text from Wiktionary pages. If you see artifacts, report them, but most formatting is stripped automatically.

### FAQ

| Question | Answer |
|---|---|
| Which Wiktionary editions does this actor support? | It supports English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, and Korean editions. The English edition has the broadest cross-language coverage. |
| How do I provide the list of words? | Use the 'Words' input field and enter one word per line. You can paste a list of any size, up to the maximum definitions limit. |
| What does one record look like? | Each record is a flat row containing the word, language, part of speech, pronunciation, etymology, definition, and usage examples, as available on the Wiktionary page. |
| Can I limit how many definitions are returned? | Yes, set the 'Maximum definitions' input to any number from 1 to 1,000,000. The actor stops after collecting that many records. |
| Does this actor require an API key or login? | No. It reads the public Wiktionary pages directly, so no registration or authentication is needed. |
| What output formats are supported? | You can export the results to CSV, JSON, Excel, or XML from the Apify dataset. |
| Can I scrape definitions for words in multiple languages at once? | Yes, but each run uses one source language edition. To get definitions from multiple editions, run the actor once per edition with the same word list. |
| What if a word is not found on Wiktionary? | The actor skips words that have no page in the selected edition. Only found word and language pairs are returned. |
| Is this actor suitable for large-scale dictionary building? | Yes, you can set the maximum definitions up to 1,000,000 per run, and the actor processes words in batch. |
| Does the actor handle non-Latin scripts like Chinese or Japanese? | Yes, it queries the Chinese, Japanese, and Korean editions directly and returns the text as-is. |

### Related actors

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by Wikimedia Foundation, Inc. It collects only publicly available data. You are responsible for using the collected data in compliance with the source's terms of service and applicable data-protection laws, including GDPR, CCPA, and PIPL. Do not use it to collect personal data unlawfully.

# Actor input Schema

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

Maximum number of definitions to collect per run.

## `words` (type: `array`):

List of words to look up. One Wiktionary record returned per word/language pair found.

## `language` (type: `string`):

Wiktionary edition to query. en.wiktionary.org has the broadest cross-language coverage.

## Actor input object example

```json
{
  "maxItems": 10,
  "words": [
    "hello",
    "world",
    "etymology",
    "lexicon",
    "polyglot"
  ],
  "language": "en"
}
```

# 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,
    "words": [
        "hello",
        "world",
        "etymology",
        "lexicon",
        "polyglot"
    ],
    "language": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/wiktionary-definitions-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,
    "words": [
        "hello",
        "world",
        "etymology",
        "lexicon",
        "polyglot",
    ],
    "language": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/wiktionary-definitions-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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,
  "words": [
    "hello",
    "world",
    "etymology",
    "lexicon",
    "polyglot"
  ],
  "language": "en"
}' |
apify call parseforge/wiktionary-definitions-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/wiktionary-definitions-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7RDyhVkgeKudjCvRz/builds/b0fqMLiJDj2BcgwVI/openapi.json