# Pikabu Scraper - Stories, Comments, Communities, Search (`abotapi/pikabu-scraper`) Actor

Scrape Pikabu (Пикабу): keyword search, hot/new/best feeds, communities, tags, full story details with media, all comments, creator profiles. Monitoring (NEW, UPDATED, REAPPEARED, EXPIRED), incremental runs, resume, MCP export.

- **URL**: https://apify.com/abotapi/pikabu-scraper.md
- **Developed by:** [Abot API](https://apify.com/abotapi) (community)
- **Features:** Limited permissions
- **Stats:** 7 total users, 3 monthly users, 84.7% 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

## Pikabu Scraper: Stories, Comments, Profiles and Search

Collect public Pikabu stories, comments and creator profiles. Search by keyword, walk feeds and community or tag listings, or supply individual story links. Story details include text, images, videos, tags, authors and vote counts where the source supplies them. Comments are separate records, so their parent IDs can be used to reconstruct threads. Export the results as JSON, CSV or Excel, or read them through the API.

### Why This Scraper?

- **Keyword search.** Search by keyword with relevance, rating or newest ordering.
- **Mixed inputs.** Combine feed links and individual stories in the same collection.
- **Full media.** Return full-size images and video sources, posters and dimensions.
- **Threaded comments.** Collect comments with author information, votes and parent IDs.
- **Profile data.** Read profile counters, registration dates, avatars and awards.
- **Cost control.** Set shared item limits and individual comment limits.
- **Recurring runs.** Resume story collection and suppress unchanged records in recurring runs.

### Use Cases

- **Content and trend research:** track which stories, tags and communities are gaining rating, comments and reposts, sorted by relevance, rating or date.
- **Community and sentiment research:** collect comments with author, vote and parent-thread data on chosen posts, tags or communities to study discussion patterns.
- **Creator and account scouting:** pull profile counters, registration dates, awards and recent stories to evaluate an account's history and reach.
- **Content aggregation and republishing:** feed stories, images and videos from specific tags, communities or user blogs into your own site, bot or digest.
- **Recurring monitoring:** watch a search, tag or community on a schedule and collect only the new and updated posts since the last run.

### Data You Get

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

| Field | Example |
|---|---|
| `kind` | `story`, `comment` or `profile` |
| `id` | `00000001` |
| `url` | Story, comment permalink or profile URL |
| `title` | `Sample Story` |
| `text` | `Sample public text` |
| `author` | Public ID, nickname, profile URL and optional avatar/subscriber count |
| `community` | Community name, slug and URL when present |
| `tags` | `["Sample tag"]` |
| `tagUrls` | Tag page links |
| `rating` | `120` |
| `pluses` | `130` positive votes |
| `minuses` | `10` negative votes |
| `commentsCount` | `11` |
| `views` | Story view count from Pikabu's public counter; null when the counter cannot be read |
| `publishedAt` | `2026-01-01T00:00:00+03:00` |
| `blocks` | Ordered text, image and video content |
| `images` | Full-size story URLs; image objects on comments |
| `videos` | Sources, poster, duration, dimensions and video identifiers |
| `media` | Story image and video counts |
| `storyId`, `parentId`, `depth` | Comment fields: parent story ID, parent comment ID (`0` for a root comment) and nesting depth |
| `registeredAt` | Profile registration date |
| `stats` | Exact profile rating, comment, story and subscriber counts |
| `awards` | Public profile awards with image and optional link |
| `changeType` | `NEW`, `UPDATED`, `UNCHANGED`, `REAPPEARED` or `EXPIRED` in incremental runs |

Story rows also carry flat alias fields next to the nested ones, so exports from other Pikabu search scrapers keep working: `searchUrl` (the listing URL the story came from), `scrapedAt`, `content`, `detailPageUrl`, `createdAt`, `createdAtHuman` (the site's relative time text), `coverImage`, `authorId`, `authorName`, `authorLink`, `authorAvatar`, `communityName` and `communityLink`.

Other fields include comment links, edited and story-author appreciation flags, long-story and pinned flags, profile user ID, avatar, background image, following count and verified badge. Profile rows include recent story cards. Optional fields may be null or empty when absent from the source.

Community links collect the community's stories; they do not produce a separate community-header record. Feed and search cards can contain partial text or media. Enable `fetchDetails` for the full story page, and `fetchComments` to collect its available comments. A story opened in full from a feed, search, community, tag or user listing also carries `channel`, the community from its original listing card, kept as a fallback alongside the detail page's own `community` value; pasted story links do not have a listing card, so they carry no `channel`.

### How to Use

1. Pick a **mode**: `search` (keyword search), `feed` (feeds, communities, tags and user blogs), `story` (pasted story links or IDs) or `profile` (creator profiles).
2. Fill in the query or links for that mode, and choose whether to open full story details and collect comments.
3. Set **Max items** to control run size and cost, then click **Start**.
4. Download the dataset as JSON, CSV or Excel, or read it through the API.

Choose a mode and set `maxItems`. This cap includes stories, comments and profile rows together. `0` means no item limit, so collection continues until the available results end.

#### Keyword search

Search uses its own query and ordering fields. An empty query searches the general result listing. Feed, story and profile link fields are ignored in this mode.

**Search by keyword:**

```json
{
  "mode": "search",
  "searchQuery": "games",
  "searchOrder": "date",
  "fetchDetails": false,
  "fetchComments": false,
  "maxItems": 20
}
```

#### Mixed feed and story links

Feed and Story link fields have their own input sections, but in either `feed` or `story` mode, either field accepts feeds, communities, tags, user blogs, individual story URLs and numeric story IDs. Individual stories are read first, then listings are walked; duplicate story IDs are skipped. Supported link shapes: home feed (also `?page=2`), `/new`, `/best`, tags (also `/tag/<name>/hot?page=2`), communities, user blogs, story links (also `m.pikabu.ru`), and search result URLs with `q`, `n`, `st` and `page`. A pasted `page` number is the page the walk starts from. If you omit `feedLinks` in Feed or Story mode (and give no story links), the scraper now scrapes one example of each shape (twelve links) instead of only the home feed; set `maxItems` to bound the run, or pass your own links.

**Walk feeds and story links:**

```json
{
  "mode": "feed",
  "feedLinks": ["https://pikabu.ru/new"],
  "storyUrls": ["https://pikabu.ru/story/sample_story_00000001"],
  "fetchDetails": false,
  "fetchComments": false,
  "maxItems": 20
}
```

#### Story detail and comments

Individual story links always open full detail. The story is returned before its comments, so a small item cap does not omit the parent story. `maxCommentsPerStory` limits returned comments for each story (default 100, never more than 10000); the shared `maxItems` limit still applies.

**Read a story with comments:**

```json
{
  "mode": "story",
  "storyUrls": ["00000001"],
  "fetchComments": true,
  "maxCommentsPerStory": 11,
  "maxItems": 12
}
```

#### Creator profiles

Profile mode returns the header, then walks the creator's stories. Turn off details and comments when you need profile counters and story cards only.

**Read a creator profile:**

```json
{
  "mode": "profile",
  "profileUrls": ["https://pikabu.ru/@sample_creator"],
  "fetchDetails": false,
  "fetchComments": false,
  "maxItems": 5
}
```

#### Run it from your code

Python:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("abotapi/pikabu-scraper").call(run_input={"mode": "search", "searchQuery": "games", "maxItems": 20})
for story in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(story["title"], story["rating"])
```

JavaScript:

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('abotapi/pikabu-scraper').call({ mode: 'search', searchQuery: 'games', maxItems: 20 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

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

#### Recurring collections and resume

Use `resumeFromRunId` to skip stories already present in a previous run or dataset. Use `incrementalMode` for recurring collections with the same scope. The initial run marks records `NEW`; later runs suppress unchanged records unless `emitUnchanged` is enabled. Changes are detected per field (title, text, content blocks, tags, author, community, media; profile description and story count). Rating, pluses, minuses, comment count, views and subscribers move on almost every scrape, so they are still returned but never mark a record `UPDATED`. The author is compared on id, name and profile link only (the author's subscriber count and avatar are returned but never mark a record `UPDATED`), and the community on name and community link without any query string. `changedFields` lists the field names that changed (`record` for records tracked before this version, compared on title, text and content blocks only). Use `ignoreFieldsForChanges` to exclude more fields, for example `tags`; it is part of the 🔁 Resume section and does not reset your saved state. State saved by earlier versions of this actor for the same task is picked up automatically, so the first run after an update does not return the whole catalogue as new.

`stateKey` names a monitoring scope. `emitExpired` fires only once a run has walked its whole configured scope. A run that stops early never reports anything `EXPIRED` and never marks a record as gone: this covers reaching **Max items**, the per-story comment limit while comments remain, a refused page, and the page limit. Records the run did not reach keep their saved state, so they come back as `UNCHANGED` (not returned, not billed) when a later run sees them again. Only records actually returned as `EXPIRED` are marked absent; with `emitExpired` off no record is marked absent and nothing is billed for it. A record that returns after being reported `EXPIRED` comes back as `REAPPEARED`. Returned unchanged or expired rows are billed as result items; expired placeholders do not trigger detail or comment enrichment.

### Input Parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `mode` | string | `search` | Search, feed or story/profile reading. |
| `searchQuery` | string | - | Search keyword or phrase. |
| `searchOrder` | string | `relevance` | Search result ordering: relevance, rating or date (sent to Pikabu as its `st` sort). |
| `searchUrl` | string | - | Optional pasted Pikabu search URL such as `https://pikabu.ru/search?q=iphone&st=3`. When set, it is walked like a feed link, with its `st` sort and `page` kept, and replaces the mode and search fields. |
| `feedLinks` | stringList | one example per shape | Feed, tag, community, user-blog, search-result or story links to walk. Default: one example per shape. |
| `storyUrls` | stringList | - | Story links or numeric IDs read for full detail. |
| `profileUrls` | stringList | - | Creator links or names for profile records. |
| `fetchDetails` | boolean | `true` | Open each story for its full detail page. |
| `fetchComments` | boolean | `true` | Collect each opened story's comments as separate rows. |
| `maxCommentsPerStory` | integer | `100` | Cap on comment rows per story; 0 is accepted and means the hard cap of 10000. |
| `maxItems` | integer | `20` | Stop after this many records (0 = unlimited). |
| `resumeFromRunId` | string | - | Continue a previous run without repeating its items. |
| `ignoreFieldsForChanges` | array | - | Extra field names that must not mark a record UPDATED (incremental mode only). |
| `incrementalMode` | boolean | `false` | Return only NEW and UPDATED records on later runs. |
| `stateKey` | string | - | Name this monitoring campaign's state. |
| `emitUnchanged` | boolean | `false` | Also return unchanged records (billed). |
| `emitExpired` | boolean | `false` | Also return records no longer found (billed). |
| `mcpConnectors` | stringList | - | Optional MCP connector export. |
| `notionParentPageUrl` | string | - | Notion connector only: parent page for item pages. |
| `maxNotifyListings` | integer | `50` | Cap on items written per connector per run. |
| `proxyConfiguration` | object | - | Apify Proxy settings for all requests. |

#### Charges

Every returned record has a result-item charge. The `detail-enrichment` event is shared by story details and comment collection: one event per returned detailed story, plus **`round(returned comments / 10)` events per story**. These enrichment events are additional to result-item charges.

Rounding uses the nearest integer, with exact halves going to the nearest even integer: 5 comments add 0 events, 6 or 11 add 1, 15 add 2, and 25 add 2. Suppressed comments and failed writes do not count. Counts are based on actual returned comments, not the configured maximum.

Rates per result item, enrichment event and actor start are listed on the Pricing tab for your subscription tier. Empty pages and refused requests do not trigger result or enrichment charges; actor start still applies.

One detailed story with 11 comments produces **12 result-item events + 2 enrichment events + actor start**.

Output tabs: `Results` (all rows), plus `Stories`, `Comments` and `Profiles` views that show only the columns of that record kind (`?view=stories`, `?view=comments`, `?view=profiles`). Views select columns, they do not filter rows, so filter on `kind` for a single-kind export.

### Output Example

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

```json
{
  "kind": "story",
  "id": "00000001",
  "title": "Sample Story",
  "url": "https://pikabu.ru/story/sample_story_00000001",
  "author": {"id": "0000", "name": "Sample Author", "url": "https://pikabu.ru/@sample_creator"},
  "community": null,
  "tags": ["Sample tag"],
  "tagUrls": ["https://pikabu.ru/tag/sample"],
  "rating": 120,
  "pluses": 130,
  "minuses": 10,
  "commentsCount": 11,
  "publishedAt": "2026-01-01T00:00:00+03:00",
  "timestamp": 1700000000,
  "seriesId": null,
  "isLong": false,
  "isPinned": false,
  "blocks": [{"type": "text", "text": "Sample public story text", "links": []}],
  "text": "Sample public story text",
  "images": [],
  "videos": [],
  "media": {"images": 0, "videos": 0},
  "detailFetched": true
}
```

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

Authorize an app connector under Apify Settings, API & Integrations. In the input, open **Export to your apps (MCP connectors, optional)** and select it. Notion requires `notionParentPageUrl`; `maxNotifyListings` limits how many records each connector receives.

Each exported record is a condensed, human-readable summary containing a title and key fields. Nested objects are flattened and arrays are shortened; the full JSON always remains in the dataset. Notion gets a page per record, while other connectors use a best-effort write or digest. Leaving connectors empty skips exports. Export failures preserve the scraped dataset.

### Plan Requirement

An Apify account is required to run the actor. Pikabu sits behind a DDoS-Guard browser check that the Apify datacenter proxy passes only on some pages and some attempts, so residential proxies (the Apify residential group, country RU) are the reliable choice and the proxy field defaults to Apify Proxy. Apify free plans do not include residential proxies: there the run continues on a backup connection, some pages may still be unavailable, and a run where every page is refused fails with a plain message instead of returning an empty dataset. Only publicly available source content is collected; unavailable or removed pages may produce fewer records, and a run where every requested page is refused fails.

### FAQ

#### How much does it cost?

You pay per result record returned (stories, comments and profiles alike), plus the detail and comment enrichment charges described in the Charges section above when those features are on. Actor start is a one-time charge per run. The **Pricing** tab shows the current rates for your subscription tier. Use **Max items** to cap the cost of any run.

#### Is it legal to scrape Pikabu?

This actor collects only publicly available Pikabu pages: stories, comments and profile pages that anyone can open in a browser. You are responsible for how you use the data: follow Pikabu's terms and the laws that apply to you, and get legal advice before any commercial redistribution. Story and comment text, images and videos may belong to their original posters.

#### Can I get only new stories and comments on a schedule?

Yes. Schedule the actor from the **Schedules** tab with the same search, feed, story or profile inputs each time, and turn on **Incremental mode**. The first scheduled run returns everything as `NEW`; later runs return only `NEW` and `UPDATED` records, and unchanged ones are suppressed, and not billed, unless **Emit unchanged** is on.

#### Why does my scheduled run not report expired records?

A run that stopped early (reached **Max items**, the comment limit with comments left, a refused page) never reports `EXPIRED` rows, because it cannot tell "removed from the site" from "not reached". Run again with **Max items** `0` (or high enough to cover the whole scope) on a bounded scope such as a community, tag, user blog or search; `EXPIRED` rows then appear only for records a complete walk did not find.

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

If every page the run tried to read was refused, the run stops with a clear failure message instead of quietly shipping zero results, so "nothing new today" is never confused with "nothing could be read". Run it again in a few minutes. If only some pages were refused, you still get whatever was read successfully.

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

Yes. Call the actor from any Apify integration or MCP client, and use the **Send results into your apps** field to send a summary of each record into Notion, Linear or Airtable when the run finishes, up to **Max items to export per connector**.

### 🔗 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/ok-ru-scraper"><b>OK.ru Scraper</b></a><br>Scrape public OK.ru users, groups, topics, posts, videos, games and greetings by keyword...</td><td>🧩 <a href="https://apify.com/abotapi/dzen-ru-scraper"><b>Dzen.ru Scraper</b></a><br>Scrape Dzen.ru (ex Yandex.Zen): articles, videos and channels. Full article text with...</td></tr>
<tr><td>📱 <a href="https://apify.com/abotapi/wattpad-scraper"><b>Wattpad Scraper</b></a><br>Scrape Wattpad stories by keyword, tag, category, language or URL. Extract authors...</td><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></tr>
<tr><td>🧩 <a href="https://apify.com/abotapi/tiktok-comments-scraper"><b>TikTok Comments Scraper</b></a><br>Scrape comments from TikTok videos using one or more video URLs or IDs. Extract comment...</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>
</table>

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

### 💬 Support

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

# Actor input Schema

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

Search runs keyword search. Feed walks hot/new/best feeds, communities, tags or user blogs. Story reads full detail (text, media, comments) for pasted story links. Profile reads creator headers plus their stories.

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

Search mode: keyword or phrase (Russian or English). Leave empty with Order set to walk the whole site feed.

## `searchOrder` (type: `string`):

Search mode: result ordering on the site's own search.

## `searchUrl` (type: `string`):

Paste a pikabu.ru search results URL, for example https://pikabu.ru/search?q=iphone\&st=3, and it is scraped as a feed link (the st sort and page parameters are kept). When set it replaces Mode, Search query and Order. Leave empty to use the fields above.

## `feedLinks` (type: `array`):

Pikabu home/new/best feeds (optionally ?page=N), tags (with /hot|/new|/best), communities, user blogs, search result URLs (q, n, st, page), story links (including m.pikabu.ru) or bare story IDs. Feed and Story modes accept links from either link field; listings are paginated and individual stories receive full detail. Leave the field untouched to scrape one example per shape.

## `storyUrls` (type: `array`):

Pikabu story links or bare numeric story IDs. Feed and Story modes also accept listing links here. Duplicate stories are collected once.

## `profileUrls` (type: `array`):

Profile mode: pikabu.ru/@name links or bare account names. Each entry returns one profile record with stats and recent stories.

## `fetchDetails` (type: `boolean`):

Feed and search modes: open every collected story for its full text, media and tags. Each successfully returned detailed story has one enrichment event. With Collect comments enabled, additional comment enrichment events use round(returned comments / 10) per story. Off returns cards only.

## `fetchComments` (type: `boolean`):

Collect comments of each opened story as separate records, including author, text, rating, media and parent comment. Every returned comment has the result-item charge. Additional enrichment events per story equal round(returned comments / 10), on top of its story-detail event. For example, 11 returned comments add one enrichment event. Exact halves round to the nearest even integer; suppressed comments are excluded.

## `maxCommentsPerStory` (type: `integer`):

Maximum comment records to return per story; Default 100; 0 is accepted and means the hard cap of 10000 comments per story. Max items still applies. Comment enrichment charges use round(actual returned comments / 10) per story, not this limit. Exact halves round to the nearest even integer.

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

Stop after this many records (0 = no limit; the run then stops when listings run out). Comments count towards this cap too.

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

Connection settings for collecting public Pikabu pages. Use the Console connection editor to configure your run.

## `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, UPDATED and REAPPEARED records. Turn on Emit unchanged or Emit expired only when you also want those rows returned (and billed).

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

Optional. Name this monitoring campaign to keep its state stable, or deliberately share state across differently configured runs. Leave empty to let the actor derive a key automatically from the mode and scope 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.

## `emitExpired` (type: `boolean`):

Off by default. Turn on to also return records that were present in a previous run but are no longer found, marked EXPIRED (each is reported once and counts toward Max items; one that comes back is marked REAPPEARED). Only produced once a run has fully scanned the tracked scope.

## `ignoreFieldsForChanges` (type: `array`):

Field names that must not mark a record as UPDATED, for example author or tags. Rating, comment count, pluses, minuses, views and subscribers (including the author's subscriber count and avatar) are always ignored for change detection but still returned. The author is compared on id, name and profile link, the community on name and link. Only used with incremental mode.

## `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.

## Actor input object example

```json
{
  "mode": "search",
  "searchQuery": "steam",
  "searchOrder": "relevance",
  "feedLinks": [
    "https://pikabu.ru/",
    "https://pikabu.ru/?page=2",
    "https://pikabu.ru/new",
    "https://pikabu.ru/best",
    "https://pikabu.ru/tag/steam",
    "https://pikabu.ru/tag/steam/hot?page=2",
    "https://pikabu.ru/community/gamedev",
    "https://pikabu.ru/@admin",
    "https://pikabu.ru/story/_14366779",
    "https://m.pikabu.ru/story/_14366779",
    "https://pikabu.ru/search?q=steam",
    "https://pikabu.ru/search?q=steam&n=3&page=2"
  ],
  "storyUrls": [
    "https://pikabu.ru/story/_14366779",
    "https://m.pikabu.ru/story/_14461062"
  ],
  "profileUrls": [
    "https://pikabu.ru/@admin"
  ],
  "fetchDetails": true,
  "fetchComments": true,
  "maxCommentsPerStory": 100,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}
```

# Actor output Schema

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

No description

## `stories` (type: `string`):

No description

## `comments` (type: `string`):

No description

## `profiles` (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": "steam",
    "searchOrder": "relevance",
    "feedLinks": [
        "https://pikabu.ru/",
        "https://pikabu.ru/?page=2",
        "https://pikabu.ru/new",
        "https://pikabu.ru/best",
        "https://pikabu.ru/tag/steam",
        "https://pikabu.ru/tag/steam/hot?page=2",
        "https://pikabu.ru/community/gamedev",
        "https://pikabu.ru/@admin",
        "https://pikabu.ru/story/_14366779",
        "https://m.pikabu.ru/story/_14366779",
        "https://pikabu.ru/search?q=steam",
        "https://pikabu.ru/search?q=steam&n=3&page=2"
    ],
    "storyUrls": [
        "https://pikabu.ru/story/_14366779",
        "https://m.pikabu.ru/story/_14461062"
    ],
    "profileUrls": [
        "https://pikabu.ru/@admin"
    ],
    "fetchDetails": true,
    "fetchComments": true,
    "maxCommentsPerStory": 100,
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    },
    "incrementalMode": false,
    "emitUnchanged": false,
    "emitExpired": false,
    "ignoreFieldsForChanges": [],
    "maxNotifyListings": 50
};

// Run the Actor and wait for it to finish
const run = await client.actor("abotapi/pikabu-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": "steam",
    "searchOrder": "relevance",
    "feedLinks": [
        "https://pikabu.ru/",
        "https://pikabu.ru/?page=2",
        "https://pikabu.ru/new",
        "https://pikabu.ru/best",
        "https://pikabu.ru/tag/steam",
        "https://pikabu.ru/tag/steam/hot?page=2",
        "https://pikabu.ru/community/gamedev",
        "https://pikabu.ru/@admin",
        "https://pikabu.ru/story/_14366779",
        "https://m.pikabu.ru/story/_14366779",
        "https://pikabu.ru/search?q=steam",
        "https://pikabu.ru/search?q=steam&n=3&page=2",
    ],
    "storyUrls": [
        "https://pikabu.ru/story/_14366779",
        "https://m.pikabu.ru/story/_14461062",
    ],
    "profileUrls": ["https://pikabu.ru/@admin"],
    "fetchDetails": True,
    "fetchComments": True,
    "maxCommentsPerStory": 100,
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": True },
    "incrementalMode": False,
    "emitUnchanged": False,
    "emitExpired": False,
    "ignoreFieldsForChanges": [],
    "maxNotifyListings": 50,
}

# Run the Actor and wait for it to finish
run = client.actor("abotapi/pikabu-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": "steam",
  "searchOrder": "relevance",
  "feedLinks": [
    "https://pikabu.ru/",
    "https://pikabu.ru/?page=2",
    "https://pikabu.ru/new",
    "https://pikabu.ru/best",
    "https://pikabu.ru/tag/steam",
    "https://pikabu.ru/tag/steam/hot?page=2",
    "https://pikabu.ru/community/gamedev",
    "https://pikabu.ru/@admin",
    "https://pikabu.ru/story/_14366779",
    "https://m.pikabu.ru/story/_14366779",
    "https://pikabu.ru/search?q=steam",
    "https://pikabu.ru/search?q=steam&n=3&page=2"
  ],
  "storyUrls": [
    "https://pikabu.ru/story/_14366779",
    "https://m.pikabu.ru/story/_14461062"
  ],
  "profileUrls": [
    "https://pikabu.ru/@admin"
  ],
  "fetchDetails": true,
  "fetchComments": true,
  "maxCommentsPerStory": 100,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "incrementalMode": false,
  "emitUnchanged": false,
  "emitExpired": false,
  "ignoreFieldsForChanges": [],
  "maxNotifyListings": 50
}' |
apify call abotapi/pikabu-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,abotapi/pikabu-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/xYzmCOYky4p9MNLnS/builds/72Sc15kvhpffyvFP3/openapi.json