# Patreon Scraper (`api-empire/patreon-scraper`) Actor

Patreon Scraper helps you collect public creator information from Patreon without manual work. Capture tier pricing, descriptions, and creator metadata for research, insights, and trend analysis across niches.

- **URL**: https://apify.com/api-empire/patreon-scraper.md
- **Developed by:** [API Empire](https://apify.com/api-empire) (community)
- **Categories:** Automation, Lead generation, Developer tools
- **Stats:** 4 total users, 0 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$19.99/month + usage

To use this Actor, you pay a monthly rental fee to the developer. The rent is subtracted from your prepaid usage every month after the free trial period.You also pay for the Apify platform usage, which gets cheaper the higher Apify subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#rental-actors

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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

A robust Apify Actor for scraping Patreon profiles, campaigns, and creator information. Extract detailed data including tiers, social media links, member counts, earnings, and more.

### Why Choose Us?

- **Comprehensive Data Extraction**: Get complete profile information including tiers, social links, member statistics, and earnings
- **Smart Proxy Management**: Automatic fallback from no proxy → datacenter → residential with intelligent retry logic
- **Bulk Processing**: Support for multiple keywords and direct profile URLs
- **Real-time Data Saving**: Data is saved to the output table immediately as each profile is scraped
- **Live Progress Tracking**: Real-time logs show work process and data collection results with detailed information
- **Reliable & Robust**: Built with error handling and retry mechanisms

### Key Features

- ✅ Search Patreon by keywords
- ✅ Scrape individual profiles by username/URL
- ✅ Extract tier information with pricing
- ✅ Get social media connections (Instagram, Twitter, etc.)
- ✅ Retrieve member statistics and earnings
- ✅ Automatic proxy fallback on blocks
- ✅ Real-time data saving to dataset
- ✅ Live progress updates with detailed profile information

### Input

#### JSON Example

```json
{
  "startUrls": [
    "python",
    "web development",
    "https://www.patreon.com/username",
    "username"
  ],
  "maxData": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
````

#### Input Fields

- **startUrls** (required): Array of strings containing Patreon profile URLs, usernames, or search keywords
  - **URLs**: `https://www.patreon.com/username`
  - **Usernames**: `username` (just the username without URL)
  - **Keywords**: `python`, `web development`, `art`, etc. (for searching Patreon)
- **maxData** (optional): Maximum number of profiles to scrape per keyword/query (default: 100, max: 1000)
- **proxyConfiguration** (required in practice): Proxy settings.
  Patreon is fronted by Cloudflare and blocks both datacenter IPs *and* most shared residential pools by IP reputation. To actually get results you need an IP source Cloudflare hasn't blacklisted. Pick one:

  - **Recommended — bring your own residential proxy.** In the Apify proxy editor pick "Custom proxies" and paste your provider URL(s). Example for Evomi:
    ```json
    "proxyConfiguration": {
      "useApifyProxy": false,
      "proxyUrls": ["http://USER:PASS@core-residential.evomi.com:1000"]
    }
    ```
    The actor will pin to your proxy and not auto-fall-back away from it.
  - **Apify RESIDENTIAL** (default prefill). Works in some regions, often blocked by Cloudflare on the `patreon.com/api/search` endpoint. If you must use it, add a country code to narrow the pool:
    ```json
    "proxyConfiguration": {
      "useApifyProxy": true,
      "apifyProxyGroups": ["RESIDENTIAL"],
      "apifyProxyCountry": "US"
    }
    ```
  - **No proxy** (`useApifyProxy: false`, no `proxyUrls`). The actor starts unproxied and, on the first 403/429/503, automatically escalates Apify datacenter → Apify residential. Most runs from the Apify cloud will land on residential within a few seconds.

  Cloudflare is bypassed via Chrome TLS impersonation (`curl_cffi` with `impersonate=chrome131`) on every request, so the only remaining variable is your IP reputation.

### Output

#### Output Format

Data is saved to the Apify dataset in **real-time** as each profile is scraped. You can monitor progress through the logs which show:

```
💾 Saved: username | Name: Campaign Name | Patrons: 1257 | Tiers: 4 (1/100 successful)
```

#### Output Fields

Each scraped profile includes:

- **url**: Patreon profile URL
- **id**: Campaign ID (format: `campaign_XXXXX`)
- **type**: Always `campaign-document`
- **name**: Campaign name
- **creator\_name**: Creator's full name
- **patron\_count**: Number of patrons
- **total\_posts**: Total number of posts
- **is\_nsfw**: NSFW flag (0 or 1)
- **tiers**: Array of membership tiers with:
  - `id`: Tier ID
  - `name`: Tier name
  - `price`: Price in USD
  - `description`: Tier description (HTML cleaned)
  - `discord_access`: Boolean indicating Discord access
- **instagram**: Instagram profile URL (if available)
- **twitter**: Twitter profile URL (if available)
- **youtube**: YouTube channel URL (if available)
- **facebook**: Facebook page URL (if available)
- **twitch**: Twitch channel URL (if available)
- **tiktok**: TikTok profile URL (if available)
- **about**: Campaign description (HTML cleaned)
- **total\_members**: Total member count
- **paid\_members**: Paid member count
- **post\_count**: Total number of posts
- **earnings\_per\_month**: Estimated monthly earnings in USD
- **avatar\_photo\_url**: Profile avatar image URL
- **avatar\_photo\_blurred\_url**: Blurred avatar image URL
- **thumb**: Thumbnail image URL
- **primary\_theme\_color**: Primary theme color (integer)
- **creation\_name**: Description of what the creator is creating
- **query**: Search query used (if applicable, or "direct" for direct URLs)
- **username**: Patreon username
- **success**: Boolean indicating successful scrape

### 🚀 How to Use the Actor (via Apify Console)

1. Log in at https://console.apify.com and go to **Actors**
2. Find your actor (patreon-scraper) and click it
3. Configure inputs:
   - Add URLs/keywords in the `startUrls` field (as a list of strings)
   - Set `maxData` if needed (default: 100, max: 1000)
   - Configure proxy settings if required (default: no proxy)
4. Run the actor
5. Monitor logs in real time - you'll see:
   - Search progress for each query
   - Profiles found per page
   - Real-time saves with profile details (name, patrons, tiers)
   - Progress updates every 10 profiles
6. Access results in the **OUTPUT** tab (data appears as it's scraped)
7. Export results to JSON or CSV

### Real-Time Logging

The actor provides detailed real-time logs showing:

- **Search Progress**: Shows which query is being processed and how many profiles found
- **Page Results**: Displays profiles found per search page
- **Data Collection**: Each saved profile shows:
  - Username
  - Campaign name
  - Patron count
  - Number of tiers
  - Success counter
- **Progress Updates**: Every 10 profiles, shows overall progress
- **Completion Summary**: Final count of successfully scraped profiles

Example log output:

```
🔍 Searching Patreon for query: 'python' (target: 100 profiles)
📊 Page 1: Found 20 new profiles (total: 20)
📊 Page 2: Found 20 new profiles (total: 40)
✅ Search complete: Found 100 unique profiles for query 'python'
📥 Scraping 100 profiles...
💾 Saved: username1 | Name: Campaign Name | Patrons: 1257 | Tiers: 4 (1/100 successful)
💾 Saved: username2 | Name: Another Campaign | Patrons: 543 | Tiers: 3 (2/100 successful)
📊 Progress: 10/100 profiles processed (10 successful)
```

### Best Use Cases

- **Market Research**: Analyze Patreon creators in specific niches
- **Competitor Analysis**: Track competitor campaigns and pricing strategies
- **Creator Discovery**: Find creators by keywords or topics
- **Data Aggregation**: Collect structured data for analysis
- **Tier Analysis**: Compare membership tiers and pricing strategies
- **Social Media Research**: Extract social media connections from creators
- **Earnings Analysis**: Analyze estimated monthly earnings

### Frequently Asked Questions

**Q: Can I scrape private profiles?**\
A: No, this actor only scrapes publicly available information from Patreon profiles.

**Q: How many profiles can I scrape?**\
A: The `maxData` parameter limits profiles per keyword (max 1000). There's no overall limit, but be mindful of rate limiting.

**Q: What happens if Patreon blocks my requests?**\
A: The actor automatically falls back to datacenter proxy, then residential proxy with 3 retries. Proxy fallback happens silently in the background.

**Q: Can I scrape specific profiles directly?**\
A: Yes, provide the profile URL (`https://www.patreon.com/username`) or just the username (`username`) in the `startUrls` field.

**Q: How long does scraping take?**\
A: Depends on the number of profiles. The actor processes profiles asynchronously for better performance. You'll see results appearing in real-time.

**Q: When will I see results?**\
A: Results are saved to the dataset immediately as each profile is scraped. You can see them in the OUTPUT tab in real-time.

**Q: What format are the results in?**\
A: Results are saved as JSON objects in the Apify dataset. You can export them as JSON or CSV.

### Support and Feedback

💬 For custom solutions or feature requests, contact us at **dev.scraperengine@gmail.com**

For issues or questions, please contact support through the Apify platform.

### Cautions

- Data is collected only from **publicly available sources**
- No data is taken from private accounts or password-protected content
- The end user is responsible for ensuring legal compliance (spam laws, privacy, data protection, etc.)
- Respect Patreon's Terms of Service and rate limits
- Use responsibly and in accordance with Patreon's robots.txt and terms of use

# Actor input Schema

## `startUrls` (type: `array`):

📝 List of Patreon profile URLs (e.g., https://www.patreon.com/username), usernames (e.g., username), or search keywords (e.g., python, web development).

## `maxData` (type: `integer`):

🔢 Maximum number of profiles to scrape per keyword/query (default: 20).

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

Apify proxy groups and custom proxy URL (when section is expanded).

## Actor input object example

```json
{
  "startUrls": [
    "python",
    "web development"
  ],
  "maxData": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "startUrls": [
        "python",
        "web development"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("api-empire/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 = {
    "startUrls": [
        "python",
        "web development",
    ],
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("api-empire/patreon-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "startUrls": [
    "python",
    "web development"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call api-empire/patreon-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=api-empire/patreon-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Patreon Scraper",
        "description": "Patreon Scraper helps you collect public creator information from Patreon without manual work. Capture tier pricing, descriptions, and creator metadata for research, insights, and trend analysis across niches.",
        "version": "0.1",
        "x-build-id": "khGt9h27gRI2d458c"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/api-empire~patreon-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-api-empire-patreon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/api-empire~patreon-scraper/runs": {
            "post": {
                "operationId": "runs-sync-api-empire-patreon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/api-empire~patreon-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-api-empire-patreon-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "startUrls"
                ],
                "properties": {
                    "startUrls": {
                        "title": "🔗 Patreon URLs, Usernames, or Keywords",
                        "type": "array",
                        "description": "📝 List of Patreon profile URLs (e.g., https://www.patreon.com/username), usernames (e.g., username), or search keywords (e.g., python, web development).",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxData": {
                        "title": "📊 Maximum Profiles per Keyword",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "🔢 Maximum number of profiles to scrape per keyword/query (default: 20).",
                        "default": 10
                    },
                    "proxyConfiguration": {
                        "title": "🌐 Proxy settings",
                        "type": "object",
                        "description": "Apify proxy groups and custom proxy URL (when section is expanded)."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```