# Snapchat Scraper (`automation-lab/snapchat-scraper`) Actor

Scrape Snapchat profiles: subscriber count, bio, website, verified badge, category, profile picture, highlights, lenses, related accounts. Works for public and private profiles. Export to JSON, CSV, Excel.

- **URL**: https://apify.com/automation-lab/snapchat-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 68 total users, 14 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

### 👻 What does Snapchat Scraper do?

Snapchat Scraper extracts **public profile data** from any Snapchat user — subscriber counts, bios, website links, categories, verified badges, profile pictures, highlights, lenses, related accounts, and more. Enter usernames, click Start, and get structured profile data in JSON, CSV, or Excel.

It works via **pure HTTP requests** (CheerioCrawler) — no browser needed. This makes it extremely fast (~2 seconds per profile) and dirt cheap to run (256 MB memory). It extracts the `__NEXT_DATA__` payload from Snapchat profile pages, giving you clean, structured data without any browser overhead.

The scraper automatically detects **three profile types**:

- **Public profiles** — full data: subscriber count, bio, website, category, verified status, lenses, highlights, related accounts, and more
- **Private profiles** — limited data: username, display name, and snapcode image
- **Not found** — clearly marked so you know which usernames are invalid

### 🎯 Who is Snapchat Scraper for?

**Influencer marketing agencies**
- Evaluate Snapchat creators by subscriber count, category, and verified status before reaching out
- Build prospect lists of creators in specific niches (entertainment, beauty, sports, etc.)
- Discover new creators through the related accounts feature

**Brand and social media managers**
- Monitor competitor Snapchat profiles — track subscriber growth, bio changes, and content activity
- Verify whether influencer partners actually have the audience they claim
- Track your own brand's Snapchat presence alongside competitors

**Market researchers and analysts**
- Map the Snapchat creator landscape by category and subcategory
- Analyze profile patterns — which categories have the most verified accounts, highest subscriber counts
- Study related account networks to understand creator clusters and communities

**Developers and data engineers**
- Feed Snapchat profile data into dashboards and analytics pipelines
- Enrich CRM records with social media presence data
- Build monitoring systems that track profile changes over time with scheduled runs

### 💡 Why use Snapchat Scraper?

- **Pay per profile** — $0.002 per profile scraped. No monthly subscription, no commitment. All platform costs (compute, proxy, storage) are included
- **Pure HTTP, no browser** — runs on CheerioCrawler with just 256 MB of memory, keeping costs extremely low
- **~2 seconds per profile** — scrape hundreds of profiles in under a minute
- **Clean, flat output** — every field is top-level. No nested raw API responses to parse
- **Public + private detection** — clearly identifies whether a profile is public, private, or not found
- **Related accounts** — discover connected creators that Snapchat recommends alongside each profile
- **Lenses, highlights, and spotlights counted** — know how active each creator is on the platform
- **Flexible input** — accepts usernames, @handles, or full Snapchat URLs in any combination
- **Flexible output** — JSON, CSV, Excel, XML, or HTML table. Integrate via API, webhooks, or 100+ Apify integrations

### 📊 What data can you extract from Snapchat?

**Public profiles** return full data:

| Data point | Example |
|---|---|
| Username | `therock` |
| Display name | `The Rock` |
| Profile type | `public`, `private`, or `not_found` |
| Subscriber count | `3200000` |
| Bio | `Official Snapchat of Dwayne Johnson` |
| Website URL | `https://www.therock.com` |
| Verified badge | `true` / `false` |
| Category | `entertainment`, `beauty`, `sports` |
| Subcategory | More specific classification within the category |
| Profile picture URL | Direct image link |
| Snapcode image URL | QR code image for adding on Snapchat |
| Hero image URL | Banner/cover image |
| Has story | Whether the profile currently has an active story |
| Curated highlights | Whether the profile has curated highlight collections |
| Spotlight highlights | Whether the profile has spotlight content |
| Lens count | Number of AR lenses created |
| Highlight count | Number of curated highlight collections |
| Spotlight count | Number of spotlight videos |
| Related accounts | List of usernames Snapchat recommends alongside this profile |
| Created at | Profile creation timestamp (ISO 8601) |
| Last updated at | Last profile update timestamp (ISO 8601) |
| Business profile ID | ID for business/creator profiles |
| Address | Business address (if available) |
| Profile URL | `https://www.snapchat.com/add/therock` |

