# DictionaryAPI Batch Word Definitions (`automation-lab/free-dictionary-batch-definitions`) Actor

Enrich English word lists with DictionaryAPI definitions, examples, parts of speech, phonetics, and pronunciation audio links. Export entry and audio licenses with source attribution; distinguish missing words from source failures.

- **URL**: https://apify.com/automation-lab/free-dictionary-batch-definitions.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Education, Developer tools
- **Stats:** 2 total users, 1 monthly users, 63.2% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.80 / 1,000 item extracteds

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## DictionaryAPI Batch Word Definitions

Enrich supplied English vocabulary lists with **DictionaryAPI word definitions**, pronunciation references, examples, and source attribution. This Actor groups all returned lexical entries into one row per normalized word, keeping entry licenses and individual audio licenses alongside the data.

Education teams and developers can use it for lesson preparation, vocabulary datasets, flashcard pipelines, or educational content enrichment. It calls the public [Free Dictionary API](https://dictionaryapi.dev/); it does not invent definitions, translate text, copy audio files, or substitute a different dictionary when the source fails.

### Who is it for?

Education teams preparing source-attributed vocabulary, developers building flashcards, and researchers organizing lexical datasets can submit the same curated English word list repeatedly. It is not a corpus-wide crawler or translation service.

### Why use this Actor?

- Submit a reusable word list instead of maintaining an API integration.
- Preserve all meanings and pronunciation references returned for each word.
- Keep licenses and source URLs with the content for downstream attribution.
- Distinguish source-confirmed missing words from outages and malformed responses.
- Export to Apify datasets and automate recurring enrichment with Tasks and Schedules.

### Getting started

1. Enter English words in **English words**.
2. Choose the maximum number of unique words to look up.
3. Run the Actor and confirm its terminal status.
4. Open the default dataset and export JSON, JSONL, CSV, or Excel.

```json
{
  "words": ["hello", "world", "test"],
  "maxWords": 100
}
```

This is a batch lookup, not dictionary-wide discovery. The source may be unavailable for particular words even when other words work.

### Input parameters

| Field | Required | Default | Behavior |
|---|---|---|---|
| `words` | Yes | — | 1–1000 English word strings. Each has at most 100 letters, with optional internal hyphens/apostrophes. No phrases, URLs or language switching. |
| `maxWords` | No | 100 | Global unique-word lookup limit, 1–1000, applied after deduplication. Includes missing words; zero/unlimited is not supported. |

Leading/trailing whitespace is trimmed, case is lowered, curly apostrophes are normalized, and duplicates are removed in first-seen order. `Hello` and `hello` produce one lookup. Unknown fields and malformed input fail validation rather than silently changing scope.

### DictionaryAPI word definitions output

The default dataset contains one row per queried word. Found rows include all returned lexical entries, not one row per definition sense.

| Field | Meaning |
|---|---|
| `query` | Normalized supplied word |
| `language` | `en` |
| `status` | `found` or recognizable source JSON `not_found` |
| `source` | `dictionaryapi.dev` |
| `sourceUrl` | Exact public lookup URL |
| `entries` | All source lexical entries, preserving nested meanings and pronunciation metadata |
| `entryCount` | Number of lexical entries, not senses |
| `scrapedAt` | UTC retrieval timestamp |

Entries can contain `word`, `phonetic`, `origin`, `phonetics`, `meanings`, `license`, and `sourceUrls`. Meaning groups include parts of speech, definitions, optional examples, synonyms, and antonyms. Pronunciation objects can contain phonetic text, audio URL, attribution URL, and audio-specific license.

Missing fields are left absent as supplied; empty audio URLs are preserved. Licenses are not inferred. Use JSON/JSONL to retain nested arrays; flatten them downstream for spreadsheets.

### Example output

A shortened example from the live `hello` response (the actual row preserves all source meanings):

```json
{
  "query": "hello",
  "language": "en",
  "status": "found",
  "source": "dictionaryapi.dev",
  "sourceUrl": "https://api.dictionaryapi.dev/api/v2/entries/en/hello",
  "entryCount": 1,
  "scrapedAt": "2026-10-13T06:00:00.000Z",
  "entries": [{
    "word": "hello",
    "meanings": [{
      "partOfSpeech": "interjection",
      "definitions": [{
        "definition": "A greeting (salutation) said when meeting someone or acknowledging someone’s arrival or presence.",
        "example": "Hello, everyone.",
        "synonyms": [],
        "antonyms": []
      }]
    }],
    "license": {"name": "CC BY-SA 3.0", "url": "https://creativecommons.org/licenses/by-sa/3.0"},
    "sourceUrls": ["https://en.wiktionary.org/wiki/hello"]
  }]
}
```

### How much does it cost to enrich English word lists?

Pay-per-event billing uses one `start` event per validated run and one primary `item` event per found word row. Multiple entries or senses inside that row have no separate event charge. Source-confirmed missing-word rows are free of per-word billing, as are failed requests and retry attempts. Saved found rows before a later source failure remain chargeable.

The start event costs **$0.005 per run**. BRONZE pricing is **$0.008 per found word**, or **$8 per 1,000 found words**. For example, 1, 10, and 100 found words cost approximately $0.013, $0.085, and $0.805 respectively including the start event. Pricing is tier-dependent and examples are estimates, not guaranteed invoices.

| Spend tier | Per found word |
|---|---:|
| FREE | $0.0092 |
| BRONZE | $0.008 |
| SILVER | $0.00624 |
| GOLD | $0.0048 |
| PLATINUM | $0.0048 |
| DIAMOND | $0.0048 |

Spend tiers depend on qualifying aggregate monthly Apify Store spend, not this Actor's word volume. Apify account/platform fees depend on your plan. Set a maximum charge on the run to bound spending; a billing cap may stop collection before the requested word limit.

### Reliability and limitations

Requests are sequential, with a 15-second request timeout and at most four attempts per word. Each word starts with direct HTTPS, followed when needed by two fresh Apify datacenter sessions and a final fresh UK residential session using a browser-compatible TLS/HTTP fingerprint, with 0.5/1/2-second backoff. Network/body-read errors, HTTP 403/429/5xx, malformed JSON and observed origin HTML 404s can trigger this bounded recovery. Persistent failures, other non-JSON responses and missing lexical structure fail the run honestly. There is no user-supplied proxy option or alternate-source substitution.

Only a 404 JSON response titled `No Definitions Found` becomes `not_found`. An HTML 404 or HTTP 522 is a source failure, not evidence the word does not exist. This distinction matters when enriching a curated list.

Failed runs can contain partial rows. Do not describe those as a complete successful batch. No browser, persistent session cache, spelling suggestions, translations, historical archive, change detection, or audio download is enabled. Returned definitions and license metadata depend entirely on the source.

### Integrations

Use Make, Zapier, or n8n to run a saved word list and consume the default dataset. For flashcards, unpack `entries[].meanings[].definitions[]` and carry the corresponding entry attribution alongside each sense. Keep audio URLs as references and check the individual audio license before reuse.

For recurring enrichment, save an Apify Task and attach a Schedule. Compare datasets in your own pipeline using `query` as a join key; the Actor does not automatically detect changes or send alerts.

### API usage

Keep your Apify token in a secret environment variable, never in public code. Start a run:

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~free-dictionary-batch-definitions/runs' \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"words":["hello","world","test"],"maxWords":100}'
```

JavaScript with `apify-client`:

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/free-dictionary-batch-definitions')
  .call({ words: ['hello', 'world', 'test'], maxWords: 100 });
if (run.status !== 'SUCCEEDED') throw new Error(`Partial or failed run: ${run.id}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems({ limit: 100 });
```

Python with `apify-client`:

```python
import os
from apify_client import ApifyClient
client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/free-dictionary-batch-definitions').call(
    run_input={'words': ['hello', 'world', 'test'], 'maxWords': 100})
