# Wikidata Lexemes Scraper (`parseforge/wikidata-lexemes-scraper`) Actor

Search and extract Wikidata Lexemes (L-namespace). Returns lemma, language QID, lexical category, senses, glosses, statements, and optional inflected forms for each lexeme. Distinct from Q-entities.

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

## Pricing

from $10.00 / 1,000 result items

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🧬 Wikidata Lexemes Scraper

> 🚀 **Export structured lexicographic data in seconds.** Pull lemmas, lexical categories, grammatical forms, and senses from the **Wikidata Lexeme namespace** across hundreds of languages. No API key, no registration, no SPARQL skills required.

> 🕒 **Last updated:** 2026-05-22 · **📊 14 fields** per record · **🧬 1.4M+ lexemes** · **🌐 1,500+ languages** · **🔤 30+ lexical categories**

The **Wikidata Lexemes Scraper** queries the L-namespace on wikidata.org and returns **14 fields per record**, including lexeme ID, lemma, language QID, lexical category QID, every documented sense, every inflected form, statement metadata, and a link back to the canonical Wikidata Lexeme page. The L-namespace is a structured, machine-readable companion to Wiktionary and powers downstream dictionaries, linguistic research, and language documentation.

The dataset covers **more than 1.4 million lexemes spanning over 1,500 languages**, from major world languages down to documented endangered and historical languages. This Actor turns the namespace into downloadable CSV, Excel, JSON, or XML in under five minutes. Lemma search, language filter, and lexical category filter all run from the same input form.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Linguists, NLP engineers, dictionary builders, language-documentation teams, computational lexicographers, knowledge-graph engineers | Multilingual lemma dictionaries, training data for morphology models, inflection tables for language apps, structured glosses for translation pipelines |

---

### 📋 What the Wikidata Lexemes Scraper does

Three lookup workflows in a single run:

- 🔍 **Lemma search.** Query the L-namespace by any lemma string in any UI language.
- 🌐 **Language filter.** Restrict results to a single language QID such as `Q1860` English or `Q150` French.
- 🔤 **Lexical category filter.** Limit to a part of speech via QID, for example `Q1084` noun or `Q24905` verb.

Each record includes the lexeme ID, lemma, lemma language code, language QID, lexical category QID, a short description, every documented sense with multilingual glosses, every inflected form with grammatical feature QIDs, statement count and properties, last-modified timestamp, the canonical Lexeme URL, and the scrape timestamp.

> 💡 **Why it matters:** structured lexicographic data powers morphological analyzers, inflection tables, multilingual search, and machine translation. Building your own pipeline means writing SPARQL queries, handling pagination across the L-namespace, and joining sense and form data by hand. This Actor skips all of that and refreshes on every run.

---

### 🎬 Full Demo

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

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
<tr><td><code>searchQuery</code></td><td>string</td><td><code>"run"</code></td><td>Lemma string to search for in the Lexeme namespace.</td></tr>
<tr><td><code>searchLanguage</code></td><td>string</td><td><code>"en"</code></td><td>UI language code used for the search index.</td></tr>
<tr><td><code>lexicalCategoryQid</code></td><td>string</td><td><code>""</code></td><td>Restrict to a part-of-speech QID. <code>Q1084</code> noun, <code>Q24905</code> verb, <code>Q34698</code> adjective.</td></tr>
<tr><td><code>languageQid</code></td><td>string</td><td><code>""</code></td><td>Restrict to a single language QID. <code>Q1860</code> English, <code>Q150</code> French, <code>Q1568</code> Spanish.</td></tr>
<tr><td><code>includeForms</code></td><td>boolean</td><td><code>false</code></td><td>Embed the inflected forms list on each lexeme record.</td></tr>
</tbody>
</table>

**Example: 50 English verbs starting with "run".**

