# Fansly Profile Scraper (`sentry/fansly-profile-scraper`) Actor

Scrape full Fansly profile data for any list of usernames — follower counts, subscription pricing, content stats, and verified Instagram, Twitter & TikTok contacts. Paste in your list and get clean, structured data ready to export instantly.

- **URL**: https://apify.com/sentry/fansly-profile-scraper.md
- **Developed by:** [Sentry](https://apify.com/sentry) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 31 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$25.00/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

## Fansly Profile Scraper

Scrape full Fansly profile data for any list of usernames in seconds. Paste in your list and get complete, structured creator data — follower counts, subscription pricing, content stats, and verified Instagram, Twitter/X, and TikTok contact links — ready to export to CSV, Google Sheets, or your CRM.

The go-to tool when you already know which Fansly creators you want data on and need it fast.

---

### What It Does

Provide a list of Fansly usernames and the scraper fetches the complete profile data for each one. No searching, no discovery, no keyword guessing — just direct, targeted data extraction. Every username you provide comes back with a full data payload: audience size, content volume, subscription pricing, and all linked social media contacts.

#### How It Fits Into a Fansly Data Pipeline

| Stage | Tool |
|---|---|
| **Discover** creators by keyword or niche | Fansly Creator Discovery Scraper |
| **Generate** model leads for agency outreach | Fansly Model Leads Scraper |
| **Enrich** a known list of usernames with full data | **Fansly Profile Scraper** (this one) |

Use the discovery tools to build your username list, then run them through this scraper to get — or refresh — the complete data for each profile.

---

### Key Features

- 📋 **List-based input** — paste any number of usernames using the bulk editor; no searching required
- 📱 **Verified social contacts** — Instagram, Twitter/X, and TikTok handles with direct clickable links per profile
- 👥 **Full audience data** — follower counts, media likes, and engagement signals
- 💰 **Subscription pricing** — complete tier breakdown with monthly prices, promo prices, and plan benefits
- 📊 **Content volume** — image, video, and bundle counts so you know how active each creator is
- 🔄 **Auto-deduplication** — duplicate usernames in your input list are removed automatically
- 📦 **Bulk enrichment** — hundreds of profiles per run, batched for efficiency
- 📤 **Export-ready output** — flat fields that import cleanly to Google Sheets, Airtable, HubSpot, or any CRM

---

### Who Is This For?

- **Model agencies and talent managers** who have a target list and need full profile data before outreach
- **Recruiters** who sourced Fansly usernames manually or via other tools and need contact + audience enrichment
- **Developers** building CRMs, dashboards, or automation tools on top of Fansly creator data
- **Data analysts** maintaining a Fansly creator database who need to refresh stats on a schedule
- **Marketers** validating a shortlist of Fansly influencers before a sponsorship or brand campaign
- **Researchers** auditing a batch of Fansly profiles for pricing, content activity, or social reach
- **Solo managers** running outreach on a curated list who need Instagram and TikTok links fast

---

### Use Cases

#### Bulk Fansly Profile Data Extraction
Have a list of 50–500 Fansly usernames from your own research, a spreadsheet, or another data source? Paste them in and get the full profile payload for every username in one run — followers, content counts, pricing tiers, bio, location, and all linked social accounts.

#### Fansly Creator Database Enrichment
Maintain a Fansly creator database in Airtable, Notion, Google Sheets, or a custom CRM? Use this scraper to bulk-populate records with current Fansly data. Run it on a schedule to keep follower counts, pricing, and content stats up to date automatically.

#### Fansly Social Media Contact Extraction
Have Fansly usernames but need their Instagram and TikTok handles for outreach? This scraper pulls every linked social account — Instagram, Twitter/X, and TikTok — with direct profile links. Export the Social Links view for a clean, ready-to-use contact sheet.

#### Subscription Pricing Research
Paste a list of Fansly creator usernames to pull their current subscription pricing in bulk. See the full tier breakdown — base prices, promo rates, and plan benefits — across all profiles at once. Useful for pricing benchmarks, competitive analysis, and identifying underpriced creators.

#### Content Activity Audit
Check image counts, video counts, bundle counts, and last active timestamps across a batch of Fansly profiles to identify high-output creators, surface inactive accounts, and prioritize your outreach list before spending time on DMs.

#### Fansly Profile Data Refresh
Already have a creator list from a previous run? Re-run it through this scraper to pull fresh data. Fansly creators change their pricing, post new content, and gain followers regularly — a periodic refresh keeps your data accurate without re-running a full discovery.

#### Multi-Platform Creator Lookup
Many Fansly creators are also active on OnlyFans, Instagram, TikTok, and Twitter/X. Their Fansly profiles link to these accounts — use this scraper to bulk-extract all off-platform contact info for any list of Fansly usernames, whether the original source was Fansly or not.

---

### Input

| Field | Type | Description |
|---|---|---|
| **Fansly Usernames** | Array | List of Fansly usernames to scrape *(required)* |
| **Proxy Configuration** | Object | Proxy settings — rotating residential proxies recommended |

---

### Output

Each scraped Fansly profile contains:

| Field | Description |
|---|---|
| `username` | Fansly username |
| `displayName` | Display name |
| `bio` | Full profile bio |
| `profileUrl` | Direct Fansly profile link |
| `avatarUrl` | Profile picture URL |
| `bannerUrl` | Banner image URL |
| `followers` | Total follower count |
| `mediaLikes` | Total media likes |
| `postLikes` | Total post likes |
| `imageCount` | Number of images posted |
| `videoCount` | Number of videos posted |
| `bundleCount` | Number of content bundles |
| `totalContent` | Total content count |
| `lowestMonthlyPrice` | Cheapest monthly subscription in USD |
| `freeSubscription` | Whether a free tier exists |
| `subscriptionTiers` | Full tier breakdown with names, prices, promo prices, benefits |
| `isStreamingEnabled` | Whether live streaming is active |
| `instagramHandle` / `instagramUrl` | Instagram username and direct link |
| `twitterHandle` / `twitterUrl` | Twitter/X username and direct link |
| `tiktokHandle` / `tiktokUrl` | TikTok username and direct link |
| `categories` | Content categories on their profile |
| `location` | Listed location |
| `joinedAt` | Account creation date |
| `lastSeenAt` | Last active timestamp |
| `accountId` | Fansly internal account ID |

---

### Output Views

Three built-in table views in the Apify console:

- **Overview** — Core profile data: avatar, name, followers, pricing, content counts, location
- **Social Links** — All social handles and clickable Instagram, Twitter, and TikTok contact links in one focused view
- **Stats & Pricing** — Full content stats, subscription tiers, engagement metrics, and activity dates

---

### Tips for Getting the Most Out of This Scraper

**Use the bulk editor for large lists.** Click the bulk edit button in the Usernames field to paste a newline-separated list of hundreds of usernames at once — no need to enter them one by one.

**Don't include the @ symbol.** Enter usernames only (e.g. `ashlee_lou_xx`, not `@ashlee_lou_xx`). The scraper strips @ symbols automatically if included.

**Deduplicate your source list first.** The scraper auto-deduplicates, but starting clean avoids confusion. If merging lists from multiple sources, deduplicate on `accountId` in your output for the cleanest dataset.

**Pair with the discovery scrapers for a complete pipeline.** Run the Fansly Creator Discovery Scraper or Fansly Model Leads Scraper to generate a username list by keyword, then feed that list into this scraper to re-pull fresh data at any time — without re-running the full discovery.

**Schedule it for automatic data refreshes.** Use Apify's built-in scheduling to re-run this scraper weekly or monthly on your saved username list. Fansly creator pricing, follower counts, and content stats change regularly — a periodic refresh keeps your database current.

**Export the Social Links view for outreach.** When all you need is Instagram, Twitter, and TikTok contacts, use the Social Links dataset view. It gives you a focused table of usernames and direct social links — perfect for importing into an outreach tool or CRM.

---

### Frequently Asked Questions

**How do I enter a large list of usernames?**
Use the bulk edit button in the Usernames input field. It opens a text editor where you can paste a newline-separated list of as many usernames as you need in one go.

**Can I include @ symbols in the username list?**
Yes — the scraper automatically strips @ symbols from any username in your list, so `@ashlee_lou_xx` and `ashlee_lou_xx` both work.

**What happens if a username doesn't exist or has been deactivated?**
The scraper silently skips any username that returns no data. Only active, publicly accessible Fansly profiles appear in the output.

**Can I use this to get Instagram and TikTok contacts for Fansly creators?**
Yes — every profile in the output includes `instagramHandle`, `instagramUrl`, `twitterHandle`, `twitterUrl`, `tiktokHandle`, and `tiktokUrl` where those accounts are linked. Use the Social Links view for a clean contact-focused export.

**How is this different from the Fansly Creator Discovery Scraper?**
The discovery scraper finds creators by keyword — you give it a search term and it finds matching profiles. This scraper does the opposite: you give it usernames and it fetches data for exactly those profiles. Use discovery to build your list, then use this scraper to enrich or refresh it.

**Can I export to Google Sheets or a CRM?**
Yes — results export to CSV, JSON, or Excel from the Apify dataset. All output fields are flat and import cleanly to Google Sheets, Airtable, HubSpot, Notion, or any spreadsheet or CRM tool.

**Can I run this on a schedule?**
Yes — use Apify's built-in scheduling to run the scraper automatically on a recurring basis. Useful for keeping a creator database refreshed with current stats, pricing, and social links.

**How many profiles can I scrape per run?**
As many as you provide. There's no built-in limit — the scraper processes your entire username list in batches. Hundreds of profiles per run are typical.

---

*fansly profile scraper · fansly username lookup · fansly bulk scraper · fansly profile data · fansly creator data · fansly scraper · fansly profile enrichment · fansly stats scraper · fansly contact scraper · fansly social links · fansly instagram links · fansly bulk lookup · fansly data export · fansly follower count · fansly subscription pricing · fansly creator database · fansly profile bulk fetch · fansly data extraction · fansly creator lookup · fansly bulk data · adult creator data · fansly enrichment tool · fansly tiktok links · fansly twitter links · fansly creator stats · fansly account data · onlyfans model data · fansly profile api · creator data scraper · fansly outreach tool*

# Actor input Schema

## `usernames` (type: `array`):

List of Fansly usernames to scrape. Enter one username per line, or use the bulk edit button to paste a list. Do not include the @ symbol.
## `proxyConfiguration` (type: `object`):

Proxy settings. Rotating residential proxies are strongly recommended for reliability.

## Actor input object example

```json
{
  "usernames": [
    "ashlee_lou_xx"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
````

# Actor output Schema

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

No description

## `socialLinks` (type: `string`):

No description

## `statsAndPricing` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("sentry/fansly-profile-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 = { "usernames": ["ashlee_lou_xx"] }

# Run the Actor and wait for it to finish
run = client.actor("sentry/fansly-profile-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 '{
  "usernames": [
    "ashlee_lou_xx"
  ]
}' |
apify call sentry/fansly-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Fansly Profile Scraper",
        "description": "Scrape full Fansly profile data for any list of usernames — follower counts, subscription pricing, content stats, and verified Instagram, Twitter & TikTok contacts. Paste in your list and get clean, structured data ready to export instantly.",
        "version": "1.0",
        "x-build-id": "qzk8aSpAEHD4MHCCN"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sentry~fansly-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sentry-fansly-profile-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/sentry~fansly-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sentry-fansly-profile-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/sentry~fansly-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sentry-fansly-profile-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": [
                    "usernames"
                ],
                "properties": {
                    "usernames": {
                        "title": "Fansly Usernames",
                        "type": "array",
                        "description": "List of Fansly usernames to scrape. Enter one username per line, or use the bulk edit button to paste a list. Do not include the @ symbol.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "proxyConfiguration": {
                        "title": "Proxy Configuration",
                        "type": "object",
                        "description": "Proxy settings. Rotating residential proxies are strongly recommended for reliability.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
