# Dictionary & Word of the Day Scraper (IPA, Audio) (`scrapers_lat/dictionary-word-of-the-day-scraper`) Actor

Get a daily Word of the Day or look up any English word: IPA phonetics, audio pronunciation URL, part of speech, definitions, examples, synonyms and antonyms, structured. Optional AI example sentences. No API key. Export to JSON, CSV or Excel.

- **URL**: https://apify.com/scrapers\_lat/dictionary-word-of-the-day-scraper.md
- **Developed by:** [Scrapers Lat](https://apify.com/scrapers_lat) (community)
- **Categories:** Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.56 / 1,000 word records

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

[![Dictionary & Word of the Day Scraper (IPA, Audio)](https://scrapers.lat/banners/dictionary-word-of-the-day-scraper.png)](https://console.apify.com/actors/7h8HlZ3qqnKJed8Xg/input)

## Dictionary & Word of the Day Scraper (IPA, Audio)

Here is one real result, today's Word of the Day, with every field the actor returns:

```json
{
  "word": "burnish",
  "language": "en",
  "isWordOfTheDay": true,
  "phonetic": "/ˈbɜː(ɹ)nɪʃ/",
  "audioUrl": null,
  "partsOfSpeech": ["noun", "verb"],
  "firstDefinition": "Polish; lustre.",
  "firstExample": "In pottery, a stone is sometimes used to burnish a pot before firing, giving it a smooth, shiny look.",
  "meanings": [
    {
      "partOfSpeech": "noun",
      "definitions": [
        { "definition": "Polish; lustre.", "example": null, "synonyms": [], "antonyms": [] }
      ],
      "synonyms": [],
      "antonyms": []
    },
    {
      "partOfSpeech": "verb",
      "definitions": [
        {
          "definition": "To make smooth or shiny by rubbing; to polish; to shine.",
          "example": "In pottery, a stone is sometimes used to burnish a pot before firing, giving it a smooth, shiny look.",
          "synonyms": [],
          "antonyms": []
        },
        {
          "definition": "(metaphoric) To make appear positive and highly respected.",
          "example": null,
          "synonyms": [],
          "antonyms": []
        }
      ],
      "synonyms": ["buff", "furbish", "polish", "shine", "wax"],
      "antonyms": []
    }
  ],
  "phonetics": [{ "text": "/ˈbɜː(ɹ)nɪʃ/", "audio": null }],
  "allSynonyms": ["buff", "furbish", "polish", "shine", "wax"],
  "allAntonyms": null,
  "definitionCount": 4,
  "sourceUrls": ["https://en.wiktionary.org/wiki/burnish"],
  "aiExampleSentences": null,
  "aiKidFriendlyDefinition": null,
  "aiMnemonic": null,
  "source": "dictionaryapi.dev",
  "observedAt": "2026-08-23T12:47:58.022Z",
  "error": null
}
```

The most complete dictionary and word-of-the-day actor available with no API key. It returns a stable daily Word of the Day, or defines any English word you pass, with IPA phonetics, an audio pronunciation URL, every part of speech, structured meanings (definition, example, synonyms, antonyms), flattened deduped synonym and antonym lists, and an optional AI layer that writes example sentences, a kid-friendly definition and a mnemonic.

**📥 [Input](https://apify.com/scrapers_lat/dictionary-word-of-the-day-scraper/input-schema) · 📤 [Output](https://apify.com/scrapers_lat/dictionary-word-of-the-day-scraper/output-schema) · 💰 [Pricing](https://apify.com/scrapers_lat/dictionary-word-of-the-day-scraper/pricing) · ▶️ [Examples](https://apify.com/scrapers_lat/dictionary-word-of-the-day-scraper/examples)**

![Apify](https://img.shields.io/badge/Platform-Apify-1CE1CE?logo=apify\&logoColor=white)
![Coverage](https://img.shields.io/badge/Coverage-English%20%2B%20multi--language-blue)
![Output](https://img.shields.io/badge/Output-JSON%20%7C%20CSV%20%7C%20Excel-orange)
![Billing](https://img.shields.io/badge/Billing-Pay%20per%20result-brightgreen)

### Table of contents

- [What it does](#what-it-does)
- [Why choose this](#why-choose-this)
- [How we compare](#how-we-compare)
- [Quickstart](#quickstart)
- [Input reference](#input-reference)
- [Output reference](#output-reference)
- [Example output record](#example-output-record)
- [Use cases](#use-cases)
- [Run via API and CLI](#run-via-api-and-cli)
- [Fetch results](#fetch-results)
- [Billing and limits](#billing)
- [FAQ and troubleshooting](#faq-and-troubleshooting)

### What it does

Two modes in one actor:

- **Word of the Day (`wotd`).** Returns one interesting, useful English word per calendar day. The pick is deterministic: it is chosen by day of year from a curated list of 366 words, so every run on the same date returns the same word. This is a curated rotation, not an official publisher feed, and the actor is transparent about that.
- **Lookup (`lookup`).** Define any word or list of words you pass. Each word returns one record with IPA phonetics, an audio pronunciation URL when one exists, every part of speech, and structured meanings including definitions, usage examples, synonyms and antonyms.

Every record also carries flattened, deduplicated `allSynonyms` and `allAntonyms` lists and a `definitionCount`, so you can build a word card or study list without walking the nested structure. Missing values are returned as `null`, never invented. A word with no entry is returned as an `error` record and is not charged.

### Why choose this

- **Word of the Day plus arbitrary lookup in one actor.** Power a daily widget and a search box from the same tool.
- **IPA phonetics and an audio pronunciation URL** on every word that has them, ready to render or play.
- **Synonyms and antonyms**, both structured per meaning and flattened into clean deduped lists.
- **Real usage examples** pulled from the dictionary entry, plus an optional AI layer for three fresh example sentences at different registers, a kid-friendly definition and a mnemonic.
- **Multi-language input** for lookups (English is fully covered; other languages are best-effort, see below).
- **No API key, no sign-up, no rate-limit juggling.** You run it and get clean JSON, CSV or Excel.

### How we compare

| Capability | This actor | WordsAPI | Merriam-Webster API |
|---|---|---|---|
| API key / signup required | No | Yes (RapidAPI key) | Yes (account + key) |
| Word of the Day built in | Yes (curated daily rotation) | No | Yes (on the website, not a free API endpoint) |
| Define any word | Yes | Yes | Yes |
| IPA phonetics | Yes | Yes | Yes |
| Audio pronunciation URL | Yes (when available) | No | Yes |
| Synonyms and antonyms | Yes | Yes | Yes |
| Usage examples | Yes (source + optional AI) | Limited | Yes |
| AI example sentences, kid definition, mnemonic | Yes (opt-in) | No | No |
| Multi-language lookups | Yes (best-effort, English full) | No (English only) | Add-on Spanish product |
| Output as JSON, CSV or Excel | Yes | JSON | JSON/XML |
| Commercial use on a free tier | Yes (pay per result) | Paid tiers above 2,500/day | Requires a paid license for commercial use |

Being honest about the gaps: **WordsAPI has richer lexical relations than this actor**, including word frequency scores, rhymes, syllable counts, and hypernym/hyponym trees over 300,000 words. If you specifically need rhymes or frequency data, use WordsAPI. **Merriam-Webster** carries editorial content (etymology, first-known-use, usage notes) that a crowd-sourced source does not. This actor wins on: no key, Word of the Day plus lookup together, audio URLs, the AI teaching layer, and unmetered pay-per-result commercial use.

### Quickstart

Open the actor, paste this into the input, and press Run. It returns today's Word of the Day.

```json
{
  "mode": "wotd"
}
```

Define your own words instead:

```json
{
  "mode": "lookup",
  "words": ["serendipity", "ephemeral", "ubiquitous"],
  "maxResults": 10
}
```

Add the AI teaching layer (paid plans):

```json
{
  "mode": "lookup",
  "words": ["serendipity"],
  "aiUsageExamples": true
}
```

### Input reference

| Field | Type | Required | Default | Description |
|---|---|---|---|---|
| `mode` | enum | no | `wotd` | `wotd` returns today's curated Word of the Day. `lookup` defines the words you pass. |
| `words` | string\[] | no | (empty) | Lookup mode. One or more words to define, for example `serendipity`, `ephemeral`. Each word returns one record. Ignored in Word of the Day mode. |
| `word` | string | no | (empty) | Convenience field for one word. It is added to the `words` list. Ignored in Word of the Day mode. |
| `language` | enum | no | `en` | Dictionary language for lookup mode: `en`, `es`, `fr`, `de`, `it`, `pt-BR`, `hi`, `ru`, `ja`, `ko`, `tr`, `ar`. English has full coverage; other languages are best-effort and return a no-definition record where the source has no entry. Word of the Day is always English. |
| `aiUsageExamples` | boolean | no | `false` | Paid add-on, off by default. Adds three AI example sentences at different registers, a kid-friendly definition and a mnemonic. Charged only when a usable result is returned. Disabled on free plans. |
| `maxResults` | integer | no | `10` | Maximum word records per run in lookup mode. Word of the Day always returns one. Free Apify plans are capped at 10 per run. |

### Output reference

One dataset item per word. Types: `string`, `boolean`, `integer`, `array`, or `null` when a value is absent.

| Field | Type | Description |
|---|---|---|
| `word` | string | The headword that was defined. |
| `language` | string | Dictionary language code, for example `en`. |
| `isWordOfTheDay` | boolean | `true` when this record is the curated Word of the Day. |
| `phonetic` | string | IPA phonetic transcription, for example `/ˌsɛ.ɹən.ˈdɪ.pɪ.ti/`. |
| `audioUrl` | string | URL of the first available audio pronunciation (mp3), or `null`. |
| `partsOfSpeech` | string\[] | Distinct parts of speech, for example `noun`, `verb`, `adjective`. |
| `firstDefinition` | string | The primary definition, for a quick single-column view. |
| `firstExample` | string | The first usage example found across the definitions, or `null`. |
| `meanings` | object\[] | Structured meanings. Each has `partOfSpeech`, `definitions[]` of `{definition, example, synonyms, antonyms}`, plus per-meaning `synonyms` and `antonyms`. |
| `phonetics` | object\[] | All phonetic entries, each with `text` (IPA) and `audio` (URL). |
| `allSynonyms` | string\[] | Flattened, deduplicated list of every synonym across all meanings. |
| `allAntonyms` | string\[] | Flattened, deduplicated list of every antonym across all meanings. |
| `definitionCount` | integer | Total number of definitions across all meanings. |
| `sourceUrls` | string\[] | Source reference URLs for the entry. |
| `aiExampleSentences` | string\[] | AI add-on: three example sentences at casual, formal and literary registers. `null` unless the add-on ran. |
| `aiKidFriendlyDefinition` | string | AI add-on: one simple, child-friendly definition. `null` unless the add-on ran. |
| `aiMnemonic` | string | AI add-on: a short memory aid to remember the word. `null` unless the add-on ran. |
| `source` | string | Data source. |
| `observedAt` | string | ISO 8601 timestamp when the record was collected. |
| `error` | string | `null` on success. A word with no definition returns a single record with this field populated, and is not charged. |

### Example output record

Real record from a live run with the AI add-on on (input `{"mode":"lookup","words":["serendipity"],"aiUsageExamples":true}`):

```json
{
  "word": "serendipity",
  "language": "en",
  "isWordOfTheDay": false,
  "phonetic": "/ˌsɛ.ɹən.ˈdɪ.pɪ.ti/",
  "audioUrl": "https://api.dictionaryapi.dev/media/pronunciations/en/serendipity-au.mp3",
  "partsOfSpeech": ["noun"],
  "firstDefinition": "A combination of events which have come together by chance to make a surprisingly good or wonderful outcome.",
  "firstExample": null,
  "meanings": [
    {
      "partOfSpeech": "noun",
      "definitions": [
        {
          "definition": "A combination of events which have come together by chance to make a surprisingly good or wonderful outcome.",
          "example": null,
          "synonyms": [],
          "antonyms": ["Murphy's law", "perfect storm"]
        },
        {
          "definition": "An unsought, unintended, and/or unexpected, but fortunate, discovery and/or learning experience that happens by accident.",
          "example": null,
          "synonyms": ["chance", "luck"],
          "antonyms": []
        }
      ],
      "synonyms": ["chance", "luck"],
      "antonyms": ["Murphy's law", "perfect storm"]
    }
  ],
  "phonetics": [
    { "text": "/ˌsɛ.ɹən.ˈdɪ.pɪ.ti/", "audio": "https://api.dictionaryapi.dev/media/pronunciations/en/serendipity-au.mp3" },
    { "text": "/ˌsɛ.ɹən.ˈdɪ.pɪ.ti/", "audio": "https://api.dictionaryapi.dev/media/pronunciations/en/serendipity-us.mp3" }
  ],
  "allSynonyms": ["chance", "luck"],
  "allAntonyms": ["Murphy's law", "perfect storm"],
  "definitionCount": 2,
  "sourceUrls": ["https://en.wiktionary.org/wiki/serendipity"],
  "aiKidFriendlyDefinition": "Serendipity is when something really good happens by accident.",
  "aiMnemonic": "Serendipity sounds like 'serene dip,' which is like a calm surprise!",
  "source": "dictionaryapi.dev",
  "observedAt": "2026-08-23T12:47:59.852Z",
  "error": null
}
```

### Use cases

- **Word-of-the-day widgets** for dictionary, news or learning apps and email newsletters, with a stable daily word plus audio.
- **Language-learning flashcards and study lists**: IPA, audio, definitions, synonyms and antonyms per card, plus AI example sentences and a mnemonic.
- **Word-game and puzzle content**: validate words, pull definitions and synonyms for hints, seed daily challenges.
- **Writing and editing assistants**: surface synonyms, antonyms and register-appropriate example sentences on demand.
- **Voice and pronunciation features**: use the audio URL and IPA to teach or check pronunciation.
- **Content and SEO teams**: batch-define a keyword list to enrich glossaries and articles.

### Run via API and CLI

Start a run and read the dataset in one call. Replace `<TOKEN>` with your Apify API token.

Run synchronously and get dataset items:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~dictionary-word-of-the-day-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"lookup","words":["serendipity","ephemeral"],"maxResults":10}'
```

Get today's Word of the Day:

```bash
curl -X POST "https://api.apify.com/v2/acts/scrapers_lat~dictionary-word-of-the-day-scraper/run-sync-get-dataset-items?token=<TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"mode":"wotd"}'
```

Apify CLI:

```bash
apify call scrapers_lat/dictionary-word-of-the-day-scraper \
  --input '{"mode":"lookup","words":["ubiquitous"],"aiUsageExamples":true}'
```

### Fetch results

Every run writes to a dataset. Fetch items as JSON, CSV or Excel by changing `format`:

```bash
## JSON
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=json"

## CSV
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=<TOKEN>&clean=true&format=csv"
```

`<DATASET_ID>` is returned as `defaultDatasetId` in the run object.

### Billing

- **Pay per result.** You are charged per word record returned (`result` event) plus a small one-time actor start event. See the [pricing tab](https://apify.com/scrapers_lat/dictionary-word-of-the-day-scraper/pricing) for current prices.
- **AI usage examples are a separate opt-in event.** Turn on `aiUsageExamples` to add three example sentences, a kid-friendly definition and a mnemonic. It is charged only when the AI returns usable output, and it is disabled for free plans.
- **No charge on failure.** A word with no definition, or a failed lookup, is written as an `error` record and is not charged. Empty runs cost nothing.
- **Spend cap respected.** Set `maxTotalChargeUsd` on the run; once reached, the actor stops emitting and charging further billable results.
- **Free Apify plans** are capped at 10 records per run, with paid add-ons disabled. Upgrade for higher `maxResults` and the AI layer.

### FAQ and troubleshooting

**Is the Word of the Day an official publisher feed?**
No. The source has no official word-of-the-day endpoint, so this actor ships a curated list of 366 interesting words and picks one deterministically by day of year. The choice is stable for a given date. It is our curated rotation, and the actor is transparent about it.

**Why is `audioUrl` null for some words?**
Not every entry has a recorded pronunciation. When none exists, `audioUrl` and the `audio` fields are `null`. The IPA `phonetic` is usually still present.

**Do non-English lookups work?**
English is fully covered. Other languages are best-effort: the source only returns them where it has an entry, which for many common non-English words it does not. In that case you get a record with an `error` note and no charge, rather than an invented definition.

**Why did my run return an `error` record?**
The word was not found in the chosen language, or a single lookup failed after retries. These records are not charged. Check spelling, or switch `language` to `en`.

**How do I get synonyms and antonyms only?**
Read `allSynonyms` and `allAntonyms`, which are flattened and deduplicated across every meaning. The per-meaning lists live inside `meanings`.

**Is this an official Merriam-Webster or Oxford tool?**
No. This actor is independent and not affiliated with any dictionary publisher. It reads only publicly available dictionary data.

### Related scrapers

- [Wikipedia Article & Pageviews Scraper](https://apify.com/scrapers_lat/wikipedia-articles-pageviews-scraper): article text and daily pageview stats.
- [Air Quality, AQI and Pollen Scraper](https://apify.com/scrapers_lat/air-quality-aqi-pollen-scraper): live air quality and pollen by location.

### More scrapers at scrapers.lat

Built and maintained by [scrapers.lat](https://scrapers.lat), where we publish scrapers for public platforms: dictionaries and reference data, company registries, government data, finance, e-commerce and more. Browse the catalog or request a custom scraper at [scrapers.lat](https://scrapers.lat).

***

> Independent tool, not affiliated with any dictionary publisher. Accesses only publicly available dictionary data. The Word of the Day is a curated rotation, not an official publisher feed.

# Actor input Schema

## `mode` (type: `string`):

wotd = return today's curated Word of the Day (stable per calendar day). lookup = define the words you pass in the Words / Word field.

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

Used in lookup mode. One or more words to define, e.g. serendipity, ephemeral, ubiquitous. Each word returns one record. Ignored in Word of the Day mode.

## `word` (type: `string`):

Convenience field for looking up one word. It is added to the Words list. Ignored in Word of the Day mode.

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

Dictionary language for lookup mode. English (en) has full coverage. Other languages are best-effort: the source only returns them where it has data, otherwise you get a no-definition record. Word of the Day is always English.

## `aiUsageExamples` (type: `boolean`):

Use AI to add 3 natural example sentences at different registers (casual, formal, literary), a simple kid-friendly definition and a mnemonic to remember the word. Charged only when a usable result is returned. Disabled on free plans.

## `maxResults` (type: `integer`):

Maximum number of word records to return across the run (lookup mode). Word of the Day always returns one. Free Apify plans are capped at 10 per run.

## Actor input object example

```json
{
  "mode": "wotd",
  "words": [
    "serendipity",
    "ephemeral"
  ],
  "language": "en",
  "aiUsageExamples": false,
  "maxResults": 10
}
```

# Actor output Schema

## `results` (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 = {
    "words": [
        "serendipity",
        "ephemeral"
    ],
    "maxResults": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapers_lat/dictionary-word-of-the-day-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 = {
    "words": [
        "serendipity",
        "ephemeral",
    ],
    "maxResults": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("scrapers_lat/dictionary-word-of-the-day-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 '{
  "words": [
    "serendipity",
    "ephemeral"
  ],
  "maxResults": 10
}' |
apify call scrapers_lat/dictionary-word-of-the-day-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapers_lat/dictionary-word-of-the-day-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/7h8HlZ3qqnKJed8Xg/builds/XJArkmFbJOuFvxo8q/openapi.json