# OK.ru Scraper - Users, Groups, Posts, Videos & Games (`abotapi/ok-ru-scraper`) Actor

Scrape public OK.ru users, groups, topics, posts, videos, games and greetings by keyword or URL. Extract profiles, feeds, views, likes, comments, players and ratings as clean JSON, with change tracking for recurring monitoring. No account required.

- **URL**: https://apify.com/abotapi/ok-ru-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 result records

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

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

## What's an Apify Actor?

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

## OK.ru Scraper: Profiles, Groups, Topics, Videos & Games

OK.ru Scraper turns Odnoklassniki (OK.ru), one of Russia's largest social networks, into structured data. Search users, groups, topic posts, videos or games by keyword, or paste any mix of ok.ru links, groups, topic posts, profiles, videos, the video showcase, the games catalogue or a single game, and greetings pages, each entry is auto-detected and read by the matching lane. Records come back as clean JSON: profiles with name, gender, birthday and location, groups with members and feed cards, videos with views, likes and comments, games with players and ratings. Everything works without logging in. Schedule the same input on a recurring basis and get only new and changed records, then export to JSON, CSV or Excel, or read the results through the API.

### Why This Scraper?

- No login, ever. Search, group feeds, topic posts, videos, games and profile enrichment all work from what the site shows logged out visitors; you never provide an account.
- Many ways in. Search users, groups, topic posts, videos or games by keyword, or paste any mix of links, groups, topics, profiles, videos, the video showcase, the games catalogue or a single game, and greetings pages are each auto-detected.
- Videos with real engagement. Every video row carries views, likes, duration and publish date; turn on Include comments to nest the first page of comments the site shows logged out visitors.
- Games with real ratings. Players and rating with vote count for every game, plus genre, tags and developer where the site lists them, from the full catalogue, a genre page or a keyword search.
- Profile enrichment out of the box. A profile ID or link alone returns name, gender, birthday, location and avatar, structured and typed.
- Monitoring built in. Schedule the same input on a recurring basis and receive only new and changed records, each marked `NEW` or `UPDATED`.
- Loud on blocks, quiet on anything else. When the site refuses every request, the run fails with a clear message instead of finishing quietly with no results.

### Use Cases

- Social listening and community research: track group membership, category and recent feed activity for public communities.
- OSINT and public profile lookups: turn a bare profile ID or link into structured name, gender, birthday and location.
- Video and channel monitoring: track views, likes and comments for individual OK.ru videos over time.
- Casual games research: compare player counts, ratings and genres across the whole games catalogue or one genre.
- Recurring content monitoring: schedule a search or a fixed list of links daily and get only what is new or changed.

### Data You Get

Sample shape: values are illustrative placeholders, not from a live record.

