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

Fetch dictionary definitions from Wiktionary in 9 source languages. Returns part of speech, definitions, examples, and cross-language meanings per word. Plain-text and HTML output for one-shot or bulk word lists.

- **URL**: https://apify.com/parseforge/wiktionary-definitions-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Education, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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/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)

## 📖 Wiktionary Definitions Scraper

> 🚀 **Export multilingual dictionary entries in seconds.** Pull definitions, parts of speech, and example sentences from **6 million+ Wiktionary entries** across nine language editions. No API key, no registration, no XML wrangling.

> 🕒 **Last updated:** 2026-05-22 · **📊 9 fields** per record · **📖 6M+ entries** · **🌐 9 language editions** · **🔤 50+ parts of speech**

The **Wiktionary Definitions Scraper** queries the community-maintained multilingual dictionary and returns **9 fields per record**, including the headword, part of speech, every definition, illustrative examples, source language edition, and a link back to the canonical page. The underlying dataset is the largest open dictionary in the world, maintained by a global community of lexicographers, linguists, and language enthusiasts.

The catalog covers **English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, and Korean editions**, with cross-language meanings included whenever the source edition documents them. This Actor turns the dictionary into downloadable CSV, Excel, JSON, or XML in under five minutes. Bulk lookups, single-word checks, and cross-edition merges all run from the same input form.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| NLP engineers, lexicographers, linguists, language-learning apps, search teams, content moderators, dictionary builders | Lemma dictionaries, training data for tokenizers and word embeddings, definition lookups in chat UIs, vocabulary expansion for language apps |

---

### 📋 What the Wiktionary Definitions Scraper does

Three lookup workflows in a single run:

- 🔤 **Single-word lookup.** Resolve one headword across every documented language in the chosen edition.
- 📚 **Bulk word list.** Pass dozens or thousands of words and stream a record per entry.
- 🌐 **Cross-language coverage.** From the English edition, pull meanings for words in any documented language with English glosses.

Each record includes the headword, source language edition, entry language code, entry language name, part of speech, definition count, the full definitions array, illustrative examples, and the canonical Wiktionary page URL.

> 💡 **Why it matters:** dictionary data underpins autocomplete, spell-check, machine translation, and language-learning features. Building your own scraper means handling wiki markup, namespace conventions, and per-edition schema drift. This Actor skips all of that and refreshes on every run.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>words</code></td><td>array</td><td><code>["hello","world","etymology","lexicon","polyglot"]</code></td><td>Headwords to look up. One record per word and language pair found.</td></tr>
<tr><td><code>language</code></td><td>string</td><td><code>"en"</code></td><td>Wiktionary edition. English has the broadest cross-language coverage.</td></tr>
</tbody>
</table>

**Example: 25 English words with full definitions.**

```json
{
    "maxItems": 25,
    "words": ["serendipity", "ephemeral", "ubiquitous", "obfuscate", "perspicacious"],
    "language": "en"
}
````

**Example: French headwords from the French edition.**

```json
{
    "maxItems": 50,
    "words": ["bonjour", "maison", "amitié", "liberté"],
    "language": "fr"
}
```

> ⚠️ **Good to Know:** the English Wiktionary edition documents the broadest cross-language coverage. If you query a word that only exists in one edition, switch the `language` field to that edition for the richest result.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔤 `word` | string | `"hello"` |
| 🌐 `sourceLanguage` | string | `"en"` |
| 🆔 `entryLanguageCode` | string | `"en"` |
| 🗣️ `entryLanguage` | string | `"English"` |
| 📚 `partOfSpeech` | string | `"Interjection"` |
| 🔢 `definitionCount` | number | `4` |
| 📖 `definitions` | string\[] | `["A greeting (salutation) said when meeting someone or acknowledging someone's arrival..."]` |
| 💬 `examples` | string\[] | `["Hello, everyone."]` |
| 🔗 `pageUrl` | string | `"https://en.wiktionary.org/wiki/hello"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T10:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>👋 Cross-language entry: "hello" in English</strong></summary>

