# Patreon Scraper (`automation-lab/patreon-public-creator-content`) Actor

Export public Patreon creator profiles, membership tiers, and visible public posts for creator-market research; locked and member-only content is excluded.

- **URL**: https://apify.com/automation-lab/patreon-public-creator-content.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.71 / 1,000 item extracteds

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?

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

Export public Patreon creator profiles, membership-tier metadata, and visible public post records for creator-market research.
The Actor uses Patreon’s public structured data, returns normalized JSON, and deliberately excludes locked, paid, and member-only posts.

### What does Patreon Scraper do?

Give the Actor one or more Patreon creator URLs or vanity names.
For each creator it can export:

- one public creator/campaign profile;
- public membership tiers, prices, benefit descriptions, and limits;
- visible public posts with titles, public text, dates, engagement counts, media references, and URLs.

All rows include a `recordType` value (`creator`, `tier`, or `post`) so spreadsheets and data pipelines can separate them reliably.
The Actor never logs in, purchases a membership, or attempts to reveal locked content.

### Who is it for?

- **Creator-economy analysts** comparing public positioning and tier structures.
- **Market researchers** building repeatable creator and content snapshots.
- **Agencies** reviewing public publishing cadence and engagement signals.
- **Data teams** feeding public Patreon records into warehouses or BI tools.
- **Developers** who need structured Patreon data without maintaining extraction infrastructure.

This Actor is designed for supplied creators.
It does not search all of Patreon or discover creators by keyword.

### Why use this Actor?

Patreon pages combine several entity types and access levels.
This Actor normalizes the supported public data into stable row types and applies one access rule consistently: only posts visible to an anonymous visitor with a zero-cent access threshold are emitted.

Other practical features include:

- pagination over visible posts;
- limits per creator and per run;
- duplicate creator removal;
- coherent proxy sessions and bounded retries;
- pay-per-result charging only for saved rows;
- JSON, CSV, Excel, XML, RSS, and API dataset exports through Apify.

### What Patreon data can I extract?

| Record type | Selected fields |
| --- | --- |
| Creator | campaign ID, vanity, display names, summary, public description, avatar, cover, currency, creation type, NSFW flag, social links, source URL |
| Tier | tier ID, title, public benefit description, amount in cents, currency, remaining availability, user limit, shipping flag, tier URL |
| Post | post ID, title, public content, teaser, post type, publish/edit time, likes, comments, image/embed URL, source URL |

Some Patreon creators hide individual profile metrics.
Fields unavailable in the public response are returned as `null`; they are not guessed.

### Getting started

1. Open the Actor input page.
2. Add one to 20 Patreon creator URLs or vanity names.
3. Choose whether to include creator, tier, and/or public-post rows.
4. Set a public-post limit per creator.
5. Click **Start**.
6. Open the default dataset to preview or download the results.

The prefilled `kurzgesagt` input is a small real-world example.

### Input parameters

| Field | Type | Default | Meaning |
| --- | --- | --- | --- |
| `creators` | string array | Kurzgesagt URL | One to 20 Patreon creator URLs or vanity names |
| `includeCreator` | boolean | `true` | Save one creator profile row per creator |
| `includeTiers` | boolean | `true` | Save public membership-tier rows |
| `includePosts` | boolean | `true` | Save only anonymously visible public posts |
| `maxPostsPerCreator` | integer | `20` | Maximum public post rows per creator, 0–1,000 |
| `maxItems` | integer | `500` | Global cap across all row types, 1–5,000 |

At least one output type must be enabled.
Creator entries may look like `kurzgesagt` or `https://www.patreon.com/c/kurzgesagt`.
Non-Patreon URLs and unsupported page shapes fail with a clear input error.

### Example input: public posts

```json
{
  "creators": ["https://www.patreon.com/c/kurzgesagt"],
  "includeCreator": false,
  "includeTiers": false,
  "includePosts": true,
  "maxPostsPerCreator": 10,
  "maxItems": 10
}
```

### Example input: profile and tiers

```json
{
  "creators": ["kurzgesagt"],
  "includeCreator": true,
  "includeTiers": true,
  "includePosts": false,
  "maxPostsPerCreator": 0,
  "maxItems": 20
}
```

### Output example

A public post row looks like this:

