# Patreon Scraper — Creator Earnings, Tiers & Members (`khadinakbar/patreon-scraper`) Actor

Scrape public Patreon creators by username or URL: profile, membership tiers and prices, patron and paid-member counts, an estimated monthly earnings range, social links, and recent posts. Keyword creator search included. HTTP-only, MCP-ready, no login required.

- **URL**: https://apify.com/khadinakbar/patreon-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 creator scrapeds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Patreon Scraper

Patreon Scraper is an Apify Actor for public Patreon creator intelligence. It accepts creator usernames, @handles, creator URLs, or keyword search queries, and returns one record per creator plus optional post records. Each creator record can include the profile, membership tiers and prices, patron and paid-member counts, an estimated monthly earnings range, social links, and a plain-text summary. The Actor is usable through Apify MCP and produces flat dataset output that is easy to read in downstream automation.

### Best fit and connected workflows

This Actor fits workflows that start with a known Patreon creator or a topic search and need structured creator data for review.

Common routing patterns:

- Known creator lookup from a handle or creator URL.
- Keyword-based creator discovery for a niche, topic, or format.
- Creator profile enrichment with tiers, counts, and earnings estimates.
- Optional recent-post collection for engagement review and paywall status.
- Apify MCP workflows that need a stable, record-oriented Patreon data source.

### Practical scenario

A sponsorship researcher finds a Patreon creator on social media and wants a structured profile before outreach. They start with the creator's handle, then review the returned creator name, canonical URL, patron count, paid-member count, tier prices, and estimated monthly earnings range. If the profile is relevant, they can save the creator in a tracking sheet and rerun the Actor with `includePosts` enabled to review recent post titles, likes, comments, and paywall status.

### Input fields

| Field | Type | Purpose |
|---|---|---|
| `creators` | array | Creator usernames, @handles, or full Patreon creator URLs. Each item resolves to one creator-profile record. |
| `searchQueries` | array | Free-text keywords for creator discovery. Each query can return matching creators. |
| `includePosts` | boolean | When true, also scrape recent posts for each creator. |
| `maxPostsPerCreator` | integer | Upper bound on posts returned per creator when post scraping is enabled. |
| `maxSearchResults` | integer | Upper bound on creators returned for each search query. |
| `enrichSearchResults` | boolean | When true, search results are expanded into full creator profiles. |
| `maxResults` | integer | Hard cap on the total number of billable records across the run. |
| `sessionId` | string | Optional Patreon `session_id` cookie for post metadata you already have access to. |
| `proxyConfiguration` | object | Proxy settings. Apify Proxy is the default configuration. |

#### Focused JSON input example

