# Datamuse Word Finder Scraper (`parseforge/datamuse-words-scraper`) Actor

Export English word lists from the Datamuse word-finder: synonyms, antonyms, rhymes, sound-alikes, hypernyms, holonyms, frequency scores, syllable counts, definitions, and part-of-speech tags. Pick a relation type, seed word, optional topic, and download the full result set.

- **URL**: https://apify.com/parseforge/datamuse-words-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.75 / 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)

## 📝 Datamuse Word Finder Scraper

> 🚀 **Export English word lists in seconds.** Pull synonyms, antonyms, rhymes, sound-alikes, hypernyms, holonyms, definitions, frequency scores, and pronunciations across **370,000+ words**. No registration, no API key, no manual JSON wrangling.

> 🕒 **Last updated:** 2026-05-20 · **📊 11 fields** per word · **🔤 370k+ words** queryable · **🔗 17 relation types**

The **Datamuse Word Finder Scraper** exports English word lists from the Datamuse word-finder and returns up to **11 fields per word**, including the word itself, relation score, syllable count, part-of-speech tags, frequency per million tokens, ARPABET pronunciation, and one or more dictionary definitions. The underlying dataset is one of the largest open word-relation indexes for English, covering 370,000+ unique forms.

Coverage spans **17 relation types**: means-like (semantic), sounds-like (phonetic), spelled-like (wildcards), rhymes, near-rhymes, synonyms, antonyms, hypernyms (kind of), hyponyms (more specific), holonyms (part of), meronyms (has parts), triggers (co-occurrence), follows / precedes (collocations), adjectives-for-noun, nouns-for-adjective, and frequency-sorted lists.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| NLP developers, crossword and word-game builders, content writers, SEO keyword strategists, ESL and EdTech apps, copywriters, lyric and poetry tools | Vocabulary expansion, rhyme finding, sound-alike search, keyword research, autocomplete dictionaries, thesaurus apps, language-learning drills |

---

### 📋 What the Datamuse Word Finder Scraper does

Seventeen relation-typed lookups in a single Actor:

- 🧠 **Means like.** Semantic neighbors (synonyms, related concepts).
- 🔊 **Sounds like / Rhymes / Near rhymes.** Phonetic similarity for songwriting, poetry, mnemonics.
- 🔡 **Spelled like.** Wildcard lookups (`?`, `*`) for crossword and word-puzzle apps.
- 📚 **Synonyms / Antonyms.** Classic thesaurus relations.
- 🌳 **Hypernyms / Hyponyms / Holonyms / Meronyms.** Taxonomy relations (`is a kind of`, `is part of`).
- 🔁 **Triggers / Follows / Precedes.** Co-occurrence and collocation lookups for n-gram suggestions.
- 🏷️ **Adjectives for noun / Nouns for adjective.** Grammatical companions for autocomplete.
- 📊 **Frequent.** Frequency-ranked word lists with wildcards.

Optional metadata add-ons return definitions, parts of speech, syllable counts, frequency per million tokens, and ARPABET pronunciations.

> 💡 **Why it matters:** building a word-aware app means juggling thesauri, rhyming dictionaries, frequency tables, and pronunciation lexicons. Datamuse exposes all of that through a single uniform interface; this Actor wraps it for repeatable, schedulable runs that you can pipe into a spreadsheet, notebook, or downstream service.

---

### 🎬 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>Words to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>queryType</code></td><td>string</td><td><code>"means_like"</code></td><td>One of 17 relation types.</td></tr>
<tr><td><code>seedWord</code></td><td>string</td><td><code>"happy"</code></td><td>Seed word or pattern. Wildcards (<code>?</code>, <code>*</code>) supported for spelled-like.</td></tr>
<tr><td><code>topicWord</code></td><td>string</td><td><code>""</code></td><td>Optional topic bias.</td></tr>
<tr><td><code>leftContext</code> / <code>rightContext</code></td><td>string</td><td><code>""</code></td><td>Words immediately before/after the target.</td></tr>
<tr><td><code>partOfSpeech</code></td><td>string</td><td><code>""</code></td><td>Restrict to noun, verb, adjective, or adverb.</td></tr>
<tr><td><code>includeDefs</code> / <code>includeTags</code></td><td>boolean</td><td><code>true</code></td><td>Include definitions and POS/frequency/pronunciation tags.</td></tr>
</tbody>
</table>

**Example: synonyms of "happy" with definitions.**