```json
{
    "maxItems": 50,
    "searchQuery": "run",
    "searchLanguage": "en",
    "lexicalCategoryQid": "Q24905",
    "languageQid": "Q1860",
    "includeForms": true
}
````

**Example: French nouns containing "maison".**

```json
{
    "maxItems": 25,
    "searchQuery": "maison",
    "searchLanguage": "fr",
    "lexicalCategoryQid": "Q1084",
    "languageQid": "Q150"
}
```

> ⚠️ **Good to Know:** Wikidata coverage of the L-namespace is uneven across languages. English, French, German, and Russian are well populated. Endangered and minor languages may have just a handful of lexemes. Always sanity-check counts before downstream use.

***

### 📊 Output

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

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🆔 `lexemeId` | string | `"L1234"` |
| 🔤 `lemma` | string | `"run"` |
| 🌐 `lemmaLanguage` | string | `"en"` |
| 🏷️ `languageQid` | string | `"Q1860"` |
| 🔢 `lexicalCategoryQid` | string | `"Q24905"` |
| 📝 `description` | string | null | `"English verb"` |
| 🔢 `senseCount` | number | `3` |
| 📖 `senses` | object\[] | `[{"id":"L1234-S1","glosses":{"en":"to move quickly..."}}]` |
| 🔢 `formCount` | number | `5` |
| 🔁 `forms` | object\[] | `[{"id":"L1234-F1","representations":{"en":"running"},"grammaticalFeatures":["Q1230649"]}]` |
| 🧾 `statementCount` | number | `12` |
| 🏷️ `statementProperties` | string\[] | `["P5402","P5238","P5187"]` |
| 🕒 `lastModified` | ISO 8601 | `"2025-11-04T08:22:17Z"` |
| 🔗 `lexemeUrl` | string | `"https://www.wikidata.org/wiki/Lexeme:L1234"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-22T10:00:00.000Z"` |

#### 📦 Sample records

<details>
<summary><strong>🏃 English verb: "run" (L1234)</strong></summary>

```json
{
    "lexemeId": "L1234",
    "lemma": "run",
    "lemmaLanguage": "en",
    "languageQid": "Q1860",
    "lexicalCategoryQid": "Q24905",
    "description": "English verb",
    "senseCount": 3,
    "senses": [
        {
            "id": "L1234-S1",
            "glosses": {
                "en": "to move quickly on foot, faster than walking",
                "fr": "courir, se déplacer rapidement à pied"
            }
        }
    ],
    "formCount": 5,
    "forms": [
        {
            "id": "L1234-F1",
            "representations": { "en": "runs" },
            "grammaticalFeatures": ["Q3910936"]
        },
        {
            "id": "L1234-F2",
            "representations": { "en": "running" },
            "grammaticalFeatures": ["Q1230649"]
        }
    ],
    "statementCount": 12,
    "statementProperties": ["P5402", "P5238", "P5187"],
    "lastModified": "2025-11-04T08:22:17Z",
    "lexemeUrl": "https://www.wikidata.org/wiki/Lexeme:L1234",
    "scrapedAt": "2026-05-22T10:00:00.000Z"
}
```

</details>

<details>
<summary><strong>🇫🇷 French noun: "maison" (L1979)</strong></summary>

