# Snapchat Profile Scraper - Creator Analytics (`benthepythondev/snapchat-profile-scraper`) Actor

Scrape public Snapchat creator profiles with subscriber counts, bios, websites, categories, profile pictures, Snapcodes, highlight counts and related accounts.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## 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

## Snapchat Profile Scraper - Public Creator and Subscriber Data

Collect structured information from public Snapchat creator profiles without opening every page manually. Snapchat Profile Scraper accepts usernames, @handles, or profile URLs and returns public creator names, subscriber counts, biographies, websites, categories, profile pictures, Snapcodes, story and highlight indicators, related accounts, and timestamps.

The Actor is designed for creator discovery, partnership research, brand monitoring, social-media analysis, and repeatable public-profile datasets. Every valid profile becomes one clean row in the Apify default dataset. Results can be exported to JSON, CSV, Excel, XML, or RSS, accessed through the Apify API, sent to a webhook, or connected to Make, Zapier, n8n, Airtable, and Google Sheets.

### What does Snapchat Profile Scraper collect?

- Public Snapchat username and display name.
- Canonical public profile URL.
- Subscriber count when the profile publishes it.
- Public biography and website URL.
- Address when publicly provided by the profile.
- Profile picture and Snapcode image URLs.
- Public badge, category, subcategory, and publisher type.
- Business profile ID when exposed.
- Story availability.
- Curated Highlight and Spotlight Highlight indicators and counts.
- Public lens count when available on the page.
- Related public account usernames.
- Profile creation and last-update timestamps when exposed.
- UTC scrape timestamp for comparison between runs.

No Snapchat login, account password, or private session cookie is required. The Actor reads public profile pages only.

### Common use cases

#### Creator research

Enrich a list of public Snapchat creators with comparable profile data. Subscriber counts, category fields, profile copy, websites, and highlight activity can support a manual creator-selection process. They should not be treated as proof of audience authenticity, engagement quality, location, or commercial consent.

#### Brand and competitor monitoring

Run the same profile list on a schedule and track changes in subscribers, biography, website, category, story availability, and highlight counts. This helps teams maintain a current view of public Snapchat positioning without repeatedly checking profiles by hand.

#### Partnership qualification

Agencies and marketing teams can send reviewed profile rows into an internal qualification table. Add your own columns for audience fit, content quality, brand safety, territory, previous outreach, and campaign status. The Actor deliberately returns source data rather than an invented partnership score.

#### Public social datasets

Researchers can collect timestamped snapshots of selected public profiles. Keep your sampling rules and collection dates alongside the data so changes can be interpreted responsibly.

#### Related-account discovery

When Snapchat provides related public profiles, the Actor returns their usernames. Use these as research suggestions, then review each account before adding it to a monitoring or outreach workflow.

### Input

Provide a list of usernames, handles, or full public profile URLs.