**Private profiles** return limited data: username, display name, snapcode image URL, and profile URL.

**Not found profiles** are clearly marked with `profileType: "not_found"` so you know which usernames are invalid.

### 💰 How much does it cost to scrape Snapchat?

This Actor uses **pay-per-event** pricing — you pay only for what you scrape. No monthly subscription required. All platform costs (compute, proxy, storage) are **included** in the price.

| | Free plan | Starter ($49/mo) | Scale ($499/mo) |
|---|---|---|---|
| **Start fee** | $0.005 | $0.004 | $0.003 |
| **Per profile** | $0.002 | $0.0017 | $0.0013 |
| **1,000 profiles** | $2.005 | $1.704 | $1.303 |
| **10,000 profiles** | $20.005 | $17.004 | $13.003 |

Higher-tier Apify plans get additional volume discounts.

**How this compares to alternatives:**

| Scraper | Pricing model | Cost for 1,000 profiles |
|---|---|---|
| **Snapchat Scraper** (this actor) | Pay per profile | **$2.00** |
| Competitor A | Monthly subscription | $15.00/month (flat fee) |
| Competitor B | Pay per result | $2.00 |

With the [Apify Free plan](https://apify.com/pricing), you get $5 of free usage per month — enough to scrape **~2,400 profiles for free**.

### 🚀 How to scrape Snapchat profiles

1. Go to the [Snapchat Scraper](https://apify.com/automation-lab/snapchat-scraper) on Apify Store
2. Click **Try for free** to open the Actor in Apify Console
3. Enter Snapchat usernames, @handles, or profile URLs
4. Click **Start** and wait for the run to complete
5. Download your data in JSON, CSV, Excel, XML, or HTML table format

The simplest input just requires usernames:

```json
{
    "usernames": ["therock"]
}
````

Multiple profiles in a single run:

```json
{
    "usernames": [
        "therock",
        "nba",
        "djkhaled",
        "https://www.snapchat.com/add/kyliejenner",
        "@nasa"
    ]
}
```

The scraper accepts any mix of plain usernames, @handles, and full Snapchat URLs.

### ⚙️ Input parameters

| Parameter | Type | Required | Description |
|---|---|---|---|
| `usernames` | string\[] | Yes | Snapchat usernames, @handles, or profile URLs to scrape. Examples: `therock`, `@nba`, `https://www.snapchat.com/add/djkhaled` |

That's it — just one parameter. The scraper handles URL parsing and username extraction automatically.

### 📦 Output example

**Public profile:**

```json
{
    "username": "therock",
    "displayName": "The Rock",
    "profileType": "public",
    "subscriberCount": 3200000,
    "bio": "Official Snapchat of Dwayne Johnson",
    "websiteUrl": "https://www.therock.com",
    "isVerified": true,
    "category": "entertainment",
    "subcategory": null,
    "profilePictureUrl": "https://cf-st.sc-cdn.net/...",
    "snapcodeImageUrl": "https://app.snapchat.com/web/deeplink/snapcode?username=therock&type=SVG",
    "heroImageUrl": "https://cf-st.sc-cdn.net/...",
    "hasStory": true,
    "hasCuratedHighlights": true,
    "hasSpotlightHighlights": false,
    "lensCount": 5,
    "highlightCount": 12,
    "spotlightCount": 0,
    "relatedAccounts": ["kevinhart4real", "willsmith"],
    "createdAt": "2016-01-15T00:00:00.000Z",
    "lastUpdatedAt": "2026-03-18T12:30:00.000Z",
    "businessProfileId": "abc123-def456",
    "address": null,
    "url": "https://www.snapchat.com/add/therock"
}
```

**Private profile:**

```json
{
    "username": "someprivateuser",
    "displayName": "John D.",
    "profileType": "private",
    "subscriberCount": null,
    "bio": null,
    "websiteUrl": null,
    "isVerified": false,
    "category": null,
    "subcategory": null,
    "profilePictureUrl": null,
    "snapcodeImageUrl": "https://app.snapchat.com/web/deeplink/snapcode?username=someprivateuser&type=SVG",
    "heroImageUrl": null,
    "hasStory": false,
    "hasCuratedHighlights": false,
    "hasSpotlightHighlights": false,
    "lensCount": 0,
    "highlightCount": 0,
    "spotlightCount": 0,
    "relatedAccounts": [],
    "createdAt": null,
    "lastUpdatedAt": null,
    "businessProfileId": null,
    "address": null,
    "url": "https://www.snapchat.com/add/someprivateuser"
}
```

### 💡 Tips for best results

- **Start with a small test** — try 2-3 usernames first to verify the output format meets your needs before scraping hundreds
- **Mix input formats freely** — you can combine plain usernames (`therock`), @handles (`@nba`), and full URLs (`https://www.snapchat.com/add/djkhaled`) in a single run
- **Check the `profileType` field** — use it to filter out private or not-found profiles in post-processing
- **Use `relatedAccounts`** to discover new profiles — scrape a seed list, then scrape the related accounts to expand your dataset
- **Schedule recurring runs** to track profile changes over time — subscriber growth, bio updates, new lenses
- **Batch large lists** — the scraper handles concurrency automatically. Feed it hundreds of usernames and let it run

### 🔗 Integrations

Snapchat Scraper connects with any cloud service or web app through [Apify integrations](https://apify.com/integrations).

**Common workflows:**

- **Snapchat to Google Sheets** — automatically export profile data to a spreadsheet for team analysis and influencer tracking
- **Snapchat to Slack/Discord** — get notified when a scraping run completes with profile summaries
- **Snapchat to Make/Zapier** — trigger downstream workflows: update a CRM, enrich contact records, send email alerts
- **Snapchat to BigQuery/Snowflake** — pipe profile data into your data warehouse for large-scale analytics
- **Scheduled runs** — set up daily or weekly scrapes to monitor profile changes over time
- **Webhooks** — receive results via HTTP POST as soon as the run finishes for real-time processing

### 🤖 Using the Apify API

The Apify API gives you programmatic access to run this Actor, retrieve datasets, and automate scraping workflows.

**Node.js:**

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const run = await client.actor('automation-lab/snapchat-scraper').call({
    usernames: ['therock', 'nba', 'djkhaled'],
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

**Python:**

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run = client.actor('automation-lab/snapchat-scraper').call(run_input={
    'usernames': ['therock', 'nba', 'djkhaled'],
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

**cURL:**

```bash
curl "https://api.apify.com/v2/acts/automation-lab~snapchat-scraper/runs" \
  -X POST \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"usernames": ["therock", "nba", "djkhaled"]}'
```

Check out the [Apify API reference](https://docs.apify.com/api/v2) for full documentation.

### 🧠 Use with AI agents via MCP

Snapchat Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). This lets you scrape Snapchat data using natural language — just ask your AI assistant to "get Snapchat profile data for therock" and it will configure and run the scraper for you.

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/snapchat-scraper"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/snapchat-scraper"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Get Snapchat profile data for therock, nba, and djkhaled"
- "How many subscribers does kylie jenner have on Snapchat?"
- "Find all related accounts for the top 10 Snapchat influencers"
- "Check if these 50 Snapchat usernames exist and which are verified"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### ⚖️ Is it legal to scrape Snapchat?

Scraping publicly available Snapchat profile data is generally considered legal. Court rulings such as *hiQ Labs v. LinkedIn* have confirmed that collecting publicly accessible information does not violate the Computer Fraud and Abuse Act.

Key points:

- Only publicly visible profile data is collected (display names, bios, Bitmojis)
- No login credentials or private accounts are accessed
- Private snaps and messages are never collected
- The scraper respects rate limits to minimize server impact

Always review Snapchat's Terms of Service and consult legal counsel for commercial use cases. For more details, see [Apify's guide on web scraping legality](https://blog.apify.com/is-web-scraping-legal/).

### How do I find Snapchat influencers for a marketing campaign?

Start with a seed list of known creators in your niche and run them through Snapchat Scraper to get subscriber counts, categories, verified status, and bio details. Then use the `relatedAccounts` field in the output — Snapchat recommends related creators alongside each profile, giving you a discovery network. Scrape those related accounts to expand your list organically. Filter the results by `category`, `subscriberCount`, and `isVerified` to build a shortlist of genuinely relevant creators with real audiences. This approach costs a fraction of influencer database subscriptions and gives you real-time data rather than cached profiles.

### What Snapchat data can I extract without a Snapchat account?

You do not need a Snapchat account, login, or API key to use this scraper. It extracts all publicly visible data from Snapchat profile pages, including subscriber counts, bios, website links, categories, verified badges, profile pictures, hero images, lens counts, highlight counts, spotlight counts, related accounts, and business addresses. Private accounts return limited data (username, display name, snapcode). The scraper works via pure HTTP requests — no browser, no cookies, no credentials.

### How do I track Snapchat profile growth over time?

Set up a scheduled run in Apify Console targeting your list of usernames. Run it daily or weekly and each run will capture a fresh snapshot of subscriber counts, bio text, story status, and content counts. Connect the output to Google Sheets via Apify integrations to build a time-series spreadsheet automatically, or pipe results into your data warehouse. The `lastUpdatedAt` field also tells you when a creator last updated their profile, helping you distinguish active accounts from dormant ones.

### ❓ FAQ

**What profile data can I get from private accounts?**

Private Snapchat profiles return limited data: username, display name, snapcode image URL, and profile URL. You won't get subscriber counts, bios, website links, or other detailed information for private accounts. The `profileType` field will be set to `"private"` so you can easily filter these in your results.

**How fast is the scraper?**

Approximately 2 seconds per profile. With proxy enabled, the scraper runs up to 20 concurrent requests, so 100 profiles take about 10 seconds. Without proxy, concurrency is limited to 3 requests to avoid rate limiting.

**Does it need a Snapchat account or login?**

No. The scraper extracts publicly available data from Snapchat profile pages. No login, API key, or Snapchat account is required.

**What formats can I enter usernames in?**

Any of these formats work and can be mixed freely in the same input:

- Plain username: `therock`
- @handle: `@therock`
- Full URL: `https://www.snapchat.com/add/therock`

**What happens if a username doesn't exist?**

The scraper returns a result with `profileType: "not_found"` and null values for all data fields. This way you know exactly which usernames are invalid without missing any from your results.

**How does this compare to other Snapchat scrapers?**

This scraper is the most cost-effective option on the Apify Store. It uses pay-per-event pricing ($0.002/profile) instead of monthly subscriptions ($15/month). It's also the fastest — pure HTTP with no browser overhead. The output is clean and flat with 24 fields per profile, not nested raw API data you need to parse.

**Is it legal to scrape Snapchat?**

Our scrapers are ethical and do not extract any private user data. They only extract what Snapchat has chosen to make publicly available on profile pages. We believe that our scrapers, when used for ethical purposes, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers. You can also read our blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

### 🔗 Other social media scrapers

- [TikTok Scraper](https://apify.com/automation-lab/tiktok-scraper) — scrape TikTok profiles, videos, and engagement metrics
- [Twitter/X Scraper](https://apify.com/automation-lab/twitter-scraper) — extract tweets, profiles, and followers from Twitter/X
- [Facebook Ads Library Scraper](https://apify.com/automation-lab/facebook-ads-library) — search and extract ads from Meta Ad Library
- [YouTube Transcript Scraper](https://apify.com/automation-lab/youtube-transcript) — extract transcripts and metadata from YouTube videos
- [Indeed Scraper](https://apify.com/automation-lab/indeed-scraper) — scrape job listings from Indeed
- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — find businesses with contact info from Google Maps

# Actor input Schema

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

Enter Snapchat usernames, profile URLs, or @handles. Examples: therock, @nba, https://www.snapchat.com/add/djkhaled

## Actor input object example

```json
{
  "usernames": [
    "therock"
  ]
}
```

# Actor output Schema

## `overview` (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": [
        "therock"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/snapchat-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": ["therock"] }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/snapchat-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": [
    "therock"
  ]
}' |
apify call automation-lab/snapchat-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Snapchat Scraper",
        "description": "Scrape Snapchat profiles: subscriber count, bio, website, verified badge, category, profile picture, highlights, lenses, related accounts. Works for public and private profiles. Export to JSON, CSV, Excel.",
        "version": "0.1",
        "x-build-id": "ERCAbt0iwCM7kJWzw"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~snapchat-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-snapchat-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/automation-lab~snapchat-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-snapchat-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/automation-lab~snapchat-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-snapchat-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": "Snapchat usernames",
                        "type": "array",
                        "description": "Enter Snapchat usernames, profile URLs, or @handles. Examples: therock, @nba, https://www.snapchat.com/add/djkhaled",
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
