# Patreon Scraper – Profiles, Tiers & Posts | $1.50/1K (`bovi/patreon-scraper`) Actor

Scrape creator profiles and public posts from Patreon. Get campaign and post records. Run with creator or post URLs, or a search query; no login or API key required. Pricing: $0.0015 per dataset item and $0.00005 per Actor Start on Free.

- **URL**: https://apify.com/bovi/patreon-scraper.md
- **Developed by:** [Vitalii Bondarev](https://apify.com/bovi) (community)
- **Categories:** Other, MCP servers
- **Features:** Limited permissions
- **Stats:** 25 total users, 7 monthly users, 91.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.45 / 1,000 items

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

## Patreon Scraper for Creator Profiles and Posts

Scrape Patreon creator profiles, tiers, patron data, earnings estimates, and public posts with media from Patreon's public JSON:API; no Patreon login, API key, or proxy is required. Use creator, posts, search, or postByUrl modes to extract structured records for research, outreach, and content analysis.

- Compare public patron counts, tier prices, and conservative monthly estimates across creators.
- Catalog public posts with access flags, engagement counts, previews, and normalized media URLs.
- Find Patreon creators by keyword for creator-economy research and outreach.
- Inspect parse confidence, warnings, and the source used for each record.
- Run the Actor with only your Apify account; Patreon credentials are not required.

### What you get

| Field family | Fields | What it contains |
|---|---|---|
| Record identity | `record_type`, `campaign_id`, `creator_name`, `vanity`, `url` | Identifies campaign, post, or search-result records and creator URLs. |
| Creator profile | `creation_name`, `summary`, `one_liner`, `avatar_url`, `cover_url`, `pledge_url` | Campaign description, tagline, profile assets, and checkout URL. |
| Audience and earnings | `patron_count`, `paid_member_count`, `est_monthly_cents`, `creation_count` | Public patron data, paid-member data, post count, and a conservative estimate based on paid members multiplied by the cheapest paid tier. |
| Tiers | `tier_count`, `tiers`, `min_tier_cents`, `max_tier_cents` | Published tiers, titles, descriptions, USD amounts, images, shipping flags, and price points. |
| Campaign metadata | `created_at`, `published_at`, `is_monthly`, `is_nsfw`, `currency` | Campaign dates, billing type, adult-content flag, and currency. |
| Social data | `social_links` | Connected social accounts when available. |
| Post identity | `post_id`, `title`, `post_type`, `published_at_post`, `edited_at`, `post_url` | Post identifiers, titles, types, dates, and Patreon links. |
| Post access and text | `is_public`, `is_paid`, `teaser_text`, `content_text` | Public/paywalled status, free preview, and HTML-stripped public text. |
| Engagement | `like_count`, `comment_count` | Post engagement counts. |
| Media | `media` | Normalized `kind`, `image_url`, `thumbnail_url`, `video_url`, `video_duration_sec`, `embed_url`, `embed_provider`, and `embed_title`. |
| Quality and provenance | `parse_confidence`, `warnings`, `data_source`, `scraped_at` | Completeness score, warnings, `json_api` or `ssr_fallback`, and scrape timestamp. |

Creator mode returns campaign records. Posts and post-by-URL modes return post records. Search mode returns `search_result` records with creator name, vanity, URL, avatar, public patron count, NSFW flag, summary, and creation name.

### Sample output

The sample below is shortened by omitting fields not needed to show the core campaign result, including the full `tiers` array. Retained values are copied exactly from a successful dataset record.

```json
{
  "record_type": "campaign",
  "creator_name": "CGP Grey",
  "vanity": "cgpgrey",
  "url": "https://www.patreon.com/cgpgrey",
  "patron_count": null,
  "paid_member_count": null,
  "tier_count": 6,
  "min_tier_cents": 300,
  "max_tier_cents": 10000,
  "est_monthly_cents": null,
  "creation_count": 257,
  "is_monthly": true,
  "is_nsfw": false,
  "currency": "USD",
  "parse_confidence": 0.95,
  "warnings": ["patron_count_private"],
  "data_source": "json_api",
  "scraped_at": "2026-11-08T04:31:40.804881+00:00"
}
```

### Pricing

The live billing model is pay-per-event. `apify-default-dataset-item` represents one Patreon creator or post record. `apify-actor-start` is charged when the Actor starts; the number of start events depends on Actor memory, with at least one event charged.

| Plan | `apify-actor-start` | `apify-default-dataset-item` |
|---|---:|---:|
| Free | $0.00005 per event (Free) | $0.0015 per event (Free) |
| Silver | $0.000049 per event (Silver) | $0.00147 per event (Silver) |
| Gold | $0.0000485 per event (Gold) | $0.001455 per event (Gold) |
| Platinum | $0.000048 per event (Platinum) | $0.00144 per event (Platinum) |
| Diamond | $0.0000475 per event (Diamond) | $0.001425 per event (Diamond) |

At Free-plan prices, 1,000 `apify-actor-start` events cost $0.05 and 10,000 cost $0.50; 1,000 `apify-default-dataset-item` events cost $1.50 and 10,000 cost $15.

Failed lookups and skipped items are not charged as dataset-item results. The event names `patreon-earnings-record` and `patreon-item` have no price, so the buyer is not charged for them.

For example, **3333 results = $4.99955 on Free**, assuming one Actor Start event: $4.9995 for 3333 dataset items plus $0.00005 for the start. The supplied Free-plan calculation gives **3333 results** after one start event against the $5 credit, before considering any other run conditions.

The Apify Free plan includes **$5 of monthly platform usage credit**. This Actor uses pay-per-event pricing with platform usage paid by the Actor developer, so separately billed platform usage does not apply to the buyer for this pricing setup.

### How to use

1. **Choose** `creator`, `posts`, `search`, or `postByUrl`.
2. **Add** creator URLs or vanity names for creator and posts mode, post URLs or numeric IDs for post-by-URL mode, or a keyword for search mode.
3. **Set** `maxItems` to limit post or search results; in posts mode, the limit applies per creator.
4. **Run** the Actor with your Apify account; normal runs do not require Patreon login, an API key, or a proxy.
5. **Review** access flags, media, `parse_confidence`, `warnings`, and `data_source`.
6. **Repeat** the run through Apify Schedules, using daily as a starting point for creator or post listings.

Example input:

```json
{
  "mode": "posts",
  "creatorUrls": ["darknetdiaries"],
  "maxItems": 50
}
```

Export the Apify dataset as JSON or CSV, or read it through the Apify dataset API.

### Input parameters

| Parameter | What it does | Default |
|---|---|---|
| `mode` | Selects `creator`, `posts`, `search`, or `postByUrl`. | `creator` |
| `creatorUrls` | Patreon creator URLs or vanity names for `creator` and `posts`; `postByUrl` can use it when `postUrls` is absent. | Not set |
| `postUrls` | Patreon post URLs or numeric post IDs for `postByUrl`. | Not set |
| `searchQuery` | Keyword for `search` mode. | Not set |
| `maxItems` | Maximum records returned; in `posts` mode, maximum per creator. The schema accepts 1–50000. | `100` |
| `proxyConfiguration` | Optionally enables Apify Proxy for very high volume or rate-limit warnings. | `{"useApifyProxy": false}` |
| `disableUsageStats` | Disables the usage statistics described below when `true`. | `false` |

### Limits and edge cases

| Condition | What you see | What to do |
|---|---|---|
| A creator keeps earnings private | `patron_count` and `paid_member_count` can be `null`; `warnings` can include `patron_count_private`. This affects approximately 25% of creators according to the Actor’s probe findings. | Treat missing counts as private rather than zero. |
| Public member data or a paid tier is unavailable | `est_monthly_cents` is `null`. When present, it is `paid_member_count × cheapest paid tier`, a conservative floor rather than exact revenue. | Use the estimate only when both inputs are available. |
| A creator has a free tier | `min_tier_cents` represents the cheapest paid tier; `max_tier_cents` represents the most expensive published tier. | Use `tiers` to inspect free and paid offerings separately. |
| A post is paywalled | `is_paid` can be `true`, `is_public` can be `false`, and locked body content is not returned. Public title, type, media preview, and engagement fields can still be available. | Filter on `is_paid` or `is_public` before using `content_text`. |
| A post does not expose enough access indicators | `is_public` can be `null` when the available API fields do not allow an inference. | Check `is_paid`, `warnings`, and returned text. |
| No creator URLs are supplied in `creator` or `posts` mode | No creator or post records are returned and the run reports that no creator URLs were provided. | Supply at least one Patreon URL or vanity name. |
| No query is supplied in `search` mode | No search records are returned and the run reports that no search query was provided. | Add a non-empty `searchQuery`. |
| A post URL or ID cannot be resolved | `postByUrl` returns no post record for that input. | Use a Patreon post link or numeric post ID. |
| Both campaign lookup paths fail | The creator or related post listing produces no record for that target. | Check the Patreon URL or vanity name and try again. |
| A run reaches high request volume or rate limits | The normal no-proxy path can produce rate-limit warnings. | Enable the optional Apify Proxy configuration. |

Published tiers come from the available Patreon data; unpublished tiers and the special system placeholder tier are excluded. Posts are paginated 20 at a time, and `maxItems` controls how many post records are requested per creator.

### FAQ

#### How much does it cost to scrape Patreon creator profiles and posts?

The dataset-item event costs $0.0015 per result on Free, $0.00147 on Silver, $0.001455 on Gold, $0.00144 on Platinum, and $0.001425 on Diamond. The Actor Start event costs $0.00005 on Free, $0.000049 on Silver, $0.0000485 on Gold, $0.000048 on Platinum, and $0.0000475 on Diamond. For example, 3333 results = $4.99955 on Free assuming one start event.

#### Why did the Actor return an empty result?

This can happen when a required mode-specific input is missing, a creator or post cannot be resolved, a search has no returned matches, or both campaign lookup paths fail. Check the mode and matching input field.

#### Why is a run not working without a proxy?

Normal runs use Patreon's public JSON:API without a proxy. If a high-volume run produces rate-limit warnings, enable the optional Apify Proxy configuration and review the run logs and `warnings` fields.

#### Can I extract paid Patreon post content?

No. The Actor returns publicly accessible post text only. Paywalled posts are marked with `is_paid` or `is_public` when determinable, while locked body content is not scraped.

#### Is it legal to use data from Patreon?

The Actor uses public data from Patreon's JSON:API and the public creator-page fallback, without authentication. Whether a particular use is allowed depends on Patreon's source terms and applicable law for your use case; review those requirements before processing or publishing the data.

### Related actors

- [Company Lookup – B2B Firmographic Enrichment](https://apify.com/bovi/company-lookup-scraper) — related for company and firmographic enrichment.
- [DoorDash Menu Scraper — Prices, Calories & Items](https://apify.com/bovi/doordash-scraper) — related for structured menu, price, calorie, and item data.
- [MercadoLibre Scraper - Products, Prices & Sellers](https://apify.com/bovi/mercadolibre-scraper) — related for product, price, and seller market data.

### Usage statistics

This Actor creates a small, content-free summary at the end of each run, used only to monitor reliability and improve this Actor. No input values, credentials or scraped data are sent.

A copy of the exact record for your run is saved as `USAGE_STATS` in your own Apify key-value store.

To opt out, set `disableUsageStats` to `true` in the input. Nothing is sent then.

[Full list of collected fields](https://api.apify.com/v2/key-value-stores/v9rgHjMKLDGtHf8tD/records/index.html)

# Actor input Schema

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

What to scrape. 'creator' fetches campaign info + tiers + earnings estimate for one or more Patreon creators. 'posts' fetches the public post list (with media URLs) for a creator's campaign. 'search' finds creators by keyword. 'postByUrl' fetches a single post by its URL or ID.

## `creatorUrls` (type: `array`):

Patreon creator page URLs or vanity names. Used in 'creator' and 'posts' modes. Accepts full URLs (https://www.patreon.com/cgpgrey) or bare vanity names (cgpgrey). Each item produces one campaign record ('creator' mode) or a batch of post records ('posts' mode).

## `postUrls` (type: `array`):

Patreon post URLs or numeric post IDs. Used in 'postByUrl' mode only. Example: https://www.patreon.com/posts/some-title-141115192. Each item produces one post record with full media details.

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

Keyword to search Patreon for creators. Used in 'search' mode only. Example: 'true crime podcast' returns matching campaign pages ranked by Patreon's own relevance algorithm.

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

Maximum number of records to return. In 'creator' mode: max campaigns fetched per vanity/URL. In 'posts' mode: max posts fetched per creator (Patreon paginates 20 at a time). In 'search' mode: max search results returned. Keep low (20–100) for quick agent lookups; raise to 500+ for bulk exports.

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

Optional Apify Proxy. Leave OFF — the actor reaches Patreon's JSON:API directly with browser TLS impersonation and needs no proxy for normal runs. Enable Apify Proxy (RESIDENTIAL group) only if you push very high volume and start seeing rate-limit (HTTP 429) warnings; the actor then rotates the exit IP automatically on retry. The buyer's Apify account is billed for any proxy usage.

## `disableUsageStats` (type: `boolean`):

See the README Usage statistics section for details.

## Actor input object example

```json
{
  "mode": "creator",
  "creatorUrls": [
    "https://www.patreon.com/cgpgrey"
  ],
  "searchQuery": "true crime podcast",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "disableUsageStats": false
}
```

# Actor output Schema

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

Dataset containing Patreon Scraper records (record_type, creator_name, title, patron_count, paid_member_count, tier_count, est_monthly_cents, is_nsfw, like_count, comment_count, url, parse_confidence).

# 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": "creator",
    "creatorUrls": [
        "https://www.patreon.com/cgpgrey"
    ],
    "searchQuery": "true crime podcast",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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 = {
    "mode": "creator",
    "creatorUrls": ["https://www.patreon.com/cgpgrey"],
    "searchQuery": "true crime podcast",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("bovi/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 '{
  "mode": "creator",
  "creatorUrls": [
    "https://www.patreon.com/cgpgrey"
  ],
  "searchQuery": "true crime podcast",
  "maxItems": 100
}' |
apify call bovi/patreon-scraper --silent --output-dataset

```

## MCP server setup

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