# Yandex Wordstat API — Keyword Volume, Trends & Regions (`cheapapi/yandex-wordstat-keyword-tool`) Actor

Yandex Wordstat keyword tool: monthly search volume, up to 2,000 related keywords, similar queries, trends since 2018 and demand by city. Bulk.

- **URL**: https://apify.com/cheapapi/yandex-wordstat-keyword-tool.md
- **Developed by:** [CheapAPI](https://apify.com/cheapapi) (community)
- **Categories:** SEO tools, Marketing, Developer tools
- **Stats:** 14 total users, 11 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

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

## How to integrate an Actor?

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

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

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

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

# README

## Yandex Wordstat API — Keyword Volume, Trends & Regions

Get **Yandex Wordstat** keyword data in bulk as clean JSON: the **monthly search volume** of every keyword (broad, phrase and exact match), up to **2,000 related keywords** with their volumes, **similar queries**, **search trends** (monthly since 2018, weekly or daily) and **demand by city or region**. Data comes straight from Yandex — Russia's leading search engine — so it is the keyword data you need for SEO and PPC in Russia, Belarus, Kazakhstan and Uzbekistan. No Yandex account, API key, proxy or captcha solving needed.

| Quick facts | |
|---|---|
| Price | $10.20 per 1,000 rows on the Free plan, $6.80 on Gold+; no start fee |
| One row | a keyword's volume, one related/similar keyword, a whole trend series, or one region |
| Depth | up to 2,000 related keywords and 20 similar keywords per keyword |
| Filters | 1,100+ regions (city, region or country), device, excluded words, minimum volume |
| History | monthly from January 2018, weekly, or daily for the last 60 days |
| Speed | about 100 keywords per hour (Yandex's current hourly request limit); longer lists wait automatically |

Jump to [Pricing](#pricing) · [FAQ](#faq) · [Limitations](#limitations)

**Why this Actor**

- **Yandex's own numbers:** the same counts you see on wordstat.yandex.ru, fetched in bulk — no manual copying, no browser automation, no blocked accounts.
- **Real ("clean") frequency in one row:** broad, `"phrase"` and `"!exact"` match volumes side by side, charged as **one** row.
- **Keyword research in one run:** up to **2,000 related keywords** per seed (most searched first), plus the 20 **similar queries** Yandex users also searched.
- **Seasonality and growth:** a trend row per keyword with the full series, average, peak month, change % and **year-over-year %** (monthly trends of 13+ months).
- **Local demand:** searches per city or region with Yandex's **affinity index** (over 100 = more popular there than on average), or limit every count to the regions you target.
- **Fair, predictable billing:** you pay per delivered row; a keyword nobody searches costs only a $0.0016 no-data fee, invalid keywords and failed requests are free, and your maximum cost per run is always respected.

### Compared with alternatives

There is **no other Actor with Yandex search volumes** in the Apify Store (searched "wordstat", "yandex keyword" and "yandex search volume", October 2026; one small Actor returns Yandex autocomplete suggestions without volumes). The closest listings return **Google** keyword volumes. Actor fees of public Store listings (Free plan / Gold plan), checked October 2026:

| Option | Data | 1,000 keyword volumes | Related keywords |
|---|---|---|---|
| **This Actor** | **Yandex** | **$10.20 / $6.80** | yes, up to 2,000 per keyword ($0.0102 / $0.0068 each) |
| Most-used keyword volume Actor (~1,500 users) | Google | $12 / $8 | yes, at the same per-row price |
| Keyword research Actor (~400 users) | Google | $10 | yes, $0.01 per row |
| Batch volume Actor (~800 users) | Google | $1.99 / $0.40 per batch of 1,000 | no |

This Actor is **15% cheaper per row than the most-used keyword volume Actor on every plan**. If you only need Google volumes for a list of keywords, a batch Google Actor is cheaper — but none of them has Yandex data.

### Not included

- **Google, Bing or other search engines** — Yandex searches only.
- **CPC, competition and keyword difficulty** — Wordstat does not provide them.
- **Search results or rankings** — use a Yandex SERP Actor for positions.
- **More than 2,000 related keywords or 20 similar keywords per keyword** — Yandex's own limits.
- **Daily data older than 60 days** or monthly data before January 2018 — Yandex's own limits.

### What data you get

Every row has `id` (stable across runs), `type`, `keyword` (your input), `phrase`, `searches`, `position`, `regionFilter`, `device` and `scrapedAt`. Extra fields by row type:

| Row type (`type`) | Extra fields | Example |
|---|---|---|
| `volume` — 1 per keyword | `searches` (broad), `phraseMatchSearches`, `exactMatchSearches` (null when not requested), `topRelatedKeyword` | купить диван: 663,892 / 26,008 / 23,289 |
| `related` — queries containing the keyword | `searches`, `position`, `shareOfKeywordPercent`, `wordCount` | купить диван недорого: 76,468 (11.52%) |
| `similar` — other queries of the same people | `searches`, `position`, `wordCount` | мебельный магазин: 252,693 |
| `trend` — 1 per keyword | `period`, `fromDate`, `toDate`, `latestDate`, `averageSearches`, `peakDate`, `peakSearches`, `changePercent`, `yearOverYearPercent` (monthly, 13+ months; else null), `series[]` | monthly, peak 2026-08 |
| `region` — demand by place | `regionId`, `regionName`, `regionLevel`, `regionSharePercent`, `affinityIndex` | Moscow: 83,899, affinity 113.9 |

`searches` is the number of Yandex searches in the last 30 days (for trend rows: the latest period). The dataset has ready-made views: **All rows, Search volume, Related & similar keywords, Trends, Regions**. Each view shows the columns for one row type and starts with the `type` column (all rows stay in one dataset, so sort or filter by `type` in the table or your export), plus a `RUN_SUMMARY` record in the key-value store.

### How to use

1. Open the Actor and click **Try for free**.
2. Enter your **Keywords**, one per line (Russian, English and other languages; Wordstat operators work).
3. Pick the **Reports** — search volume and related keywords are selected by default.
4. Optionally limit counts to **Regions** (e.g. `Moscow`, `Kazan`, `213`) or a **Device**.
5. Click **Start** and download the results as JSON, CSV, Excel or HTML, or read them through the API.

The prefilled input (1 keyword, volume + 20 related keywords) finishes in a few seconds. Plan big lists at about **100 keywords per hour** — 1,000 keywords take about 10 hours in one run (it waits for the hourly limit by itself; keep **Maximum wait** at 60 minutes or more). One run takes up to 2,000 statistics requests (volume + related = 1 request per keyword; each extra match type, the trend and the regions report add 1 — the run log shows the count and the expected hours at the start; the default run timeout is 24 hours); split bigger lists across runs.

Ready-to-paste input:

```json
{
    "keywords": ["купить диван", "ремонт квартир"],
    "reports": ["volume", "related", "trend"],
    "matchTypes": ["broad", "exact"],
    "maxPhrasesPerKeyword": 100,
    "regions": ["Moscow"],
    "excludeWords": ["бесплатно"]
}
```

**API (curl)** — runs the Actor and returns the rows when it finishes:

```bash
curl -X POST "https://api.apify.com/v2/acts/cheapapi~yandex-wordstat-keyword-tool/run-sync-get-dataset-items?token=<YOUR_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"keywords": ["купить диван"], "reports": ["volume", "related"], "maxPhrasesPerKeyword": 50}'
```

**JavaScript** (`npm install apify-client`):

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_TOKEN>' });
const run = await client.actor('cheapapi/yandex-wordstat-keyword-tool').call({
    keywords: ['купить диван', 'ремонт квартир'],
    reports: ['volume', 'related'],
    maxPhrasesPerKeyword: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.filter((r) => r.type === 'volume'));
```

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_TOKEN>")
run = client.actor("cheapapi/yandex-wordstat-keyword-tool").call(run_input={
    "keywords": ["купить диван", "ремонт квартир"],
    "reports": ["volume", "related"],
    "maxPhrasesPerKeyword": 50,
})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["type"], row["phrase"], row["searches"])
```

### Use cases

- **SEO for Russian-speaking markets:** build a semantic core from seed keywords, with real (exact-match) frequencies to prioritise pages.
- **Yandex Direct (PPC) planning:** size demand per keyword, city and device before launching campaigns; find negative keywords in related queries.
- **Seasonality:** see which months a product peaks and plan content, stock and budgets with year-over-year growth.
- **Regional expansion:** compare demand and affinity across cities to choose where to open, advertise or localise.
- **Market and trend research:** track brands, products or topics monthly — schedule the Actor and compare runs.
- **Content planning:** turn related and similar queries into article topics and FAQ sections.

### Advanced options

| Option | Default | What it does |
|---|---|---|
| `keywords` | — (required) | One keyword per line, up to 400 characters; up to 2,000 statistics requests per run (2,000 keywords with the default reports, about 20 hours). Operators: `"…"`, `!word`, `[word order]`, `-word`. |
| `reports` | `volume`, `related` | Any of `volume`, `related`, `similar`, `trend`, `regions`. |
| `regions` | all | City, region or country names (English or Russian) or Yandex region IDs; up to 100. Applies to volume, related, similar and trend. |
| `device` | `all` | `all`, `desktop`, `phone`, `tablet`. |
| `maxPhrasesPerKeyword` | 50 | Related keywords per keyword, 1–2,000 (each is a charged row). |
| `minSearches` | 0 | 0 or more: skip related/similar keywords with fewer monthly searches (skipped ones are free). |
| `excludeWords` | — | Leave out queries containing these words (added as `-word`). |
| `matchTypes` | `broad` | Volume columns: `broad`, `phrase` (`"…"`), `exact` (`"!…"`). Still one charged row; phrase/exact stay empty for keywords that already use operators. |
| `maxSimilarPerKeyword` | 20 | Similar keywords per keyword, 1–20. |
| `trendPeriod` | `monthly` | `monthly` (from 2018), `weekly`, `daily` (last 60 days). |
| `trendFrom` / `trendTo` | last 24 months / 52 weeks / 30 days | Dates `YYYY-MM-DD`; moved to whole months or Monday–Sunday weeks when needed. |
| `regionLevel` | `cities` | Regions report: `cities`, `regions` or `all`. |
| `maxRegionsPerKeyword` | 20 | Places per keyword in the Regions report, most searches first (each is a charged row). |
| `maxWaitMinutes` | 65 | Minutes each request may wait for Yandex's hourly request limit (0–120) before the run stops; the limit resets within 60 minutes. |

### Output example

Real rows from a run for `купить диван` (all reports with `matchTypes` broad/phrase/exact, 3 related, 2 similar, 2 regions and a custom monthly trend from `trendFrom: 2025-07-01`; October 2026; some rows and trend points left out):

```json
[
  { "id": "1e40eed40219cd70", "type": "volume", "keyword": "купить диван", "phrase": "купить диван", "searches": 663892, "position": null,
    "regionFilter": "All regions", "device": "all", "scrapedAt": "2026-10-05T14:46:36.494Z",
    "phraseMatchSearches": 26008, "exactMatchSearches": 23289, "topRelatedKeyword": "купить диван недорого" },
  { "id": "095c907d78e099a0", "type": "related", "keyword": "купить диван", "phrase": "купить диван недорого", "searches": 76468, "position": 1,
    "regionFilter": "All regions", "device": "all", "scrapedAt": "2026-10-05T14:46:36.494Z", "shareOfKeywordPercent": 11.52, "wordCount": 3 },
  { "id": "9dea7c84e2e4d2fd", "type": "similar", "keyword": "купить диван", "phrase": "мебельный магазин", "searches": 252693, "position": 1,
    "regionFilter": "All regions", "device": "all", "scrapedAt": "2026-10-05T14:46:36.494Z", "shareOfKeywordPercent": null, "wordCount": 2 },
  { "id": "3f6a080f4ad36ba2", "type": "trend", "keyword": "купить диван", "phrase": "купить диван", "searches": 690667, "position": null,
    "regionFilter": "All regions", "device": "all", "scrapedAt": "2026-10-05T14:46:36.494Z",
    "period": "monthly", "fromDate": "2025-07-01", "toDate": "2026-09-30", "latestDate": "2026-09-01", "averageSearches": 650007,
    "peakDate": "2026-08-01", "peakSearches": 911485, "changePercent": -9.7, "yearOverYearPercent": -1.2,
    "series": [ { "date": "2025-07-01", "searches": 764886, "sharePercent": 0.007228 }, { "date": "2026-08-01", "searches": 911485, "sharePercent": 0.008115 },
                { "date": "2026-09-01", "searches": 690667, "sharePercent": 0.005944 } ] },
  { "id": "3e360e6cc07ecbae", "type": "region", "keyword": "купить диван", "phrase": "купить диван", "searches": 83899, "position": 1,
    "regionFilter": "All regions", "device": "all", "scrapedAt": "2026-10-05T14:46:36.494Z",
    "regionLevel": "cities", "regionId": "213", "regionName": "Moscow", "regionSharePercent": 0.006557, "affinityIndex": 113.9 }
]
```

### Pricing

Pay per event — **you pay per delivered row, or a small $0.0016 no-data fee per request for a keyword with nothing to deliver**, with no start fee. Apify platform usage is billed separately by Apify. This Actor uses 256 MB of memory; our test runs used about $0.0005 of platform usage each, and a run that waits at Yandex's hourly limit adds roughly $0.10 per hour of waiting (at $0.40 per compute unit).

| Event | Free | Bronze | Silver | Gold, Platinum, Diamond |
|---|---|---|---|---|
| Keyword row (`keyword-row`) | $0.0102 | $0.00906 | $0.00793 | $0.0068 |
| Lookup without data (`empty-lookup`) | $0.0016 | $0.0016 | $0.0016 | $0.0016 |

- A **volume row** is one row however many match types you choose. A **trend row** contains the whole series.
- **Lookup without data:** only when a keyword gives nothing to deliver (nobody searched it, or your filters removed everything) — charged once per request made for that keyword. Search volume (with all its match types counted as separate requests), trend and regions are one request each; related and similar share the volume request. With the Search volume report, such a keyword still gets its volume row (all zeros) for this fee only.
- **Free:** invalid keywords, keywords Yandex rejects, failed requests, duplicates, and related keywords below your minimum. If one report of a keyword fails, the rows of its other reports are still delivered and charged as usual.

**Worked examples (Free / Gold):**

- **Search volume for 1,000 keywords** (1,000 rows): **$10.20 / $6.80** (about 10 hours at the current hourly limit, plus about $1 of platform usage for the waiting).
- **100 seed keywords × (volume + 50 related keywords)** (5,100 rows): **$52.02 / $34.68**.
- **Full research for one keyword** — volume, 200 related, 20 similar, monthly trend and the top 20 cities (242 rows): **$2.47 / $1.65**.

Set **Maximum cost per run** in the run options to cap any run; the Actor stops cleanly at the limit and tells you what was skipped.

**Apify Free plan:** up to **$0.25 of results per month** (enough to try the prefilled input — 1 keyword with volume and 20 related keywords costs $0.21). Any paid Apify plan removes this limit. When many users are running at the same time, even a trial run may wait for Yandex's hourly limit before it returns rows (it waits up to **Maximum wait**, and nothing is charged while it waits).

### Integrations

- **Google Sheets, Excel, CSV:** export the dataset or use the Google Sheets integration to fill a sheet after every run.
- **Make, Zapier, n8n:** start the Actor and receive rows in your scenarios.
- **Webhooks:** get a call when a run finishes.
- **Scheduling:** run monthly to track trends; every row has a stable `id`.
- **API and MCP:** call it from code (see above) or from AI agents through Apify's MCP server.

### FAQ

**Is it legal?** The Actor gets its data through Yandex's official, paid keyword statistics API (Yandex Cloud Search API), not by scraping the Wordstat website. The data is aggregated search counts with no personal data. You are responsible for how you use the results, including Yandex's terms of use if you republish the numbers.

**How fresh is the data?** Volumes are for the last 30 days, fetched live at run time. Monthly trends end with the last finished month, weekly with the last finished week, daily with yesterday.

**Why do the volume row and the trend row show different numbers?** The volume row counts the last 30 days; the trend row's `searches` is the last calendar month (or week/day).

**What is the difference between broad, phrase and exact match?** Broad counts every query containing the words (`купить диван` includes `купить угловой диван недорого`). Phrase (`"купить диван"`) counts only queries made of exactly these words. Exact (`"!купить !диван"`) also fixes each word form. SEO specialists usually plan with phrase or exact match.

**Why did I get fewer related keywords than I asked for?** Yandex returns fewer for rare keywords; `minSearches`, `excludeWords` and duplicates also remove some. The keyword itself is never repeated as a related keyword (it is the volume row), so with the maximum of 2,000 you get up to 1,999 related keywords plus the volume row.

**Why was I charged for a keyword with no searches?** Yandex still processed the lookup, so a small $0.0016 no-data fee applies per request made: $0.0016 with the default reports, up to $0.008 with every report and match type enabled (5 requests). Invalid keywords and failed requests are free.

**Can I limit counts to a city?** Yes — put city, region or country names in **Regions**. The Regions report itself always ranks every place (it shows where the demand is).

**The run says it is waiting at the hourly limit — is something wrong?** No. Yandex limits how many statistics requests can be made per hour (about 100 at the moment, shared by all users of this Actor); the run waits and continues automatically (up to **Maximum wait** for each request), and nothing is charged while it waits. Platform usage while waiting is about $0.10 per hour.

**Does it work for Turkey or other countries?** Wordstat counts searches made on Yandex. They are large in Russia, Belarus, Kazakhstan and Uzbekistan, and small elsewhere (Turkish keywords often show only tens of searches).

**Do I need a Yandex account or API key?** No. Everything is included in the price.

### Support

Found a problem or need a feature? Open an issue on the Actor's **Issues** tab with the run ID; we aim to answer within one working day.

Every run also saves a `RUN_SUMMARY` record in its key-value store: keywords requested, completed, without data, partial, failed and skipped by your cost limit, rows delivered, no-data fees charged, waits at the hourly limit, and a `problems` list with the reason for each keyword that was skipped or incomplete.

### Limitations

- **Throughput:** Yandex currently allows this Actor about **100 statistics requests per hour**. Volume + related costs 1 request per keyword; each extra match type, the trend and the regions report add 1 each. Large lists are processed at that pace — the run waits automatically, or you can split the list across runs.
- Counts are Yandex's own statistics: estimates, not exact logs; very rare keywords may show 0.
- Up to 2,000 related and 20 similar keywords per keyword; daily trends only for the last 60 days; monthly trends from January 2018.
- The region filter applies to volume, related, similar and trend; the Regions report always covers every place.
- Region names are matched in English or Russian; when several places share a name, the larger one is used — give the numeric Yandex region ID to be exact.

# Actor input Schema

## `keywords` (type: `array`):

One keyword per line, as people type it into Yandex (Russian, Kazakh, Belarusian, Uzbek, Turkish or English; up to 400 characters). Duplicates are removed.<br>• Yandex Wordstat operators work: <code>"купить iphone"</code> (only these words), <code>!купить</code> (this exact word form), <code>\[iphone купить]</code> (this word order), <code>купить iphone -бу</code> (exclude a word).<br>• Speed: Yandex currently allows this Actor about 100 statistics requests per hour, i.e. about 100 keywords per hour with the default reports. Longer lists keep running and wait for the limit automatically; one run handles up to 2,000 statistics requests (about 20 hours; volume + related = 1 request per keyword, each extra match type, the trend and the regions report add 1), split bigger lists.

## `reports` (type: `array`):

What to get for every keyword. Each delivered row is one charged result; a keyword with no searches costs only a small no-data fee (see Pricing in the README).

## `regions` (type: `array`):

Only count searches made in these places: city, region or country names in English or Russian ("Moscow", "Saint Petersburg", "Kazakhstan", "Москва") or Yandex region IDs (213 = Moscow). Empty = all regions. Up to 100. Applies to volume, related, similar and trend (the Regions report always covers every region).

## `device` (type: `string`):

Only count searches made on this type of device.

## `maxPhrasesPerKeyword` (type: `integer`):

How many related keywords to return for each keyword (most searched first). Each one is a charged row, so this is the main cost control. Yandex returns up to 2,000.

## `minSearches` (type: `integer`):

Skip related and similar keywords with fewer monthly searches than this (skipped keywords are not charged).

## `excludeWords` (type: `array`):

Leave out every query containing one of these words (one word per line, e.g. <code>бесплатно</code>, <code>бу</code>). Applies to every report.

## `matchTypes` (type: `array`):

Volume numbers to add to the Search volume row. Phrase and exact match are what SEO specialists call the real ("clean") frequency. Each extra match type is one more request (it counts toward the hourly request limit), but the row is still charged once. Not available for keywords that already use operators (their phrase/exact columns stay empty).

## `maxSimilarPerKeyword` (type: `integer`):

How many similar keywords to return per keyword (Yandex gives up to 20).

## `trendPeriod` (type: `string`):

Granularity of the trend report.

## `trendFrom` (type: `string`):

Start of the trend (YYYY-MM-DD). Empty = the last 24 months, 52 weeks or 30 days. Moved to the start of a month (monthly) or a Monday (weekly) when needed.

## `trendTo` (type: `string`):

End of the trend (YYYY-MM-DD). Empty = the last finished month, week or day.

## `regionLevel` (type: `string`):

Which kind of places the Regions report lists.

## `maxRegionsPerKeyword` (type: `integer`):

How many places to return per keyword, the ones with the most searches first. Each place is a charged row.

## `maxWaitMinutes` (type: `integer`):

Yandex limits keyword statistics requests per hour and the limit resets within 60 minutes. When it is reached the run waits and continues automatically, up to this many minutes for each request (0–120; keep 60 or more for lists over 100 keywords). After that it stops and keeps what it has; nothing is charged for the waiting.

## Actor input object example

```json
{
  "keywords": [
    "купить диван"
  ],
  "reports": [
    "volume",
    "related"
  ],
  "device": "all",
  "maxPhrasesPerKeyword": 20,
  "minSearches": 0,
  "matchTypes": [
    "broad"
  ],
  "maxSimilarPerKeyword": 20,
  "trendPeriod": "monthly",
  "regionLevel": "cities",
  "maxRegionsPerKeyword": 20,
  "maxWaitMinutes": 65
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `volume` (type: `string`):

No description

## `keywordIdeas` (type: `string`):

No description

## `trends` (type: `string`):

No description

## `regions` (type: `string`):

No description

## `runSummary` (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 = {
    "keywords": [
        "купить диван"
    ],
    "reports": [
        "volume",
        "related"
    ],
    "maxPhrasesPerKeyword": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("cheapapi/yandex-wordstat-keyword-tool").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 = {
    "keywords": ["купить диван"],
    "reports": [
        "volume",
        "related",
    ],
    "maxPhrasesPerKeyword": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("cheapapi/yandex-wordstat-keyword-tool").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 '{
  "keywords": [
    "купить диван"
  ],
  "reports": [
    "volume",
    "related"
  ],
  "maxPhrasesPerKeyword": 20
}' |
apify call cheapapi/yandex-wordstat-keyword-tool --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,cheapapi/yandex-wordstat-keyword-tool"
        }
    }
}
```

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/4i9CY5j3aJMMhhY2c/builds/ABhly0bMjaztIRv4u/openapi.json