```json
{
    "maxItems": 25,
    "queryType": "means_like",
    "seedWord": "happy",
    "includeDefs": true,
    "includeTags": true
}
````

**Example: words that rhyme with "moon" biased toward astronomy.**

```json
{
    "maxItems": 50,
    "queryType": "rhymes",
    "seedWord": "moon",
    "topicWord": "astronomy"
}
```

> ⚠️ **Good to Know:** Datamuse caps each query at 1,000 results, so for very large word lists, break your request into multiple seeded queries (alphabetical wildcards, multiple topics) and concatenate datasets. The default returns are ranked by relevance, not alphabetical order.

***

### 📊 Output

Each word record contains up to **11 fields**. Download as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🔤 `word` | string | `"pleased"` |
| 🔁 `queryType` | string | `"means_like"` |
| 🌱 `seedWord` | string | null | `"happy"` |
| 📊 `score` | number | null | `40004395` |
| 🔢 `numSyllables` | number | null | `1` |
| 🏷️ `partsOfSpeech` | string\[] | null | `["adjective", "verb"]` |
| 📈 `frequencyPerMillion` | number | null | `19.64` |
| 🔊 `pronunciation` | string | null | `"P L IY1 Z D"` (ARPABET) |
| 📚 `definitions` | string\[] | null | `["adj  Happy, content."]` |
| 🏷️ `tags` | string\[] | null | Raw Datamuse tag list |
| 🕒 `scrapedAt` | ISO 8601 | Collection timestamp |

#### 📦 Sample records

<details>
<summary><strong>📝 Means-like search for "happy" -> "pleased"</strong></summary>

```json
{
    "word": "pleased",
    "queryType": "means_like",
    "seedWord": "happy",
    "score": 40004395,
    "numSyllables": 1,
    "partsOfSpeech": ["adjective", "verb"],
    "frequencyPerMillion": 19.64,
    "pronunciation": "P L IY1 Z D",
    "definitions": ["adj  Happy, content."],
    "tags": ["syn", "adj", "v", "results_type:primary_rel", "pron:P L IY1 Z D", "f:19.640009"],
    "scrapedAt": "2026-05-20T23:16:57.989Z"
}
```

</details>

<details>
<summary><strong>📝 Means-like search for "happy" -> "blissful"</strong></summary>

```json
{
    "word": "blissful",
    "queryType": "means_like",
    "seedWord": "happy",
    "score": 40004156,
    "numSyllables": 2,
    "partsOfSpeech": ["adjective"],
    "frequencyPerMillion": 0.86,
    "pronunciation": "B L IH1 S F AH0 L",
    "definitions": [
        "adj  Extremely happy; full of joy; experiencing, indicating, causing, or characterized by bliss.",
        "adj  (obsolete) Blessed; glorified."
    ],
    "tags": ["syn", "adj", "pron:B L IH1 S F AH0 L", "f:0.859597"]
}
```

</details>

<details>
<summary><strong>📝 Means-like search for "happy" -> "content"</strong></summary>

```json
{
    "word": "content",
    "queryType": "means_like",
    "seedWord": "happy",
    "score": 40004024,
    "numSyllables": 2,
    "partsOfSpeech": ["adjective"],
    "frequencyPerMillion": 73.8,
    "pronunciation": "K AA1 N T EH0 N T",
    "definitions": ["adj  Satisfied, pleased, contented."]
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🔤 | **Massive coverage.** 370,000+ unique English forms across 17 relation types. |
| 🎯 | **Flexible queries.** Combine relation type with topic bias, left/right context, and part-of-speech filter. |
| 📚 | **Rich metadata.** Optional definitions, ARPABET pronunciations, syllable counts, and frequency per million tokens. |
| ⚡ | **Fast.** Hundreds of words in under 5 seconds. |
| 🔁 | **Always fresh.** Live word-finder pulls reflect the current Datamuse index. |
| 🧩 | **Wildcards.** Spelled-like supports `?` (one char) and `*` (any) for crossword and pattern matching. |
| 🚫 | **No authentication.** Public word-finder. No login or token required. |

> 📊 Datamuse is one of the most-used open word APIs in the indie and educational developer community.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Filters | Setup |
|---|---|---|---|---|---|
| **⭐ Datamuse Word Finder Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **370k+ words** | **Live per run** | 17 relation types, topic, context, POS | ⚡ 2 min |
| Direct Datamuse queries | Free, rate-limited | Full | Live | Manual | 🛠️ Coding |
| Commercial NLP word APIs | $$$+/month | Variable | Variable | Many | ⏳ Long signup |
| Local thesaurus / WordNet dumps | Free | Subset, stale | Rarely | Manual | 🕒 Setup time |

Pick this Actor when you want repeatable, schedulable word lists in CSV/JSON without writing query loops or rate-limiting handlers.

***

### 🚀 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 Datamuse Word Finder Scraper page on the Apify Store.
3. 🎯 **Set input.** Pick a relation type, set a seed word, and add optional topic or context.
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">

#### ✍️ Content and SEO

- Expand keyword sets with means-like and triggers queries
- Find low-frequency long-tail variants for blog posts
- Build content brief libraries with topic-biased thesaurus pulls
- Generate alt-text and meta-description candidates

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

#### 🎮 Word games and puzzles

- Crossword builders with `spelled_like` wildcard searches
- Rhyme-game seed lists for songwriting and battle-rap apps
- Hangman/Wordle dictionaries filtered by length and frequency
- Anagram and pangram word pools

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

#### 📚 EdTech and language learning

- Vocabulary lists keyed to CEFR level via frequency tiers
- Pronunciation drills using ARPABET output
- Synonym/antonym flashcards for SAT/GRE prep apps
- ESL exercises with co-occurring word pairs

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

#### 🤖 NLP and product features

- Power autocomplete with relevance-ranked candidates
- Build domain-specific thesauri (medical, legal, finance)
- Generate paraphrase candidates for content rewriting
- Seed embeddings benchmarks with curated word pairs

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

***

### 🔌 Automating Datamuse Word Finder 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 documentation](https://docs.apify.com/) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Build keyword-expansion pipelines that refresh weekly without manual prompting.

***

### 🌟 Beyond business use cases

Data like this 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

- Corpus linguistics studies on word relations
- Reproducible datasets for psycholinguistic experiments
- NLP coursework with hands-on word-finder exercises
- Frequency-based reading-difficulty research

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

#### 🎨 Personal and creative

- Songwriters mining rhymes and near-rhymes
- Poets building thematic word palettes
- Bloggers stretching headline vocabulary
- Hobby word-list collectors and dictionary nerds

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

#### 🤝 Non-profit and civic

- Accessibility tools for dyslexia and language disorders
- Literacy-program word lists for community libraries
- Translation/localization aid kits for non-profit content
- Open educational resources for ESL classrooms

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

#### 🧪 Experimentation

- Train domain-specific word2vec or fastText models
- Prompt engineering for LLM paraphrase and rewriting
- Agent pipelines that propose alternative phrasing
- Benchmark embeddings on synonym and analogy tasks

</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%20Datamuse%20Word%20Finder%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%20Datamuse%20Word%20Finder%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%20Datamuse%20Word%20Finder%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%20Datamuse%20Word%20Finder%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?

Pick a relation type and seed word, click Start, and the Actor queries the open word-finder and returns one structured record per matching word, ranked by relevance.

#### 📏 How accurate is the data?

Datamuse derives its relations from corpora including WordNet, Wiktionary, and the Google Books n-gram dataset. Scoring is empirical and tuned for usefulness, not strict linguistic correctness. Frequency scores reflect Google Books usage.

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

Datamuse maintains a continuously updated word index. Every run pulls live, so your results reflect the current version of the underlying lexicons.

#### 🔊 What format is the pronunciation field?

ARPABET, with stress markers. The numbers after vowels indicate primary (`1`), secondary (`2`), or no (`0`) stress.

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval (daily, weekly) to refresh keyword sets or vocabulary lists.

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

Datamuse's open word index is intended for free use. Some underlying source corpora (WordNet, Wiktionary) have their own licenses; review them for redistribution at scale.

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

Yes for non-substantial extracts. Datamuse's terms ask large-volume users to be considerate; if you need very high volumes, consider their commercial license.

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

No. The free Apify plan is enough for testing and small runs (10 records per run). A paid plan lifts the limit.

#### 🔁 What happens if a run fails or gets interrupted?

Apify automatically retries transient errors. Partial datasets are preserved.

#### 🧩 Can I do wildcard searches like crossword apps?

Yes. Use `queryType: spelled_like` with `?` (one character) and `*` (any sequence). Example: `h?ll?` matches `hallo`, `hello`, `hills`, and more.

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

Datamuse Word Finder 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 word data 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. Build keyword pipelines that refresh content briefs or app vocabularies automatically.

***

### 🔗 Recommended Actors

- [**📐 arXiv Preprint Scraper**](https://apify.com/parseforge/arxiv-scraper) - Open-access research papers
- [**🐉 Open5e SRD 5.1 Scraper**](https://apify.com/parseforge/open5e-srd-scraper) - SRD 5.1 monsters, spells, and items
- [**🖼️ Art Institute of Chicago Scraper**](https://apify.com/parseforge/art-institute-of-chicago-scraper) - AIC catalog metadata
- [**📊 OurAirports Global Airport Database Scraper**](https://apify.com/parseforge/ourairports-scraper) - Worldwide airport reference data

> 💡 **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.

***

# Actor input Schema

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

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

## `queryType` (type: `string`):

Which word relationship to fetch.

## `seedWord` (type: `string`):

The seed word, phrase, or wildcard pattern. For 'spelled\_like' use '?' (one char) and '*' (any). Examples: 'happy', 'th*', 'h?ll?'.

## `topicWord` (type: `string`):

Optional topic to bias results (Datamuse 'topics' param).

## `leftContext` (type: `string`):

Word that immediately precedes the target (Datamuse 'lc' param).

## `rightContext` (type: `string`):

Word that immediately follows the target (Datamuse 'rc' param).

## `partOfSpeech` (type: `string`):

Restrict to one grammatical category.

## `includeDefs` (type: `boolean`):

Append dictionary definitions to each word (Datamuse 'md=d').

## `includeTags` (type: `boolean`):

Append part-of-speech, syllable, frequency, and pronunciation tags (Datamuse 'md=psrf').

## Actor input object example

```json
{
  "maxItems": 10,
  "queryType": "means_like",
  "seedWord": "happy",
  "includeDefs": true,
  "includeTags": true
}
```

# 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,
    "queryType": "means_like",
    "seedWord": "happy",
    "partOfSpeech": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/datamuse-words-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,
    "queryType": "means_like",
    "seedWord": "happy",
    "partOfSpeech": "",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/datamuse-words-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,
  "queryType": "means_like",
  "seedWord": "happy",
  "partOfSpeech": ""
}' |
apify call parseforge/datamuse-words-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Datamuse Word Finder Scraper",
        "description": "Export English word lists from the Datamuse word-finder: synonyms, antonyms, rhymes, sound-alikes, hypernyms, holonyms, frequency scores, syllable counts, definitions, and part-of-speech tags. Pick a relation type, seed word, optional topic, and download the full result set.",
        "version": "1.0",
        "x-build-id": "dkPLeSvIw2WxDd48n"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~datamuse-words-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-datamuse-words-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~datamuse-words-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-datamuse-words-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~datamuse-words-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-datamuse-words-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"
                    },
                    "queryType": {
                        "title": "Query Type",
                        "enum": [
                            "means_like",
                            "sounds_like",
                            "spelled_like",
                            "rhymes",
                            "near_rhymes",
                            "synonyms",
                            "antonyms",
                            "hypernyms",
                            "hyponyms",
                            "holonyms",
                            "meronyms",
                            "triggers",
                            "follows",
                            "precedes",
                            "adjectives_for_noun",
                            "nouns_for_adjective",
                            "frequent",
                            "general"
                        ],
                        "type": "string",
                        "description": "Which word relationship to fetch."
                    },
                    "seedWord": {
                        "title": "Seed Word or Pattern",
                        "type": "string",
                        "description": "The seed word, phrase, or wildcard pattern. For 'spelled_like' use '?' (one char) and '*' (any). Examples: 'happy', 'th*', 'h?ll?'."
                    },
                    "topicWord": {
                        "title": "Topic Word",
                        "type": "string",
                        "description": "Optional topic to bias results (Datamuse 'topics' param)."
                    },
                    "leftContext": {
                        "title": "Left Context",
                        "type": "string",
                        "description": "Word that immediately precedes the target (Datamuse 'lc' param)."
                    },
                    "rightContext": {
                        "title": "Right Context",
                        "type": "string",
                        "description": "Word that immediately follows the target (Datamuse 'rc' param)."
                    },
                    "partOfSpeech": {
                        "title": "Part of Speech",
                        "enum": [
                            "",
                            "n",
                            "v",
                            "adj",
                            "adv"
                        ],
                        "type": "string",
                        "description": "Restrict to one grammatical category."
                    },
                    "includeDefs": {
                        "title": "Include definitions",
                        "type": "boolean",
                        "description": "Append dictionary definitions to each word (Datamuse 'md=d').",
                        "default": true
                    },
                    "includeTags": {
                        "title": "Include part-of-speech tags",
                        "type": "boolean",
                        "description": "Append part-of-speech, syllable, frequency, and pronunciation tags (Datamuse 'md=psrf').",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