```json
{
  "creators": [
    "TopoTraveler",
    "https://www.patreon.com/EconomicsExplained"
  ],
  "searchQueries": [
    "true crime podcast"
  ],
  "includePosts": true,
  "maxPostsPerCreator": 20,
  "maxSearchResults": 20,
  "enrichSearchResults": true,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output fields

| Field | Type | Purpose |
|---|---|---|
| `recordType` | string | Either `creator` or `post`. |
| `query` | string | The username, URL, or search query that produced the record. |
| `campaignId` | string | Patreon numeric campaign id. |
| `vanity` | string | Creator vanity handle. |
| `creatorName` | string | Creator display name. |
| `campaignName` | string | Campaign or creation name. |
| `url` | string | Canonical Patreon URL. |
| `summary` | string | Plain-text creator summary. |
| `isNsfw` | boolean | Creator content flag. |
| `isMonthly` | boolean | Indicates monthly billing. |
| `currency` | string | Currency code for tier and earnings values. |
| `patronCount` | integer | Total patrons, including free and paid members. |
| `paidMemberCount` | integer | Paying members. |
| `publishedAt` | string | Publish timestamp for the visible record. |
| `avatarUrl` | string | Creator avatar URL. |
| `tiers` | array | Membership tiers with title, monthlyPriceUsd, amountCents, isFree, and description. |
| `paidTierCount` | integer | Count of paid tiers. |
| `minTierUsd` | number | Lowest paid tier price. |
| `maxTierUsd` | number | Highest paid tier price. |
| `estimatedEarningsMinUsd` | number | Low end of the estimated monthly earnings range. |
| `estimatedEarningsMaxUsd` | number | High end of the estimated monthly earnings range. |
| `earningsEstimateBasis` | string | Explanation of how the estimate was derived. |
| `earningsVisibility` | string | Patreon earnings visibility value, usually `private`. |
| `reportedMonthlyEarningsUsd` | number | Publicly reported monthly earnings when available. |
| `youtubeUrl` | string | Linked YouTube profile URL. |
| `twitterUrl` | string | Linked X or Twitter profile URL. |
| `instagramUrl` | string | Linked Instagram profile URL. |
| `facebookUrl` | string | Linked Facebook profile URL. |
| `twitchUrl` | string | Linked Twitch profile URL. |
| `tiktokUrl` | string | Linked TikTok profile URL. |
| `discordUrl` | string | Linked Discord invite or profile URL. |
| `postCount` | integer | Total visible posts from search or profile results. |
| `creatorId` | string | Patreon numeric user id of the creator. |
| `partial` | boolean | True for lighter search cards. |
| `postId` | string | Post id for post records. |
| `title` | string | Post title. |
| `teaserText` | string | Post teaser text. |
| `postType` | string | Post type. |
| `likeCount` | integer | Like count. |
| `commentCount` | integer | Comment count. |
| `isPaid` | boolean | Whether the post requires a pledge to view. |
| `minPledgeUsdToView` | number | Minimum pledge to view the post. |
| `imageUrl` | string | Post image URL. |
| `scrapedAt` | string | ISO 8601 scrape timestamp. |

#### Focused JSON output example

```json
{
  "recordType": "creator",
  "query": "TopoTraveler",
  "campaignId": "12104065",
  "vanity": "TopoTraveler",
  "creatorName": "Topo Traveler",
  "campaignName": "The Official Patreon for Topo Traveler",
  "url": "https://www.patreon.com/TopoTraveler",
  "summary": "Public creator profile summary text",
  "patronCount": 209,
  "paidMemberCount": 104,
  "tiers": [
    {
      "title": "Casual Hiker",
      "monthlyPriceUsd": 5,
      "amountCents": 500,
      "isFree": false,
      "description": "Tier description"
    }
  ],
  "paidTierCount": 2,
  "minTierUsd": 5,
  "maxTierUsd": 10,
  "estimatedEarningsMinUsd": 520,
  "estimatedEarningsMaxUsd": 780,
  "earningsEstimateBasis": "paid_member_count x tier price range",
  "earningsVisibility": "private",
  "youtubeUrl": "https://youtube.com/channel/UCeagElDDKCx75ZJiICK-VNQ",
  "currency": "USD",
  "scrapedAt": "2026-06-17T00:00:00.000Z"
}
```

### How it works

The Actor uses Patreon's public HTTP endpoints and internal JSON:API data. Creator handles are resolved deterministically from page bootstrap data, including vanity to campaign-id resolution. Profile data, tiers, counts, search results, and recent posts are fetched from the public data sources exposed by Patreon. The default proxy configuration uses Apify Proxy with automatic datacenter selection.

### Pricing

This Actor uses Pay per event pricing, and Apify platform usage is billed separately according to your Apify plan and resource consumption. Event billing covers Actor start, creator records, and post records when post scraping is enabled. For current billing details, check the live Pricing tab on the Actor page.

A simple example in words: if a run returns one hundred creator records and no posts, the billing includes one Actor start event and one hundred creator-scraped events. If you enable recent posts, each returned post adds its own post-scraped event.

### Use with AI agents (MCP)

This Actor is usable through Apify MCP as a tool that returns Patreon creator and post records in a predictable dataset shape. The exact Actor identity is `khadinakbar/patreon-scraper`.

Tool description: fetch public Patreon creator profiles, creator discovery results, and optional recent posts as flat dataset rows that an agent can parse field by field.

> Find the Patreon creator profile for TopoTraveler, include recent posts, and return the tier prices, paid-member count, and estimated monthly earnings range.

Output interpretation is record-based: creator rows describe one public Patreon creator, while post rows describe individual public posts returned for that creator. `query` shows which username, URL, or search keyword produced the record. When search results are enriched, they use the same shape as creator lookups. Search and post limits in the input schema act as pagination controls, and `maxResults` keeps the total billable record count bounded. If you enable `includePosts`, each returned post adds a post-scraped event. For cost planning, use the record caps together with the live Pricing tab.

### Apify API example

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

const client = new ApifyClient({
  token: process.env.APIFY_TOKEN,
});

const run = await client.actor("khadinakbar/patreon-scraper").call({
  creators: ["TopoTraveler"],
  includePosts: true,
  maxPostsPerCreator: 5,
  maxResults: 50,
  proxyConfiguration: {
    useApifyProxy: true,
  },
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Best results and outcome guidance

Use `creators` when you already know the Patreon handle or URL. Use `searchQueries` when you are starting from a niche or topic and want creator discovery. Keep `includePosts` off when you only need creator-level intelligence, and enable it when recent engagement or paywall status matters. Set `enrichSearchResults` to true when you want search hits to behave like full creator profiles, or false when you want lighter discovery cards. Use `maxResults` as a run-wide cost cap, especially when combining creator input with search results and posts.

### Focused standalone workflow

This Actor is designed as a focused standalone workflow.

### Design note

I found that the dataset contract uses one flat record shape for both creator and post outputs, with `recordType` distinguishing them. That makes it practical to process the dataset in one pass while still separating creator-level and post-level fields.

### FAQ

**Can I start from a creator URL instead of a handle?**\
Yes. The `creators` field accepts usernames, `@handles`, and full creator URLs, including `/c/`, `/cw/`, and `user?u=` forms.

**Can I find creators from a topic keyword?**\
Yes. Use `searchQueries` for creator discovery, then optionally enrich the returned matches with full profile data.

**What happens if I only want creator data and no posts?**\
Leave `includePosts` set to false. You will get one creator record per requested creator or enriched search result.

**Can I read paid or exclusive post metadata?**\
Yes, when you supply your own Patreon `session_id` cookie in `sessionId`. Public profiles, tiers, counts, and earnings data work without it.

**Which output fields are most useful for routing leads?**\
`creatorName`, `url`, `patronCount`, `paidMemberCount`, `minTierUsd`, `maxTierUsd`, `estimatedEarningsMinUsd`, and `estimatedEarningsMaxUsd` are the main fields for creator review and prioritization.

### Responsible use

Use this Actor for public Patreon creator data and for post metadata you are authorized to access. Respect creator rights, Patreon terms, and applicable laws when storing or analyzing the results. The output reflects public profile data and derived estimates unless a creator has chosen to publish earnings directly.

# Actor input Schema

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

Patreon creators to scrape, each as a username, @handle, or full creator URL (e.g. 'TopoTraveler', '@TopoTraveler', or 'https://www.patreon.com/TopoTraveler'). The /c/, /cw/ and user?u= URL forms are also accepted. Each resolves to one creator-profile record. Leave empty if you only want keyword search; this is NOT a post URL.

## `searchQueries` (type: `array`):

Free-text keywords to discover Patreon creators (e.g. 'rock climbing podcast'). Each query returns up to maxSearchResults matching creators. Use this to find creators when you do not already know their handle; for a known creator use the 'creators' field instead. Optional.

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

When true, also scrape each creator's most recent posts (title, type, publish date, like and comment counts, paywall status). Adds one post-scraped charge per post returned. Applies to creators from both 'creators' and search results. Defaults to false.

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

Upper bound on posts returned per creator when includePosts is true (e.g. 20). Posts are returned newest-first. Set to 0 to disable posts even if includePosts is true. Defaults to 20; max 500.

## `maxSearchResults` (type: `integer`):

Upper bound on creators returned per search query (e.g. 20). Only applies to 'searchQueries'. Each result is a creator record. Defaults to 20; max 200.

## `enrichSearchResults` (type: `boolean`):

When true, each search hit is enriched with a full profile fetch (tiers, paid-member count, earnings estimate, socials) — same shape as the 'creators' output. When false, search returns the lighter card data only (name, patron count, URL, avatar) and runs cheaper. Defaults to true.

## `maxResults` (type: `integer`):

Hard safety cap on the TOTAL number of billable records (creators + posts) pushed across the whole run, regardless of inputs (e.g. 1000). Stops the run cleanly when reached so cost stays predictable. Defaults to 1000; max 100000.

## `sessionId` (type: `string`):

Optional Patreon 'session\_id' cookie value from a logged-in account, used only to read exclusive/paid post metadata you already have access to. Leave blank for public data (default). Can also be supplied via the PATREON\_SESSION\_ID environment variable. Never required; public profiles, tiers, counts and earnings work without it.

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

Proxy settings. Defaults to Apify Proxy (automatic datacenter selection), which works against Patreon and is available on every plan. If your account has the Residential group you may add it for extra resilience, but it is not required.

## Actor input object example

```json
{
  "creators": [
    "TopoTraveler",
    "https://www.patreon.com/EconomicsExplained"
  ],
  "searchQueries": [
    "true crime podcast",
    "indie game dev"
  ],
  "includePosts": false,
  "maxPostsPerCreator": 20,
  "maxSearchResults": 20,
  "enrichSearchResults": true,
  "maxResults": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Default dataset with one record per creator and (optionally) per post.

## `state` (type: `string`):

STATE key in the default key-value store: pushed count and emitted ids for this run.

# 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": [
        "TopoTraveler"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/patreon-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": ["TopoTraveler"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/patreon-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": [
    "TopoTraveler"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call khadinakbar/patreon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/patreon-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/j9aP7rGuxxBsZstvh/builds/tBDnYujVX4w7qVzc1/openapi.json