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

{
  "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):

{
  "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:

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:

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:

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:

$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:

{
  "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.