# Boosty Scraper (`sashaebashu/boosty-scraper`) Actor

Read any Boosty creator: subscriber count, every subscription tier with its real price, funding goals and progress, publishing cadence, engagement per post and how much sits behind the paywall — plus alerts when a creator raises prices, goes quiet or disappears.

- **URL**: https://apify.com/sashaebashu/boosty-scraper.md
- **Developed by:** [Sasha Ebashu](https://apify.com/sashaebashu) (community)
- **Categories:** Social media, Automation, Videos
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $20.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

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

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

# README

## Boosty Scraper — Creators, Subscribers & Tier Prices

Boosty is where a large part of the Russian-speaking creator economy actually earns. This Actor
reads any public Boosty creator: **how many followers they have, what every subscription tier
costs, what their funding goals are, how often they post, how much engagement each post gets, and
how much of their output sits behind the paywall** — then tells you when any of that moves.

Public API, no key, no login.

### What you get per creator

| | |
|---|---|
| **Audience** | Follower count, total posts, showcase items |
| **Pricing** | Every tier with its price in the creator's own currency *and* USD/EUR/RUB, what the tier promises, which tiers unlock the Discord role or private Telegram, plus hidden and limited flags |
| **Live discounts** | Which tiers are running a promo right now, how deep, until when — and **how many people have taken it** |
| **Goals** | Open funding goals with current, target and progress percent |
| **Output** | Posts in the last 30/90 days, days since the last post, dormant flag |
| **Engagement** | Average reactions, comments and total engagement per post, and every reaction type broken out |
| **Paywall mix** | How many posts are free versus gated, and which tier gates each one |
| **Comments** | On free posts: author, text, date, replies and reactions, plus who comments most |
| **Content** | On free posts: the full post text, plus images, videos, audio and outbound links |
| **Reach** | Linked Instagram, Telegram, YouTube, VK, Twitch, TikTok, X, plus the Discord server behind the paid tiers |

For a **paid** post only metadata is read: its body is not served to anonymous callers and is never
requested, so you get the title, the date, the engagement and the tier that gates it. For a **free**
post you also get the text and the media the creator published.

### The one hard number about money on this platform

Every subscription discount carries `count.activation` — **how many people actually took it**. One
creator in the sample runs four promos at 10–25% off with **71 activations between them**. That is
not an estimate and not a follower count: those are people who paid at a named price.

Treat it as a **floor**, and only that. Activations accumulate over the life of the promo, so some
of those people may since have cancelled, and subscribers who joined at full price are not counted
at all. The Actor reports the activations and the discounted price and stops there; multiplying
them is your call, not a number it will invent for you.

### Two things this refuses to guess

**No revenue estimate.** Boosty publishes *followers*, not paying subscribers. Multiplying
followers by a tier price would produce a confident-looking number that is wrong by an unknown
factor. You get the real inputs — follower count, every tier price, goal progress — and you decide.

**"Likes" is not what it says.** Boosty's `likes` counter is, in fact, the ❤️ reaction: it matched
`reactions.heart` in all 180 posts sampled across six blogs, while the real 👍 lives in
`reactions.like` and is usually the larger number. Reporting it as "likes" would understate a
creator badly — one blog in the sample averages **0.77 hearts and 14.8 total engagement**. So the
field is called `hearts`, and `avgEngagement` (all reactions + comments) is the headline number.

### Comments, and what the paywall hides

Comment threads are public **on free posts only** — the thread of a paid post answers HTTP 403 to
anonymous callers, even though that post's own title, date and engagement are public. So comments
are requested only for free posts that actually have any, which also means a creator whose output
is entirely paid costs no extra requests at all. `commentsLockedPosts` says how many threads were
behind the paywall, so an empty comment list is never mistaken for a silent audience.

### Media links, and which of them actually work

Handing over a link that 403s is worse than handing over none, so all three kinds were tested
rather than assumed:

| | Works for you? |
|---|---|
| **Images** (`images.boosty.to`) | **Yes** — unsigned and durable, opens for anyone |
| **Video watch page** (`ok.ru/video/<id>`) and its preview image | **Yes** — durable, opens for anyone |
| **Video stream** (`streamUrl`) | **Only from the machine that scraped it.** OK.ru signs these with an `expires` timestamp *and* the requesting IP, so it works during the run and not afterwards from your desk. Flagged `streamUrlIsSigned`. |
| **Audio** (`cdn.boosty.to`) | **No** — 403 to anonymous callers with or without Referer/Origin. The URL is an identifier, not a download, and is flagged `urlNeedsSession`. Title, artist, duration, size and format are all still there. |

### Monitor mode

Run it on a schedule against the creators you follow, compete with, or sponsor.

| `changeType` | Means |
|---|---|
| **`tier_change`** | A tier's price moved, or a tier was added or removed — `tierPriceChanges` spells out each one, in the creator's own currency |
| **`promo_change`** | A discount started or ended — the list price does not move, so this would otherwise pass as unchanged |
| `new_posts` | They published since the last run — **`newPosts` lists which ones**, with title, link, date and the tier that gates each |
| `went_quiet` | The run where they crossed your dormancy threshold — announced once, not repeated every run |
| `subscribers_up` / `subscribers_down` | Audience moved, with `subscribersDelta` |
| `goal_progress` | A funding goal moved or changed |
| **`no_longer_available`** | Boosty no longer serves the blog — deleted, renamed or blocked |
| `new`, `unchanged` | First sighting / nothing moved |

A creator that 404s but was **never** in your baseline is reported as a probable typo, not as news.
The disappearance alert only fires for a creator that was really there before.

Two different numbers describe new output, deliberately. `newPostsSinceLastRun` is the change in
the creator's own post counter — it can read zero when they delete one post and publish another.
`newPosts` is the list actually observed, matched by publish date against the last run, and is the
one to trust. If every post read was newer than the baseline the creator may have published more
than your post limit could see, and `newPostsTruncated` says so instead of implying the list is
complete.

### Input

| Field | What it does |
|---|---|
| **Creators** | Profile URLs, post URLs or bare handles — `https://boosty.to/welovegames`, `welovegames`, `@welovegames` all work and de-duplicate. |
| **Include tiers / goals** | One extra request each per creator. Tiers bring the live discounts with them. |
| **Include comments / Comments per post** | Reads threads on free posts. Nothing is requested for posts with no comments or behind a paywall. |
| **Analyse posts / Posts per creator** | How far back to read. More posts means truer averages. |
| **Include the individual posts** | Adds every post read: title, date, reactions, comments, gating tier, media types, tags. |
| **Treat as dormant after** | Your definition of quiet, not a hidden constant. |
| **Monitor mode / Output only changes** | The alert behaviour above. |

### Notes & limits

Properties of the source, measured rather than assumed:

- **A tier's bare `price` field is EUR**, whatever the creator actually charges. One tier reads
  `price: 1.42` while the creator's own price is **130 ₽**. Every price here is reported with its
  currency, so nothing is quoted in a unit nobody named.
- **The USD and EUR figures are converted live and drift.** Two calls two seconds apart returned
  1.65 then 1.62 USD for a tier whose rouble price never moved. They are fine for comparing
  creators; they are useless for detecting change, so **monitor mode diffs the creator's own
  currency** and never the converted number. Otherwise almost every run would report a price
  change that never happened.
- **Post paging uses a cursor**, not a row number. An integer offset answers HTTP 400 on every
  page, which looks like a dead endpoint. The end of a blog is an **empty** page, never a short one.
- **Boosty's search and feed endpoints require a login** (HTTP 401), so this Actor works from
  creators you name rather than discovering them. Handles come from the creator's own links on
  YouTube, Telegram, Twitch and so on.
- **The 30- and 90-day post counts are left empty when the posts read do not span that window** —
  reporting "3 posts in 90 days" because only 20 posts were fetched would be an artefact of your
  own limit, not a fact about the creator. Raise the post limit to fill them in.
- **Comments on paid posts are not public** (HTTP 403) while the post metadata is. Requesting them
  anyway would burn one request per paywalled post and make every creator look "partial".
- **Comment reactions ship both `laugh` and `laught`** — the same reaction under two spellings.
  Summing the list blindly double-counts it.
- **Discovery is genuinely closed, checked three ways**: the search and feed endpoints answer 401,
  `oauth/token/` only issues tokens against a real account's refresh token, the search page is a
  client-side app with nothing in its HTML, and robots.txt disallows `*?searchQuery=*`. This Actor
  therefore works from creators you name.
- A blog that requires a login to view is reported as such, not silently dropped.
- **Load-tested at real scale**: 75 creators in 24 s at 4 parallel requests, 13 s at 8, 28 s with
  comments, 40 s reading 150 posts each — no throttling and no warnings from Boosty.
- The Actor honours your **Maximum cost per run** and stops when the cap is reached.

# Actor input Schema

## `creators` (type: `array`):

Boosty profile URLs or handles. Paste `https://boosty.to/welovegames`, a link to one of their posts, or just `welovegames`.

## `includeTiers` (type: `boolean`):

Every tier with its price in the creator's own currency plus USD, EUR and RUB, and what each tier promises. One extra request per creator.

## `includeGoals` (type: `boolean`):

Open goals with current and target amounts and progress. One extra request per creator.

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

Reads the comment thread of every post that has comments — author, text, date, replies and reactions — and works out who comments most. Only posts with comments are requested, so quiet blogs cost nothing extra.

## `maxCommentsPerPost` (type: `integer`):

Top comments to read per post, newest thread first. Only used when comments are on.

## `includePosts` (type: `boolean`):

Reads recent posts to work out publishing cadence, engagement, and how much of the output sits behind a paywall.

## `maxPostsPerCreator` (type: `integer`):

How far back to read. 30 posts per request. Larger numbers give truer averages and let the 30/90-day counts be filled in.

## `includePostList` (type: `boolean`):

Adds every analysed post to the output — title, date, likes, each reaction type, comments, which tier gates it and what media it holds. Off by default because it makes rows large.

## `dormantAfterDays` (type: `integer`):

Days without a post before a creator counts as dormant. Drives `isDormant` and the `went_quiet` alert.

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

Stop after this many creators.

## `maxConcurrency` (type: `integer`):

4 is comfortable and fast. Higher risks Boosty throttling you rather than finishing sooner.

## `monitorMode` (type: `boolean`):

Compare against the previous run of the same creators and label what changed: tier prices, new posts, subscriber movement, a creator going quiet.

## `onlyChanges` (type: `boolean`):

With monitor mode on, skip creators where nothing moved — an empty run then means nothing needs your attention. History is kept per creator, so editing the list or the limits does not reset it.

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

Optional. The Boosty API is reachable without a proxy from most regions; switch one on only if you get errors.

## Actor input object example

```json
{
  "creators": [
    "https://boosty.to/welovegames",
    "shawn101",
    "koshkamoroshka"
  ],
  "includeTiers": true,
  "includeGoals": true,
  "includeComments": false,
  "maxCommentsPerPost": 20,
  "includePosts": true,
  "maxPostsPerCreator": 50,
  "includePostList": false,
  "dormantAfterDays": 60,
  "maxItems": 100,
  "maxConcurrency": 4,
  "monitorMode": false,
  "onlyChanges": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

## `alerts` (type: `string`):

No description

## `pricing` (type: `string`):

No description

## `full` (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 = {
    "creators": [
        "https://boosty.to/welovegames",
        "shawn101",
        "koshkamoroshka"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("sashaebashu/boosty-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 = { "creators": [
        "https://boosty.to/welovegames",
        "shawn101",
        "koshkamoroshka",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("sashaebashu/boosty-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 '{
  "creators": [
    "https://boosty.to/welovegames",
    "shawn101",
    "koshkamoroshka"
  ]
}' |
apify call sashaebashu/boosty-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,sashaebashu/boosty-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/4fDBZtWbX9ip4NhnU/builds/gmllrYCtKPZUyaIOB/openapi.json