if run['status'] != 'SUCCEEDED':
    raise RuntimeError('Check run status; stored rows may be partial')
items = client.dataset(run['defaultDatasetId']).list_items(limit=100).items
```

### MCP setup

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/free-dictionary-batch-definitions"
```

For Claude Desktop, Cursor, and VS Code, use a compatible remote HTTP MCP configuration:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/free-dictionary-batch-definitions",
      "headers": {"Authorization": "Bearer <APIFY_TOKEN>"}
    }
  }
}
```

Store the token in the client's secret configuration. Discover actual tool names and argument schemas with scoped `tools/list`. Actor selection also exposes run/data retrieval and abort tools; discovery is not permission to execute them.

Example prompt: “Look up hello, world, and test, then summarize the source-provided definitions with attribution. Do not invent missing examples.”

Start once and retain the returned run ID and storage IDs; these are metadata, not lexical rows. `call-actor` waits at most 45 seconds (default 30). If pending, follow the same run with `get-actor-run`, using 2/4/8-second backoff capped at 10 seconds and a 120-second overall deadline. On timeout recover the known run; do not restart to poll. At the deadline report pending and the run ID.

Once successful, read `get-dataset-items` in pages of 20 source rows, at most 100 rows or 64 KiB of serialized UTF-8 content admitted to model context, whichever comes first. Enforce the byte budget host-side before injecting rows; disclose omitted oversized content and continuation offset. If your client cannot intercept large responses, do not claim a hard byte guarantee. Full exports belong in storage/downstream processing. Terminal failures mean any rows are partial.

### Legality and source attribution

This is an independent integration, not an official DictionaryAPI, Wiktionary, or Apify product. Source names describe compatibility, not endorsement.

Follow the source's terms and returned entry/audio licenses. Public availability does not mean unrestricted reuse. Preserve attribution and applicable share-alike requirements when creating derivatives. Missing license metadata is not a permission grant. Do not send sensitive personal data, credentials, or confidential text as words.

### Privacy and retention

The Actor sends normalized words to DictionaryAPI and stores them with public lexical entries in the run's default Apify dataset. No external AI model is used for lookup or generated meanings. No persistent cache or media copies are created. Apify storage/log retention follows your account settings; delete datasets, key-value stores, and logs using Apify controls when no longer needed.

Failed operations send sanitized diagnostic input, exceptions and actor/build/run IDs to our private GlitchTip service for repair; secret fields and URL queries are removed and reports are retained for 30 days. Words are not a safe place for secrets. Apify hosts the runtime, storage and bounded datacenter/residential proxy fallback; DictionaryAPI receives lookup words; private GlitchTip receives failure diagnostics.

### FAQ and troubleshooting

**Does a failed run mean the word is missing?** No. Check the error and terminal status. Only recognizable source JSON not-found responses establish `not_found`.

**Why did one word work and another time out?** Upstream availability can differ by endpoint/cache. The Actor retries transient failures but does not guarantee service availability or quietly substitute another source.

**Can I use phrases or another language?** No. This release accepts English words with optional internal apostrophes/hyphens, not free text or translations.

**Can I download pronunciation audio?** The dataset includes source URL references only. Audio is not fetched or copied.

**Are repeated words charged twice?** Normalized duplicate inputs are removed before lookup. Each found unique word is one item event.

### Related workflows

This Actor is a standalone conventional-English lexical enrichment tool. Slang/community dictionaries and direct Wiktionary parsing serve different source contracts; they are not fallback sources for this output.

### Support

Open an issue on the Actor page with a run ID, safe input sample, and expected field. Do not include tokens or private data. We aim to provide a substantive response to user-reported Store issues within 14 calendar days.

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/free-dictionary-batch-definitions/changelog.md

# Actor input Schema

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

Supply 1–1000 word strings, each up to 100 letters with optional internal apostrophes or hyphens. Whitespace is trimmed, case is lowered, curly apostrophes normalized, and duplicates removed in first-seen order. No phrases or URLs. One lookup per unique word; no search expansion.

## `maxWords` (type: `integer`):

Global lookup limit after normalization and deduplication, including words with no definitions. Default 100; range 1–1000. Keeps the first unique words in supplied order; zero does not mean unlimited. Each found word produces one row containing all returned entries.

## Actor input object example

```json
{
  "words": [
    "hello",
    "world",
    "test"
  ],
  "maxWords": 100
}
```

# Actor output Schema

## `dataset` (type: `string`):

Results in supplied word order. Rows from failed runs are partial.

# 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 = {
    "words": [
        "hello",
        "world",
        "test"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/free-dictionary-batch-definitions").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 = { "words": [
        "hello",
        "world",
        "test",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/free-dictionary-batch-definitions").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 '{
  "words": [
    "hello",
    "world",
    "test"
  ]
}' |
apify call automation-lab/free-dictionary-batch-definitions --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/free-dictionary-batch-definitions"
        }
    }
}
```

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/jQAEWCu8hikcMUeRm/builds/SBZbFEyN86VXn4hex/openapi.json