```json
{
  "recordType": "post",
  "creatorVanity": "Kurzgesagt",
  "campaignId": "73401",
  "sourceUrl": "https://www.patreon.com/Kurzgesagt/posts/new-video-us-in-165740172",
  "scrapedAt": "2026-08-27T06:00:00.000Z",
  "postId": "165740172",
  "title": "NEW VIDEO: The Impenetrable Barrier Trapping Us in the Solar System",
  "content": "After exploring most of Earth...",
  "teaserText": null,
  "postType": "video_embed",
  "publishedAt": "2026-08-04T14:00:21.000+00:00",
  "editedAt": "2026-08-04T14:00:21.000+00:00",
  "likeCount": 150,
  "commentCount": 10,
  "imageUrl": "https://www.patreon.com/media-u/v3/711474305",
  "embedUrl": "https://youtu.be/Cyl3X88KEgg",
  "isPublic": true
}
```

Values change at the source.
The example demonstrates the shape, not a freshness guarantee.

### Working with mixed record types

The default dataset intentionally keeps all value-producing rows together for simple Apify integrations.
Filter on `recordType` when you need a single entity:

- `recordType=creator` for campaign/profile snapshots;
- `recordType=tier` for pricing and membership analysis;
- `recordType=post` for public publishing analysis.

The dataset’s `overview` view presents the most useful cross-type columns.
Full JSON exports retain every field.

### How much does it cost to scrape public Patreon records?

The Actor uses pay-per-event pricing: one small start event per run plus one `item` event for each saved creator, tier, or public-post row.
The six subscription tiers have decreasing item prices.
Your Apify Console shows the active tier and exact estimate before a run.

At the BRONZE rate of **$0.001188 per saved row** plus a **$0.005 start**, illustrative totals are:

| Saved rows | Approximate price |
| ---: | ---: |
| 10 | $0.0169 |
| 100 | $0.1238 |
| 1,000 | $1.193 |

No item event is charged for a locked post, duplicate creator, rejected record, or failed fetch because no dataset row is produced.
Infrastructure usage is covered by the Actor price rather than billed as a separate record type.

### Recurring monitoring workflow

Create an Apify Schedule with a stable creator list and output settings.
Send each completed dataset to your warehouse, Google Sheets, webhook, or automation platform.
Use `campaignId`, `tierId`, and `postId` as source identifiers when comparing snapshots.

A downstream workflow can:

1. identify newly observed public post IDs;
2. compare public tier prices and descriptions;
3. detect creator profile text changes;
4. calculate public posting cadence;
5. preserve an auditable observation timestamp in `scrapedAt`.

The Actor records snapshots; it does not send alerts or perform historical diffing itself.

### Export and integrations

From the dataset page you can download JSON, CSV, Excel, XML, HTML, or RSS.
You can also connect runs to:

- Google Sheets;
- Make;
- Zapier;
- Slack or email webhooks;
- Amazon S3 and other storage integrations;
- a custom ETL job through the Apify API.

For large recurring workflows, consume the dataset API using stable source IDs rather than relying on row order.

### API usage with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~patreon-public-creator-content/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"creators":["kurzgesagt"],"maxPostsPerCreator":10,"maxItems":20}'
```

Use `run-sync-get-dataset-items` when a small synchronous response is appropriate.
For longer runs, start asynchronously and poll the returned run ID.

### API usage with JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/patreon-public-creator-content').call({
  creators: ['kurzgesagt'],
  includeCreator: true,
  includeTiers: true,
  includePosts: true,
  maxPostsPerCreator: 20,
  maxItems: 50,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/patreon-public-creator-content').call(run_input={
    'creators': ['https://www.patreon.com/c/kurzgesagt'],
    'maxPostsPerCreator': 20,
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use Patreon Scraper with MCP

#### Claude Code

Add the Actor to Claude Code through Apify MCP:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/patreon-public-creator-content"
```

#### Claude Desktop, Cursor, and VS Code