| Field | Example |
| --- | --- |
| `kind` | `"profile"` (also `"group"`, `"topic"`, `"video"`, `"game"`, `"greeting"`) |
| `id` | `"123456789012"` |
| `url` | ok.ru link to the record |
| `name` | `"Sample Group"` (profile, group and game records) |
| `title` / `text` | `"Sample topic title"` / `"Sample post text"` (topic, video and greeting records) |
| `firstName` / `lastName` | `"First"` / `"Last"` (profile) |
| `gender` / `birthday` | `"male"` / `"05-12"` (profile) |
| `location` / `avatar` | `"Sample City, Sample Country"` / avatar image URL (profile) |
| `membersCount` | `214187` (group) |
| `description` / `category` | `"Sample description"` / `"Board games"` (group and game search rows; a greeting's `category` is its topic, for example `"Happy birthday"`) |
| `feedCount` / `feedTexts` | `10` / recent feed post texts (group link rows) |
| `groupId` | `"53494783737943"` (topic and video records) |
| `commentsCount` | `42` (topic and video records) |
| `images` | image URLs (topic records) |
| `comments` | first page of comments, with Include comments on (video and topic records) |
| `durationSeconds` / `publishedAt` | `125` / ISO timestamp (video) |
| `viewsCount` / `likesCount` | `150000` / `2400` (video) |
| `dailyViews` | `310` (video search rows) |
| `channelName` / `channelUrl` | `"Sample Channel"` / channel link (video; the name only on video link and showcase rows) |
| `ownerType` / `ownerId` | `"group"` / `"1234567890"` (video) |
| `genre` / `tags` | `"board"` / `["Board games"]` (game; `genre` only from the games catalogue and game links, not game search) |
| `playersCount` | `955000` (game) |
| `rating` / `ratingVotes` | `4.32` / `145000`, null when a game has no votes yet (game) |
| `developer` | `"Sample Studio"` (game search rows and single game links, not catalogue pages) |
| `changeType` / `firstSeenAt` / `lastSeenAt` | `"NEW"` / ISO timestamps (incremental mode only) |

Profile records also carry `age` and `online` status when the site's own search returns them. Video records also carry `width`, `height`, a `thumbnail` image URL, and `isLive` / `isAdult` flags where the site marks them; `channelName` and `isAdult` only come from a direct video link or the showcase, not from search rows. Game records also carry a `shortName` slug, `is18plus` and `isNew` flags, `image` and `banner` URLs, and a `topicUrl` link to the game's discussion topic when the site provides one. Greeting records also carry `tags`, the category link titles shown with that greeting.

### How to Use

1. Pick a **mode**: `search` (by keyword) or `links` (paste any mix of ok.ru links).
2. In search mode, set the **search query** and the **types to search**. In links mode, paste your **links**; groups, topics, profiles, videos, games and greetings pages are each auto-detected.
3. Turn on **Include comments** if you want the first page of video and topic comments nested in each row, and set **Max items** to control run size and cost.
4. Click **Start**, then download the dataset as JSON, CSV or Excel, or read it through the API.

**Search users by keyword:**

```json
{
  "mode": "search",
  "searchQuery": "котики",
  "searchTypes": ["users"],
  "maxItems": 100
}
```

**Paste any mix of links; groups, topics and profiles are auto-detected per entry:**

```json
{
  "mode": "links",
  "links": [
    "https://ok.ru/group/53494783737943",
    "https://ok.ru/group/53494783737943/topic/158816426481751",
    "https://ok.ru/profile/352769811913"
  ]
}
```

**One query across videos, games and groups at once, with video and topic comments included:**

```json
{
  "mode": "search",
  "searchQuery": "котики",
  "searchTypes": ["videos", "games", "groups"],
  "maxItems": 50,
  "includeComments": true
}
```

**Daily monitoring of a group search, named so the state stays stable:**

```json
{
  "mode": "search",
  "searchQuery": "фитнес",
  "searchTypes": ["groups"],
  "incrementalMode": true,
  "stateKey": "fitness-groups",
  "maxItems": 200
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/ok-ru-scraper").call(run_input={
    "mode": "search", "searchQuery": "котики", "searchTypes": ["users"]})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row["kind"], row.get("name") or row.get("title"))
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/ok-ru-scraper').call({
  mode: 'search', searchQuery: 'котики', searchTypes: ['users'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

Or connect it to Make, Zapier, n8n, Google Sheets or webhooks from the Integrations tab.

#### How Max items applies

In search mode, Max items is a fresh budget for each selected type: three types with Max items 50 can return up to 150 records total, 50 of each. In links mode, Max items is one shared budget across the whole link list.

Search pagination (users, topic posts, groups, videos and games) stops as soon as one page brings nothing new, even if the site says more pages exist. This avoids looping forever on a search whose ranking repeats itself near the end of the results. The tradeoff: if the site serves one fully repeated page in the middle of a long result list, that search stops there and never reaches the genuinely new results further down. Those records are simply not collected in that run (and are not billed); in Incremental mode they show up as `NEW` on a later run that reaches them. If a broad query returns noticeably fewer records than Max items, run it again or split it into narrower queries.

The same rule applies across types in one run: Topic posts search also returns the groups those posts belong to, and Groups search skips any group already returned that way. A group is never returned twice, but if Topic posts runs first and already covered a whole page of group results, Groups search stops there. When you need a full group list, run Groups search on its own.

#### Resume and recurring updates

Two different features for two different situations:

- **Resume** (`resumeFromRunId`): paste a previous run's run ID or dataset ID. It is meant to continue one interrupted crawl without returning records already collected there. **Known issue: at the moment it skips nothing.** A resumed run returns and bills every record again, including every record already in the earlier dataset, even though the run log says "Resume: skipping N record(s)". Until this is fixed, do not use Resume to save money: use **Incremental mode** (below) to avoid paying twice for records you already have, and **Max items** to cap run size.
- **Incremental mode** (`incrementalMode`, default off): for scheduling this actor on a recurring basis (daily, hourly) with the same input, and getting only what changed. State is kept in a key value store. Without a `stateKey`, the key is derived from your whole input (everything except the connection settings), so changing any field, even Max items, starts a fresh state where everything is `NEW` again; set `stateKey` to keep one state across input changes, or to share it between tasks. State is saved only when the run finishes, so a run that is aborted or times out does not update it, and the records it returned come back as `NEW` (and are billed again) next time. Every record is classified `NEW` (first time seen for this state key), `UPDATED` (content changed since last seen) or `UNCHANGED` (nothing changed, suppressed and not billed unless `emitUnchanged` is on). This actor does not track or emit `EXPIRED` or `REAPPEARED` records: a record that disappears from the site simply stops appearing in later runs, it is not flagged. Every incremental record carries `changeType`, `firstSeenAt` and `lastSeenAt`. With `incrementalMode` off, output is unchanged: same records, same charges as before.

### Send results into your apps (MCP connectors)

Optionally pipe the scraped results into the apps you already use, via Model Context Protocol (MCP) connectors. This is an extra delivery step after the scrape, the Apify dataset is never changed.

What gets written to the connector: a condensed, human readable summary of each record, not the full JSON. Each item becomes one entry with a title and its key fields flattened to plain text. The complete record always stays in the Apify dataset.

1. Authorize a connector once under Apify, Settings, API & Integrations (Notion, Linear, Airtable, or Apify).
2. Select it in the connector input field. If the picker is empty, you have not authorized a connector yet.
3. For Notion, also set `notionParentPageUrl` to the page where items should be created.

The connection is mediated by Apify's MCP proxy, so this actor never sees your third party credentials. Leave the field empty to skip.

### Input Parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `mode` | string | `search` | `search` runs the site's own search (profiles, groups, topic posts, videos or games); `links` reads any ok.ru links, auto-detected per entry. |
| `searchQuery` | string | (none) | Search mode: keyword or phrase, Russian or English. |
| `searchTypes` | array | `["users"]` | Search mode: one or more of `users`, `groups`, `content`, `videos`, `games`; each is searched for the same query and Max items applies to each type. |
| `links` | array | sample links | Links mode: any mix of ok.ru links or bare profile IDs, groups, topics, profiles, videos, the video showcase, the games catalogue or a genre, one game, and greetings pages. |
| `maxItems` | integer | `20` | Stop after this many records (`0` = no limit). In search mode the limit applies to each selected type. |
| `includeComments` | boolean | `false` | Nest the first page of comments (up to 20, oldest first) inside video and topic records. Each record returned with comments is charged one small Comments collected event; records without comments are not. |
| `resumeFromRunId` | string | (none) | Paste a previous run ID or dataset ID to continue a large pull. Known issue: it currently skips nothing, so already collected records are returned and billed again (see Resume above). |
| `incrementalMode` | boolean | `false` | Turn on for daily or recurring monitoring; returns only new and changed records on later runs. |
| `stateKey` | string | (none) | Name this monitoring campaign to keep its state stable. Leave empty to derive a key from the run settings. |
| `emitUnchanged` | boolean | `false` | Also return (and bill) records that have not changed since the last run. |
| `mcpConnectors` | array | (none) | Optional: send a summary of each record to apps you authorized under Integrations. |
| `notionParentPageUrl` | string | (none) | Notion connector only: page under which item pages are created. |
| `maxNotifyListings` | integer | `50` | Cap on items written to each connector per run. Does not affect the dataset. |
| `proxyConfiguration` | object | Apify Proxy | Connection settings. |

### Output Example

Sample shape: values are illustrative placeholders, not from a live record.

```json
{
  "kind": "profile",
  "id": "123456789012",
  "name": "First Last",
  "firstName": "First",
  "lastName": "Last",
  "url": "https://ok.ru/profile/123456789012",
  "gender": "male",
  "birthday": "05-12",
  "location": "Sample City, Sample Country",
  "avatar": "https://i.okcdn.ru/i?r=SampleAvatar",
  "changeType": "NEW",
  "firstSeenAt": "2026-09-27T09:00:00+00:00",
  "lastSeenAt": "2026-09-27T09:00:00+00:00"
}
```

### Plan Requirement

The default connection setting works out of the box for every mode. If the site refuses every request in a run, the run fails with a clear message instead of finishing quietly with no results, so "nothing matched" is never confused with "nothing could be read".

### FAQ

#### How much does it cost?

You pay per record returned, plus a small extra charge for records returned with comments when Include comments is on. The Pricing tab shows the current rates. Use Max items to cap the cost of any run.

#### Is it legal to scrape OK.ru?

This actor collects only publicly available data that the site itself shows to logged out visitors. You are responsible for how you use it: follow OK.ru's terms and the laws that apply to you, and get legal advice if you plan commercial redistribution. Names, photos and other personal data may be subject to privacy and data protection rules in your jurisdiction.

#### Can I get only new or changed records on a schedule?

Yes. Schedule the actor from the Schedules tab and turn on Incremental mode. Later runs then return only new and updated records; unchanged ones are not billed unless you turn on Emit unchanged. There is no EXPIRED or REAPPEARED tracking: a record that disappears from the site just stops showing up, it is not flagged.

#### Why did I get fewer records than Max items?

In search mode, a search stops as soon as one page brings nothing new, even if the site says more pages exist, so on a broad query it can stop before the real end of the results; those records are not collected (or billed) in that run. Run it again or split it into narrower queries. If you selected both Topic posts and Groups, groups already returned by the topic posts search are skipped, and Groups search can stop early for the same reason; run Groups search on its own for a full list. See How Max items applies above. In links mode, each entry is read once, so the count depends only on how many links you pasted and what the site returns for each.

#### Does Resume from a previous run skip records I already have?

No, not at the moment. This is a known issue: Resume currently skips nothing, so a resumed run returns and bills every record again, including all records already in the earlier dataset, even though the log reports them as skipped. To avoid paying twice for records you already have, use Incremental mode with a fixed `stateKey` instead, and Max items to cap run size.

#### Why did my run fail instead of returning an empty dataset?

If the site refuses every request, the run stops with a clear message so "nothing found" is never confused with "nothing could be read". The same applies in links mode when none of your links can be read, for example because they do not exist on OK.ru: the run fails instead of returning empty or placeholder records. Run it again in a few minutes, or check the link.

#### Can I use it with AI agents or MCP?

Yes. Call it from any Apify integration or MCP client, and use the connector field to push results into Notion, Linear or Airtable.

### 🔗 More scrapers you might like

Pair this actor with these related scrapers from the same team:

<table>
<tr><td>🧩 <a href="https://apify.com/abotapi/pikabu-scraper"><b>Pikabu Scraper</b></a><br>Scrape Pikabu (Пикабу): keyword search, hot/new/best feeds, communities, tags, full story...</td><td>🏠 <a href="https://apify.com/abotapi/cian-ru-scraper"><b>Cian RU</b></a><br>Collect property listings from Cian.ru by search filters or direct URLs. Returns...</td></tr>
<tr><td>🏷️ <a href="https://apify.com/abotapi/wildberries-marketplace-scraper"><b>Wildberries Scraper</b></a><br>Scrape Wildberries marketplace: product search with prices (wallet vs retail), discounts...</td><td>🛒 <a href="https://apify.com/abotapi/ozon-ru-scraper"><b>Ozon.ru Scraper</b></a><br>Extract structured product data from Ozon.ru, Russia’s largest marketplace. Search by...</td></tr>
<tr><td>💼 <a href="https://apify.com/abotapi/hh-ru-jobs-scraper"><b>HH.ru Jobs Scraper</b></a><br>From $1/1K. Scrape HH.ru job listings with 50+ structured fields. Search by filters or...</td><td>🏠 <a href="https://apify.com/abotapi/domclick-scraper"><b>Domclick RU Property Scraper</b></a><br>Extract property listings from domclick.ru, one of Russia’s largest real estate portals...</td></tr>
</table>

👉 [Browse all abotapi scrapers](https://apify.com/abotapi)

### 💬 Support & custom scrapers

- 🐞 **Found a bug or a missing field?** Open a ticket on the [Issues tab](https://apify.com/abotapi/ok-ru-scraper/issues/open). We usually reply within hours.
- 🛠️ **Need another site, extra fields or a private build?** Email <abotapi@proton.me> or message [Telegram @abotapi](https://t.me/abotapi).
- ⭐ **Enjoying it?** A quick review on the actor page helps other users find it.

# Actor input Schema

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

Search runs the site's own search (profiles, groups, topic posts, videos or games). Links accepts any ok.ru links - groups, topics, profiles, videos, the video showcase, games and greetings pages - auto-detected per entry and read by the matching lane.

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

Search mode: keyword or phrase (Russian or English).

## `searchTypes` (type: `array`):

Search mode: pick any mix of types; each one is searched for the same query and Max items applies to each type. Profiles returns user records; groups returns groups with members, category and description; topic posts returns posts; videos returns videos with views, likes and duration; games returns games with players and rating.

## `links` (type: `array`):

Links mode: any mix of ok.ru links or bare profile IDs - groups (/group/<id>), topics (/group/<id>/topic/<id>), profiles (/profile/<id>), videos (/video/<id>), the video showcase (/video), the games catalogue or a genre (/games, /games/board), one game (/game/<name>) and greetings (/pozdravleniya or a category such as /pozdravleniya/s-dnem-rozhdeniya).

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

Stop after this many records (0 = no limit; the run then stops when listings run out). In search mode the limit applies to each selected type.

## `includeComments` (type: `boolean`):

Off by default. Turn on to add the comments OK.ru shows to logged-out visitors (the first 20, oldest first) inside each video and topic record. Each record returned with comments is charged one small Comments collected event; records without comments are not. The total comment count is included either way for video links.

## `resumeFromRunId` (type: `string`):

Paste a previous run ID or dataset ID to continue a large pull without returning items already collected there.

## `incrementalMode` (type: `boolean`):

Turn this on for daily or recurring monitoring. The first run returns every matching record as NEW. Later runs normally return only NEW and UPDATED records. Turn on Emit unchanged only when you also want those rows returned (and billed).

## `stateKey` (type: `string`):

Optional. Name this monitoring campaign to keep its state stable. Leave empty to derive a key from the run settings.

## `emitUnchanged` (type: `boolean`):

Off by default. Turn on to also return records that have not changed since the last run, marked UNCHANGED. This returns, and bills, extra rows you already have.

## `mcpConnectors` (type: `array`):

Optionally send results into the apps you already use, via Model Context Protocol (MCP) connectors. Authorize one under Apify, Settings, API & Integrations, then select it here. Notion gets a rich page-per-item export; other connectors get a best-effort write or digest. Leave empty to skip; never changes the dataset output.

## `notionParentPageUrl` (type: `string`):

URL or id of the Notion page under which item pages are created. Required to enable the Notion export; ignored by other connectors.

## `maxNotifyListings` (type: `integer`):

Cap on items written to each connector per run. Does not affect the dataset.

## `proxyConfiguration` (type: `object`):

Apify Proxy settings. The public OK.ru pages serve the standard pool.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "котики",
  "searchTypes": [
    "users"
  ],
  "links": [
    "https://ok.ru/group/53494783737943",
    "https://ok.ru/group/53494783737943/topic/158816426481751",
    "https://ok.ru/profile/352769811913"
  ],
  "maxItems": 20,
  "includeComments": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

## `videos` (type: `string`):

No description

## `games` (type: `string`):

No description

## `greetings` (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 = {
    "mode": "search",
    "searchQuery": "котики",
    "searchTypes": [
        "users"
    ],
    "links": [
        "https://ok.ru/group/53494783737943",
        "https://ok.ru/group/53494783737943/topic/158816426481751",
        "https://ok.ru/profile/352769811913"
    ],
    "maxItems": 20,
    "includeComments": false,
    "incrementalMode": false,
    "emitUnchanged": false,
    "maxNotifyListings": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/ok-ru-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 = {
    "mode": "search",
    "searchQuery": "котики",
    "searchTypes": ["users"],
    "links": [
        "https://ok.ru/group/53494783737943",
        "https://ok.ru/group/53494783737943/topic/158816426481751",
        "https://ok.ru/profile/352769811913",
    ],
    "maxItems": 20,
    "includeComments": False,
    "incrementalMode": False,
    "emitUnchanged": False,
    "maxNotifyListings": 50,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/ok-ru-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "mode": "search",
  "searchQuery": "котики",
  "searchTypes": [
    "users"
  ],
  "links": [
    "https://ok.ru/group/53494783737943",
    "https://ok.ru/group/53494783737943/topic/158816426481751",
    "https://ok.ru/profile/352769811913"
  ],
  "maxItems": 20,
  "includeComments": false,
  "incrementalMode": false,
  "emitUnchanged": false,
  "maxNotifyListings": 50,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call abotapi/ok-ru-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/ok-ru-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/TT5KWvQeGo06EmD97/builds/BYXvXeGJdsekisoXD/openapi.json