# Forendors Creator & Pricing Scraper (`huykenny/forendors-creator-pricing-scraper`) Actor

Extract public Forendors creator profiles, subscription prices, tiers, categories, and creator metadata. Built for creator research, pricing benchmarking, competitor monitoring, and creator economy analysis.

- **URL**: https://apify.com/huykenny/forendors-creator-pricing-scraper.md
- **Developed by:** [Kenny Ha](https://apify.com/huykenny) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Forendors Creator & Pricing Scraper

Extract public Forendors creator profiles, subscription prices, tiers, categories, and profile
metadata through a fast API-backed Apify Actor. **No browser automation required.**

[Forendors.cz](https://www.forendors.cz) is the Czech Patreon-style subscription platform for
podcasters, video creators and writers. This Actor talks directly to Forendors' public API, so
extracting a creator's pricing and profile data is a single call — no session handling, no HTML
parsing, no browser to maintain.

A creator record looks like this (real output from a live run):

```json
{
    "creatorHandle": "forendors",
    "creatorName": "Forendors",
    "profileUrl": "https://www.forendors.cz/forendors",
    "isVerified": true,
    "postCount": 5,
    "categories": ["Novinky", "Tipy"],
    "subscriptionTiers": [
        { "name": "Díky!", "price": 59, "currency": "CZK", "billingPeriod": "monthly" },
        { "name": "Díky díky!", "price": 173, "currency": "CZK", "billingPeriod": "monthly" },
        { "name": "Díky díky díky!", "price": 299, "currency": "CZK", "billingPeriod": "monthly" }
    ],
    "lowestPrice": 59,
    "highestPrice": 299,
    "currency": "CZK",
    "isTrending": false,
    "source": "handle"
}
```

### What does this Actor extract?

- Creator name, handle and profile URL
- Public bio/description
- Verification status
- Categories the creator posts under
- Subscription tiers, each with name, price, currency and billing period
- Lowest and highest public subscription price
- Total post count
- Whether the profile has a linked Discord server, RSS feed, or Spotify podcast
- Public discovery/trending status when available

### Use cases

#### Creator research

Build structured lists of Forendors creators — profile, verification, categories and tier
pricing — for research, reporting or internal databases.

#### Pricing benchmarking

Compare subscription pricing and tier structures across creators to see where a given price point
actually sits in the market.

#### Competitor monitoring

Track a specific set of creators over time. Schedule repeated runs and compare datasets to see
tier and pricing changes.

#### Agency and influencer research

Enrich creator research and outreach workflows with structured Forendors data instead of manually
checking profiles one by one.

#### Creator economy analysis

Analyze pricing and category positioning across public Czech creator profiles.

### How to use this Actor

1. Add the creator handles you want under **Creator handles** (e.g. `chumelenice`) — this is the
   main way to pick who gets scraped.
2. Optionally turn on **Include trending creators** to also pull in Forendors' small curated
   trending sample.
3. Optionally set price or activity filters.
4. Run the Actor. Each creator becomes one row in the dataset, ready to export as JSON, CSV or
   Excel.

### Important: direct handles are the primary input

**Forendors does not currently expose a complete public creator directory** through the endpoints
this Actor uses. There is no working search endpoint and no sitemap on forendors.cz (verified by
reverse-engineering its frontend — see `API-NOTES.md` for the full writeup). Because of that:

- **Direct handles are the recommended input.** If you know which creators you care about, list
  them under `handles`.
- **`includeTrending` only returns creators discoverable through Forendors' current public
  discovery/trending endpoints** — at most about 20-25 unique creators (homepage highlights,
  weekly picks, most-searched). It is a small free sample, not a complete Forendors database, and
  this Actor does not claim otherwise.

### Input

| Field                | Type     | Default | Description                                                                             |
| --------------------- | -------- | ------- | ----------------------------------------------------------------------------------------- |
| `handles`             | array    | –       | Recommended. Profile URLs or bare handles to scrape.                                      |
| `includeTrending`     | boolean  | `false` | Also scrape Forendors' curated trending sample (~20-25 creators max, additive with `handles`). |
| `verifiedOnly`        | boolean  | `false` | Only verified creators                                                                    |
| `minTierPriceCzk`     | integer  | –       | Keep creators with at least one active tier priced at or above this                       |
| `maxTierPriceCzk`     | integer  | –       | Keep creators with at least one active tier priced at or below this                       |
| `minPostCount`        | integer  | –       | Skip creators with fewer posts than this                                                  |
| `hasFreeTierOnly`     | boolean  | `false` | Only creators with a 0 CZK tier                                                           |
| `hasDiscordOnly`      | boolean  | `false` | Only creators with a linked Discord server                                                |
| `maxCreators`         | integer  | `200`   | `0` = no limit                                                                             |
| `maxItems`            | integer  | –       | Hard stop on dataset rows written                                                          |
| `requestDelayMs`      | integer  | `350`   | Delay between API calls                                                                    |
| `proxyConfiguration`  | object   | off     | Optional proxy                                                                             |

#### Example 1: single creator

```json
{ "handles": ["chumelenice"] }
```

#### Example 2: multiple creators

```json
{ "handles": ["chumelenice", "forendors"] }
```

#### Example 3: trending creators

```json
{ "includeTrending": true }
```

#### Example 4: handles + trending combined

```json
{ "handles": ["chumelenice"], "includeTrending": true }
```

### Output

One dataset row per creator (see the real example at the top of this README for the full field
list). The Apify Console ships a prepared **Creators** table view with the most useful columns
first (creator name, handle, price range, categories, trending status), and every dataset also
exports to JSON, CSV, Excel, XML or HTML.

### Important limitations

**Forendors does not currently expose a complete public creator directory** through the endpoints
used by this Actor — no working search, no sitemap, no browse-all-creators page. Direct handles
are therefore the recommended input, and `includeTrending` should not be treated as a complete
Forendors database; it returns only what Forendors' own public discovery/trending endpoints
currently expose (~20-25 creators).

**Follower count is not included** because the anonymous public API currently does not return a
reliable follower count — it always answers `0` regardless of a creator's real audience, confirmed
across multiple real profiles with visibly different follower counts on their own public pages.
Exposing that as a field would be worse than not having it at all, so this Actor leaves it out
entirely rather than publish a number that's always wrong.

**No revenue or subscriber estimates.** Public data can't support one — yearly-plan discounts,
gift codes and the platform's own cut are all invisible from the outside, and a guess printed next
to real numbers gets read as a real number.

**Tier prices are whole CZK**, not cents/haléře — verified against the amounts shown on live
profile pages. **`billingPeriod` is currently always `"monthly"`** — the API has fields for
quarterly/half-yearly/yearly pricing, but they were `null` on every profile tested; this Actor
does not fabricate values for them.

### Pricing (pay per event)

| Event            | Price   | When it fires                      |
| ---------------- | ------- | ----------------------------------- |
| `actor-start`    | $0.01   | Once per run                        |
| `creator-result` | $0.004  | Per creator written to the dataset  |

Charging happens **before** the write, so a run that hits your `maxTotalChargeUsd` budget stops
after delivering exactly what it charged for. A duplicate creator (e.g. requested both via
`handles` and returned by `includeTrending`) is only ever charged once. See `docs/MONETIZATION.md`
for worked cost examples (1 / 10 / 25 / 100 creators).

### FAQ

**Do I need a Forendors account?**
No. The Actor uses Forendors' public API only and never signs in.

**Can I get every creator on Forendors?**
Not through this Actor alone — there's no public directory or search on the platform (see
"Important limitations" above). Supply the handles you care about, or use `includeTrending` for
the small curated sample.

**Why is there no follower count field?**
The Forendors API itself returns `0` for anonymous requests regardless of a creator's real
audience — it's not something this Actor can see or compute, so it's left out rather than
published as a fake zero.

**How fresh is the data?**
Every run reads the Forendors API live. `scrapedAt` records the moment each row was captured.

**Can I export to CSV or Excel?**
Yes — every Apify dataset exports to JSON, CSV, Excel, XML and HTML.

### Disclaimer

This is an independent, community-built Actor and is not affiliated with, endorsed by, or
sponsored by Forendors. It processes publicly accessible data only. Users are responsible for
ensuring their use complies with applicable laws and Forendors' terms of service.

### Development

```bash
npm install
npm run start:dev     # runs against ./storage/key_value_stores/default/INPUT.json
npm test
npm run lint
npm run build
```

# Actor input Schema

## `handles` (type: `array`):

The recommended way to use this Actor: list the specific creators you want, as https://www.forendors.cz/<handle> or just the bare handle (e.g. "chumelenice"). Forendors.cz has no public search or full creator directory, so supplying handles is the only way to reliably get the creators you actually care about — see 'Include trending creators' below for the small curated sample the API exposes instead.

## `includeTrending` (type: `boolean`):

Also scrape creators currently discoverable through Forendors' own public trending/discovery endpoints (homepage highlights + weekly picks + most-searched) — at most about 20-25 unique creators total. This is NOT a complete crawl of all Forendors creators; Forendors currently exposes only this limited public discovery set. Useful on its own as a small free sample, or combined with your own handles above.

## `verifiedOnly` (type: `boolean`):

Keep only creators with the Forendors verified badge.

## `minTierPriceCzk` (type: `integer`):

Keep only creators with at least one active subscription tier priced at or above this amount.

## `maxTierPriceCzk` (type: `integer`):

Keep only creators with at least one active subscription tier priced at or below this amount.

## `minPostCount` (type: `integer`):

Skip creators with fewer posts than this — a rough activity filter.

## `hasFreeTierOnly` (type: `boolean`):

Keep only creators offering at least one 0 CZK tier.

## `hasDiscordOnly` (type: `boolean`):

Keep only creators with a linked Discord server.

## `maxCreators` (type: `integer`):

Stop after this many creators. 0 means no limit.

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

Hard stop on how many creators get written to the dataset. Leave empty for no limit.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between API calls. Lower is faster but less polite to the site — the API's own rate-limit header allows 500 requests per window.

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

Optional. The API answers fine from a datacenter IP even at moderate volume — a proxy just spreads out larger runs.

## Actor input object example

```json
{
  "handles": [
    "chumelenice"
  ],
  "includeTrending": false,
  "verifiedOnly": false,
  "hasFreeTierOnly": false,
  "hasDiscordOnly": false,
  "maxCreators": 200,
  "requestDelayMs": 350,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One row per creator: name, handle, profile URL, bio, categories, subscription tiers and CZK pricing, and whether the creator was found via a direct handle or Forendors' trending discovery.

## `summary` (type: `string`):

Counts of creators written, filtered-out creators, API requests made, and charged pay-per-event totals.

# 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 = {
    "handles": [
        "chumelenice"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("huykenny/forendors-creator-pricing-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 = { "handles": ["chumelenice"] }

# Run the Actor and wait for it to finish
run = client.actor("huykenny/forendors-creator-pricing-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 '{
  "handles": [
    "chumelenice"
  ]
}' |
apify call huykenny/forendors-creator-pricing-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,huykenny/forendors-creator-pricing-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/cMPIT9ZRExXRzO58Y/builds/0usWdTJOtxMHn0zKF/openapi.json