```json
{
    "word": "hello",
    "sourceLanguage": "en",
    "entryLanguageCode": "en",
    "entryLanguage": "English",
    "partOfSpeech": "Interjection",
    "definitionCount": 4,
    "definitions": [
        "A greeting (salutation) said when meeting someone or acknowledging someone's arrival or presence.",
        "A greeting used when answering the telephone.",
        "A call for response if it is not clear if anyone is present or listening, or if a telephone conversation may have been disconnected.",
        "Used sarcastically to imply that the person addressed is being foolish."
    ],
    "examples": [
        "Hello, everyone.",
        "Hello? Is anyone there?"
    ],
    "pageUrl": "https://en.wiktionary.org/wiki/hello",
    "scrapedAt": "2026-05-22T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇫🇷 French headword: "bonjour" from the French edition</strong></summary>

```json
{
    "word": "bonjour",
    "sourceLanguage": "fr",
    "entryLanguageCode": "fr",
    "entryLanguage": "French",
    "partOfSpeech": "Interjection",
    "definitionCount": 2,
    "definitions": [
        "Salutation utilisée le jour, lors d'une rencontre ou d'un accueil.",
        "Formule de politesse écrite en début de lettre ou de message."
    ],
    "examples": [
        "Bonjour, comment allez-vous ?"
    ],
    "pageUrl": "https://fr.wiktionary.org/wiki/bonjour",
    "scrapedAt": "2026-05-22T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 📖 | **Massive coverage.** Six million+ entries spanning nine language editions and dozens of part-of-speech categories. |
| 🌐 | **Cross-language ready.** The English edition documents meanings for thousands of languages, all returned in one structured record. |
| 🧩 | **Plain-text definitions.** Wiki markup is stripped, so output is ready for tokenizers and embeddings. |
| ⚡ | **Fast.** 10 entries in under 5 seconds, 1,000 entries in under three minutes. |
| 💬 | **Examples included.** Every record exposes the illustrative sentences alongside the definitions. |
| 🔁 | **Always fresh.** Each run hits the live Wiktionary edition, so the dataset reflects current edits. |
| 🚫 | **No authentication.** Works against the public Wiktionary content. No login or API key needed. |

> 📊 Dictionary data is the foundation of every spell-checker, autocomplete, translation feature, and language-learning app in modern software.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ Wiktionary Definitions Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **6M+** entries, 9 editions | **Live per run** | ⚡ 2 min |
| Manual Wiktionary downloads | Free | Full dump, stale by weeks | Monthly | 🐢 Hours |
| In-house wiki-markup parser | Free + engineering | Full | Build it yourself | 🛠️ Weeks |
| Commercial dictionary APIs | $99+/month | Curated subset | Daily | ⏳ Hours |

Pick this Actor when you want broad multilingual coverage, fresh data, and zero markup parsing.

***

### 🚀 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 Wiktionary Definitions Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a language edition and paste a list of words. Set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in 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">

#### 🤖 NLP & Search Teams

- Lemma dictionaries for tokenizers
- Training data for word embeddings
- Spell-check and autocomplete backbones
- Stopword and morphology references

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

#### 📱 Language-Learning Apps

- In-app definition popovers
- Vocabulary builder content packs
- Example sentences for flashcards
- Multilingual lookup features

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

#### 📚 Lexicographers & Linguists

- Comparative entries across editions
- Coverage gap analyses by language
- Reference corpus for academic papers
- Source dataset for derived dictionaries

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

#### 💬 Content & Chat Platforms

- Definition lookups inside chat UIs
- Glossary widgets in publishing tools
- Content moderation glossaries
- Knowledge-base entity enrichment

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

***

### 🔌 Automating Wiktionary Definitions 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 or weekly refreshes keep dictionary content current automatically.

***

### 🌟 Beyond business use cases

Dictionary data powers more than commercial workflows. The same structured records support research, education, civic projects, and personal initiatives.

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

#### 🎓 Research and academia

- Lexicographic studies and theses
- Corpus linguistics with cited datasets
- Cross-edition comparative research
- Open-data exercises on dictionary coverage

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

#### 🎨 Personal and creative

- Indie language-learning side projects
- Vocabulary games and puzzle apps
- Writer reference tools and content packs
- Hobbyist multilingual dictionaries

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

#### 🤝 Non-profit and civic

- Endangered-language documentation aids
- Community translation projects
- Educational glossaries for schools and libraries
- Civic literacy programs and public reference sites

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

#### 🧪 Experimentation

- Train word-sense disambiguation models
- Prototype agents that paraphrase or define
- Build glossary chrome extensions
- Test definition lookup UX with real data

</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%20Wiktionary%20Definitions%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%20Wiktionary%20Definitions%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%20Wiktionary%20Definitions%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%20Wiktionary%20Definitions%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?

Paste a list of words, pick a Wiktionary edition, click Start, and the Actor resolves each word against the chosen edition and emits a clean structured record per entry. No browser automation, no captchas, no setup.

#### 📏 How accurate is the data?

Wiktionary entries are community-maintained, peer-reviewed, and cited across major NLP datasets and language-learning products. For mission-critical lexicography, treat it as the same way you would treat any community reference.

#### 🔁 How often is the dataset refreshed?

Wiktionary editors publish updates continuously. Every run of this Actor pulls live entries, so your dataset reflects the latest community edits as of run time.

#### 🌐 Which languages are supported?

Nine source editions: English, Spanish, French, German, Italian, Portuguese, Russian, Chinese, Japanese, and Korean. The English edition documents meanings for thousands of additional languages via cross-language entries.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly, monthly) and keep a downstream dictionary in sync.

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