```json
{
  "usernames": [
    "mkbhd",
    "@nasa",
    "https://www.snapchat.com/@washingtonpost"
  ],
  "maxProfiles": 10
}
````

#### Input fields

| Field | Type | Description |
| --- | --- | --- |
| `usernames` | array of strings | Snapchat usernames, @handles, or full profile URLs. Default: `mkbhd`. |
| `maxProfiles` | integer | Maximum number of supplied profiles processed in one run. Default: 10. Maximum: 100. |

The Actor removes a leading `@`, extracts the final path segment from a URL, and skips duplicate handles. Use a small list for the first test, then increase the batch after confirming that the target accounts have public profiles.

### Output

Each dataset item represents one public Snapchat profile.

```json
{
  "username": "examplecreator",
  "display_name": "Example Creator",
  "profile_url": "https://www.snapchat.com/@examplecreator",
  "subscriber_count": 213000,
  "bio": "Technology videos and behind-the-scenes stories.",
  "website_url": "https://example.com",
  "address": null,
  "profile_picture_url": "https://cf-st.sc-cdn.net/example-profile.jpg",
  "snapcode_url": "https://cf-st.sc-cdn.net/example-snapcode.png",
  "badge": "verified",
  "category": "CREATOR",
  "subcategory": "SCIENCE_TECHNOLOGY",
  "publisher_type": "PUBLISHER",
  "business_profile_id": "abc123",
  "has_story": true,
  "has_curated_highlights": true,
  "has_spotlight_highlights": true,
  "curated_highlight_count": 5,
  "spotlight_highlight_count": 12,
  "lens_count": 2,
  "related_accounts": ["relatedcreator"],
  "created_at_ms": 1609459200000,
  "updated_at_ms": 1783746000000,
  "scraped_at": "2026-07-11T10:15:00+00:00"
}
```

Snapchat varies the fields exposed for publishers, businesses, verified creators, and ordinary public profiles. Missing upstream values are returned as `null`, empty arrays, zero-length counts, or false flags as appropriate. The Actor does not estimate hidden subscriber totals or infer private profile attributes.

### Pricing

Snapchat Profile Scraper uses pay per event pricing:

- Actor start: $0.00005 per run.
- Result: $0.003 for each profile saved to the default dataset.

A run returning 10 valid profiles costs about $0.03005 in Actor charges, excluding standard Apify platform usage. A 100-profile run costs about $0.30005. You pay for rows actually saved, so unavailable handles that produce no dataset row are not billed as results.

### Run through the Apify API

```bash
curl -X POST "https://api.apify.com/v2/acts/benthepythondev~snapchat-profile-scraper/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["mkbhd","nasa"],"maxProfiles":2}'
```

The response contains a run ID. Poll the run through the Apify API and read the default dataset after it succeeds. Keep API tokens outside source code and use Apify secrets or your own secret manager in production.

### Automation recipes

#### Weekly creator monitor

Schedule a fixed list every week. Save the results to a database and compare `subscriber_count`, `bio`, `website_url`, `has_story`, and highlight counts against the previous snapshot. Add percentage thresholds so ordinary fluctuations do not trigger noisy alerts.

#### Creator research sheet

Send results to Google Sheets or Airtable. Add human-reviewed columns for niche relevance, content quality, campaign fit, geography, contact status, and notes. Keep source metrics separate from your internal evaluation.

#### Website enrichment

Route rows with a public `website_url` to a separate website-contact research process. Verify the website belongs to the creator or organization and apply your own legal basis before any outreach. A public link is not automatic marketing consent.

#### Portfolio comparisons

Group profiles by public category or publisher type and compare subscriber scale, highlight activity, and website presence. Avoid drawing demographic or personal conclusions that the source data does not support.

### Reliability and technical approach

The Actor requests Snapchat's public creator page with a Chrome-compatible HTTP client and reads the structured Next.js data embedded by the server. It does not launch a full browser, use a logged-in Snapchat account, or depend on a paid anti-bot service. This keeps startup time and operating cost low.

Requests use bounded retries and timeouts. Inputs are normalized and deduplicated. If Snapchat returns no valid public profiles, the run fails explicitly rather than producing a misleading successful empty dataset. This behavior is important for scheduled monitoring because an upstream change becomes visible in run status.

Snapchat can change its public page structure or restrict individual profiles. Monitor production schedules and report reproducible failures with the Apify run ID and a public example handle.

### Data quality and limitations

- Subscriber counts are available only when Snapchat publishes them.
- Story and highlight indicators describe what the public page exposed at scrape time.
- A public badge or publisher field is not a substitute for independent identity or brand-safety checks.
- Public profile timestamps are returned as milliseconds when the source provides them.
- Deleted, private, restricted, misspelled, or unavailable profiles may be skipped.
- Related accounts are platform suggestions, not verified affiliations.

### Responsible use

Use this Actor only for lawful collection and processing of public information. Follow Snapchat's terms, privacy law, intellectual-property rules, marketing regulations, and your organization's compliance requirements. Do not use the dataset for harassment, sensitive profiling, stalking, spam, identity resolution, or automated outreach without a lawful basis. Respect minors and other vulnerable users; avoid collecting or operationalizing data in ways that create risk.

Snapchat is a trademark of its owner. This independent Actor is not affiliated with, endorsed by, or sponsored by Snapchat.

### Frequently asked questions

#### Does the Actor need my Snapchat login?

No. It reads public profile pages and does not request your Snapchat credentials.

#### Can it scrape private accounts or private stories?

No. The Actor is limited to publicly accessible creator profile metadata and does not bypass privacy controls.

#### Why is subscriber count empty?

Some public profiles do not publish a subscriber total. The Actor keeps the value empty instead of estimating it.

#### Can I submit full Snapchat URLs?

Yes. Full profile URLs, plain usernames, and @handles are accepted and normalized.

#### Does it download stories or Spotlight videos?

No. This Actor focuses on profile-level metadata and public activity indicators. It does not copy story or video media.

#### Can I export the results to Excel?

Yes. Open the run's default dataset and select Excel, CSV, JSON, XML, RSS, or another Apify export format.

### You might also like

- [Pinterest Profile Scraper](https://apify.com/benthepythondev/pinterest-profile-scraper) for Pinterest creator metrics.
- [Instagram Intelligence Scraper](https://apify.com/benthepythondev/instagram-intelligence-scraper) for public Instagram research.
- [TikTok Profile Scraper](https://apify.com/benthepythondev/tiktok-profile-scraper) for public TikTok account data.
- [YouTube Channel Intelligence](https://apify.com/benthepythondev/youtube-channel-intelligence) for channel and video analytics.

### Support and reviews

If a public profile no longer parses, open an issue on the Actor page with the run ID, a redacted input, and the behavior you expected. Reproducible reports can be investigated much faster than screenshots without run context. If the Actor is useful, please leave an honest Apify Store review. Reviews help other users evaluate reliability and show which features deserve priority.

**Keywords:** Snapchat scraper, Snapchat profile scraper, Snapchat subscriber count, Snapchat creator analytics, Snapchat public profile API, Snapcode scraper, influencer research, creator discovery, social media monitoring, public profile dataset.

# Actor input Schema

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

Public Snapchat usernames, @handles, or full snapchat.com profile URLs.

## `maxProfiles` (type: `integer`):

Maximum number of supplied profiles processed in one run.

## Actor input object example

```json
{
  "usernames": [
    "mkbhd",
    "nasa"
  ],
  "maxProfiles": 10
}
```

# Actor output Schema

## `results` (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": [
        "mkbhd",
        "nasa"
    ],
    "maxProfiles": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("benthepythondev/snapchat-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": [
        "mkbhd",
        "nasa",
    ],
    "maxProfiles": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("benthepythondev/snapchat-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": [
    "mkbhd",
    "nasa"
  ],
  "maxProfiles": 10
}' |
apify call benthepythondev/snapchat-profile-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Snapchat Profile Scraper - Creator Analytics",
        "description": "Scrape public Snapchat creator profiles with subscriber counts, bios, websites, categories, profile pictures, Snapcodes, highlight counts and related accounts.",
        "version": "1.0",
        "x-build-id": "AGAE54Immnhd8Js7p"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/benthepythondev~snapchat-profile-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-benthepythondev-snapchat-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/benthepythondev~snapchat-profile-scraper/runs": {
            "post": {
                "operationId": "runs-sync-benthepythondev-snapchat-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/benthepythondev~snapchat-profile-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-benthepythondev-snapchat-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",
                "properties": {
                    "usernames": {
                        "title": "Snapchat usernames or profile URLs",
                        "type": "array",
                        "description": "Public Snapchat usernames, @handles, or full snapchat.com profile URLs.",
                        "default": [
                            "mkbhd"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxProfiles": {
                        "title": "Maximum profiles",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of supplied profiles processed in one run.",
                        "default": 10
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