```json
{
    "lexemeId": "L1979",
    "lemma": "maison",
    "lemmaLanguage": "fr",
    "languageQid": "Q150",
    "lexicalCategoryQid": "Q1084",
    "description": "French noun",
    "senseCount": 2,
    "senses": [
        {
            "id": "L1979-S1",
            "glosses": {
                "fr": "bâtiment où l'on habite",
                "en": "house, residential building"
            }
        }
    ],
    "formCount": 2,
    "forms": [
        {
            "id": "L1979-F1",
            "representations": { "fr": "maisons" },
            "grammaticalFeatures": ["Q146786"]
        }
    ],
    "statementCount": 8,
    "statementProperties": ["P5185", "P5402"],
    "lastModified": "2025-09-12T15:44:01Z",
    "lexemeUrl": "https://www.wikidata.org/wiki/Lexeme:L1979",
    "scrapedAt": "2026-05-22T10:00:00.000Z"
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🧬 | **Structured lexicography.** Lemma, language QID, lexical category, senses, forms, and statements per record. |
| 🌐 | **Multilingual.** Covers 1,500+ languages, with cross-language glosses on every sense. |
| 🔁 | **Inflection-ready.** Forms array carries grammatical feature QIDs for plurals, tenses, declensions, and more. |
| ⚡ | **Fast.** 10 lexemes in under 5 seconds, 1,000 lexemes in under three minutes. |
| 🏷️ | **Knowledge-graph native.** Every QID joins directly with Q-entities and Wikidata properties. |
| 🔁 | **Always fresh.** Each run hits the live Wikidata L-namespace, so the dataset reflects current contributions. |
| 🚫 | **No authentication.** Works against the public Wikidata index. No login or API key needed. |

> 📊 Structured lexicographic data is the foundation of morphological analyzers, translation pipelines, and language documentation projects.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Setup |
|---|---|---|---|---|
| **⭐ Wikidata Lexemes Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **1.4M+** lexemes, 1,500+ languages | **Live per run** | ⚡ 2 min |
| Hand-written SPARQL on the public endpoint | Free + engineering | Full | Build it yourself | 🛠️ Days |
| Wikidata JSON dumps | Free | Full, stale by weeks | Monthly | 🐢 Hours |
| Commercial lexicographic APIs | $99+/month | Curated subset | Daily | ⏳ Hours |

Pick this Actor when you want structured lexicographic records without writing SPARQL or hosting your own SPARQL engine.

***

### 🚀 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 Wikidata Lexemes Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter a lemma search, pick a language QID and lexical category QID, and set `maxItems`.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

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

#### 🤖 NLP & Translation

- Morphological analyzers from forms arrays
- Lemma dictionaries for tokenizers
- Training data for translation alignment
- Cross-language gloss lookups

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

#### 📱 Language Apps

- Verb conjugation tables from forms
- Plural and gender data for nouns
- Lemma autocomplete with QID joins
- Multilingual definition popovers

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

#### 📚 Lexicographers

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

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

#### 🧠 Knowledge-Graph Engineers

- Lexeme-to-entity links for entity linking
- Property-rich nodes for semantic search
- Wiki-anchored multilingual glossaries
- Structured nodes for AI knowledge stores

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

***

### 🔌 Automating Wikidata Lexemes Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Weekly or monthly pulls keep downstream lexicographic stores in sync automatically.

***

### 🌟 Beyond business use cases

Lexicographic data powers more than commercial workflows. The same structured records support research, education, civic projects, and language documentation.

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

#### 🎓 Research and academia

- Computational linguistics dissertations
- Cross-language morphology studies
- Reproducible datasets cited in papers
- Open-data exercises on language coverage

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

#### 🎨 Personal and creative

- Indie language-learning side projects
- Conjugation game prototypes
- Writer reference tools and glossaries
- Hobbyist lexicographic databases

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

#### 🤝 Non-profit and civic

- Endangered-language documentation
- Community translation projects
- Educational glossaries for schools
- Civic literacy programs

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

#### 🧪 Experimentation

- Train morphological generators
- Prototype agents that inflect words
- Build glossary chrome extensions
- Test language-app UX with real data

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

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Wikidata%20Lexemes%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%20Wikidata%20Lexemes%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%20Wikidata%20Lexemes%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%20Wikidata%20Lexemes%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?

Enter a lemma search, pick optional language and lexical category QIDs, click Start, and the Actor queries the Wikidata L-namespace and emits a clean structured record per matching lexeme. No browser automation, no SPARQL, no captchas.

#### 🆔 What are lexemes and how are they different from Q-entities?

Wikidata stores three kinds of entries: Items (Q-prefix) for things, Properties (P-prefix) for predicates, and Lexemes (L-prefix) for words. Lexemes have lemmas, languages, lexical categories, senses, and forms, distinct from regular knowledge-graph items.

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

Wikidata contributors edit lexemes continuously. Every run of this Actor pulls live data, so the dataset reflects current contributions as of run time.

#### 🌐 Which languages are supported?

Over 1,500 languages have at least one lexeme. English, French, German, Russian, and several other major languages are well populated. Coverage of endangered and minor languages varies.

#### ⏰ Can I schedule regular runs?

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

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

Wikidata content is released under Creative Commons CC0. There are no attribution requirements, though citing Wikidata is encouraged.

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

Yes. CC0 permits commercial use with no restrictions. You are responsible for downstream compliance with any specific use-case requirements.

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

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

#### 🔁 What happens if a search returns no matches?

A diagnostic record is pushed with an `error` field. Try a broader lemma string or remove the language/lexical-category filter.

#### 🔤 Does it include phonology or audio?

This Actor returns lemmas, senses, forms, and statement metadata. For audio pronunciation or IPA, reach out via the contact form below to request a companion pronunciation scraper.

#### 🆘 What if I need help?

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

***

### 🔌 Integrate with any app

Wikidata Lexemes 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 lexeme 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. Push fresh lexeme records into your morphological analyzer, or alert your team in Slack.

***

### 🔗 Recommended Actors

- [**📖 Wiktionary Definitions Scraper**](https://apify.com/parseforge/wiktionary-definitions-scraper) - Multilingual dictionary entries with definitions and examples
- [**📚 Wikipedia Scraper**](https://apify.com/parseforge/wikipedia-scraper) - Encyclopedic articles and references
- [**📰 ArXiv Scraper**](https://apify.com/parseforge/arxiv-scraper) - Scientific preprint metadata
- [**📈 Indexmundi Scraper**](https://apify.com/parseforge/indexmundi-scraper) - Global demographic and economic indicators
- [**🗺️ Nominatim OSM Scraper**](https://apify.com/parseforge/nominatim-osm-scraper) - Geocode addresses via OpenStreetMap

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more reference-data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Wikidata, the Wikimedia Foundation, or any of its contributors. All trademarks mentioned are the property of their respective owners. Only publicly available open lexicographic data is collected.

# Actor input Schema

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

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

## `searchQuery` (type: `string`):

Lemma string to search for in the Lexeme namespace. Example: 'run', 'maison', 'こんにちは'.

## `searchLanguage` (type: `string`):

UI language code used for the search index. Defaults to English.

## `lexicalCategoryQid` (type: `string`):

Restrict to a part-of-speech QID. Examples: Q1084 noun, Q24905 verb, Q34698 adjective.

## `languageQid` (type: `string`):

Restrict to a single language QID. Examples: Q1860 English, Q150 French, Q1568 Spanish.

## `includeForms` (type: `boolean`):

Embed the inflected forms list (plurals, conjugations, declensions) on each lexeme record.

## Actor input object example

```json
{
  "maxItems": 10,
  "searchQuery": "run",
  "searchLanguage": "en",
  "includeForms": false
}
```

# 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,
    "searchQuery": "run",
    "searchLanguage": "en"
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/wikidata-lexemes-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,
    "searchQuery": "run",
    "searchLanguage": "en",
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/wikidata-lexemes-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,
  "searchQuery": "run",
  "searchLanguage": "en"
}' |
apify call parseforge/wikidata-lexemes-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Wikidata Lexemes Scraper",
        "description": "Search and extract Wikidata Lexemes (L-namespace). Returns lemma, language QID, lexical category, senses, glosses, statements, and optional inflected forms for each lexeme. Distinct from Q-entities.",
        "version": "1.0",
        "x-build-id": "lLv1IVJtZtUYNps4j"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~wikidata-lexemes-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-wikidata-lexemes-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~wikidata-lexemes-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-wikidata-lexemes-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~wikidata-lexemes-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-wikidata-lexemes-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"
                    },
                    "searchQuery": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Lemma string to search for in the Lexeme namespace. Example: 'run', 'maison', 'こんにちは'."
                    },
                    "searchLanguage": {
                        "title": "Search Language",
                        "type": "string",
                        "description": "UI language code used for the search index. Defaults to English."
                    },
                    "lexicalCategoryQid": {
                        "title": "Lexical Category QID",
                        "type": "string",
                        "description": "Restrict to a part-of-speech QID. Examples: Q1084 noun, Q24905 verb, Q34698 adjective."
                    },
                    "languageQid": {
                        "title": "Language QID",
                        "type": "string",
                        "description": "Restrict to a single language QID. Examples: Q1860 English, Q150 French, Q1568 Spanish."
                    },
                    "includeForms": {
                        "title": "Include Forms",
                        "type": "boolean",
                        "description": "Embed the inflected forms list (plurals, conjugations, declensions) on each lexeme record.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