Wiktionary content is published under Creative Commons Attribution-ShareAlike. Attribution and share-alike requirements apply to redistributed entries. Review the license before integrating into a commercial product.

#### 💼 Can I use this data commercially?

Yes, under the Creative Commons Attribution-ShareAlike terms. You are responsible for the attribution and share-alike requirements in your downstream product.

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

No. The free Apify plan is enough for testing and small word lists (10 records per run). A paid plan lifts the limit and gives you access to scheduling, higher concurrency, and larger word lists.

#### 🔁 What happens if a word does not exist in the chosen edition?

A diagnostic record is pushed with an `error` field explaining the miss. The run continues processing the rest of the word list.

#### 🔤 Does it include etymology and pronunciation?

This Actor returns definitions, part of speech, and examples. For etymology and IPA pronunciation, reach out via the contact form below to request a companion etymology scraper.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Wiktionary Definitions 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 entries 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 dictionary entries into your model retraining loop, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**🧬 Wikidata Lexemes Scraper**](https://apify.com/parseforge/wikidata-lexemes-scraper) - Structured multilingual lexeme records
- [**📚 Wikipedia Scraper**](https://apify.com/parseforge/wikipedia-scraper) - Encyclopedic articles and references
- [**📖 Open Library Scraper**](https://apify.com/parseforge/open-library-scraper) - Bibliographic metadata for millions of books
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap
- [**📰 ArXiv Scraper**](https://apify.com/parseforge/arxiv-scraper) - Scientific preprint metadata

> 💡 **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 Wiktionary, the Wikimedia Foundation, or any of its contributors. All trademarks mentioned are the property of their respective owners. Only publicly available open dictionary data is collected.

# Actor input Schema

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

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

## `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("💾 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,
  "words": [
    "hello",
    "world",
    "etymology",
    "lexicon",
    "polyglot"
  ],
  "language": "en"
}' |
apify call parseforge/wiktionary-definitions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wiktionary Definitions Scraper",
        "description": "Fetch dictionary definitions from Wiktionary in 9 source languages. Returns part of speech, definitions, examples, and cross-language meanings per word. Plain-text and HTML output for one-shot or bulk word lists.",
        "version": "1.0",
        "x-build-id": "G74PcAOPiRBpByhxH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~wiktionary-definitions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-wiktionary-definitions-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~wiktionary-definitions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-wiktionary-definitions-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~wiktionary-definitions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-wiktionary-definitions-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"
                    },
                    "words": {
                        "title": "Words",
                        "type": "array",
                        "description": "List of words to look up. One Wiktionary record returned per word/language pair found.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "language": {
                        "title": "Source Language",
                        "enum": [
                            "en",
                            "es",
                            "fr",
                            "de",
                            "it",
                            "pt",
                            "ru",
                            "zh",
                            "ja",
                            "ko"
                        ],
                        "type": "string",
                        "description": "Wiktionary edition to query. en.wiktionary.org has the broadest cross-language coverage."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