Claude Desktop, Cursor, and VS Code can use this HTTP MCP configuration (place it in the client’s MCP settings):

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/patreon-public-creator-content"
    }
  }
}
```

Example prompts:

- “Export the latest 20 public posts from the Kurzgesagt Patreon.”
- “Get the public membership tiers and prices for this Patreon creator.”
- “Run a profile, tier, and public-post snapshot for these three creator URLs.”

### Limits and expected behavior

- Patreon can change its public API and anti-bot behavior.
- The Actor uses US residential proxy access automatically; users do not need to configure a proxy field.
- Upstream requests use a coherent session and retry transient blocks up to three times.
- A creator that does not exist fails the run instead of returning a misleading empty result.
- Only supplied creators are supported; keyword/category discovery is not included.
- `maxItems` may stop a creator partway through its tiers or posts.
- Public posts can be sparse because locked and paid rows are intentionally removed.
- Public counts and fields may be hidden by the creator or Patreon and therefore be `null`.
- Media URLs are references only; the Actor does not download files.

### Locked and member-only content

This product is not a paywall bypass.
It checks Patreon's anonymous visibility indicators and excludes a post unless it is currently viewable, has a zero-cent pledge threshold, and is not marked paid.
It never accepts cookies, account credentials, membership tokens, or payment details.
Do not use it to seek content you are not authorized to access.

### Responsible use and legality

Public availability does not remove every legal obligation.
Use the Actor for lawful purposes, follow applicable privacy and database rules, respect intellectual-property rights, and comply with Patreon’s terms and your organization’s policies.
Avoid republishing creator text or media without permission.
Collect only fields needed for a legitimate workflow and apply appropriate retention controls.

You are responsible for the input you submit and how you use the output.

### Troubleshooting

#### The run reports that Patreon denied a request

A residential session can occasionally receive an upstream block.
The Actor retries transient responses automatically.
If all attempts fail, wait before retrying and check the run log for the creator that failed.
Do not repeatedly launch identical runs during a Patreon incident.

#### A creator returns fewer public posts than expected

Patreon may list posts that require a paid or free membership.
Those rows are outside this Actor’s public-only scope and are excluded.
Increase `maxPostsPerCreator` only when the creator has more anonymously visible posts.

#### The creator URL is rejected

Use a public Patreon creator page such as `https://www.patreon.com/c/kurzgesagt` or submit only the vanity name.
Post URLs, checkout URLs, non-Patreon domains, and numeric user-query URLs are not creator inputs.

#### Why are some fields null?

The public source does not expose every metric for every campaign, tier, or post.
The Actor preserves `null` rather than inventing a value.

### Frequently asked questions

#### Does the Actor require a Patreon account?

No.
It uses only data visible through anonymous public Patreon surfaces.

#### Can it download attachments or videos?

No.
It exports public metadata and available media/embed references, not the media files themselves.

#### Can it reveal locked Patreon posts?

No.
Locked, paid, and member-only posts are excluded by design.

#### Can it scrape many creators?

Yes, up to 20 supplied creators per run and 5,000 total rows.
Use several bounded runs when you need larger controlled batches.

#### Can I schedule it?

Yes.
Apify Schedules are well suited to recurring public creator snapshots.

#### What identifies a row across runs?

Use `campaignId` for creators, `tierId` for tiers, and `postId` for posts.
`sourceUrl` provides the corresponding public source link.

### Related Automation Lab actors

For adjacent public creator research, consider:

- [OnlyFans Public Profile and Post Preview Scraper](https://apify.com/automation-lab/onlyfans-public-profile-post-preview-scraper) for anonymous public OnlyFans profile and preview metadata.
- [X Public Profile Metadata Scraper](https://apify.com/automation-lab/x-public-profile-metadata) for public X profile and post-sample research.
- [Tumblr Tagged Posts Scraper](https://apify.com/automation-lab/tumblr-tagged-posts-scraper) for public Tumblr topic feeds.

Choose this Actor when Patreon creator profiles, tiers, and anonymously visible posts are the source of record.

# Actor input Schema

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

One to 20 public Patreon creator URLs or vanity names, for example https://www.patreon.com/c/kurzgesagt or kurzgesagt.

## `includeCreator` (type: `boolean`):

Add one normalized public creator profile record per supplied creator.

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

Add public membership-tier price and benefit metadata.

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

Add visible public post records. Locked, paid, and member-only posts are excluded.

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

Maximum visible public posts to save for each creator after access filtering.

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

Global cap across creator, tier, and public-post records.

## Actor input object example

```json
{
  "creators": [
    "https://www.patreon.com/c/kurzgesagt"
  ],
  "includeCreator": true,
  "includeTiers": true,
  "includePosts": true,
  "maxPostsPerCreator": 20,
  "maxItems": 20
}
```

# Actor output Schema

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

Open the default dataset overview containing creator, tier, and public-post rows.

# 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://www.patreon.com/c/kurzgesagt"
    ],
    "maxPostsPerCreator": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/patreon-public-creator-content").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://www.patreon.com/c/kurzgesagt"],
    "maxPostsPerCreator": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/patreon-public-creator-content").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://www.patreon.com/c/kurzgesagt"
  ],
  "maxPostsPerCreator": 20,
  "maxItems": 20
}' |
apify call automation-lab/patreon-public-creator-content --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/patreon-public-creator-content"
        }
    }
}

```

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/DsGynvbm1EVql0dVL/builds/C2s2VY2BMs0nA2gVk/openapi.json