# Username Existence Scraper (`automation-lab/username-existence-scraper`) Actor Check if a username exists on 400+ websites and social networks. Sherlock-style cross-platform username search via HTTP. Export results as JSON, CSV, or Excel. No login or API key required. - **URL**: https://apify.com/automation-lab/username-existence-scraper.md - **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community) - **Categories:** Social media, Other - **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, NaN 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. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. 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 Username Existence Scraper do? **Username Existence Scraper** checks whether a username exists on **400+ websites and social networks** — including GitHub, Reddit, Pinterest, Spotify, Wikipedia, DeviantArt, and hundreds more. It works like [Sherlock](https://github.com/sherlock-project/sherlock) but runs in the cloud with full API access, structured data output, and scheduling. Enter one or more usernames and the scraper sends HTTP requests to 400+ sites, checking if a profile page exists for that username. Results are returned as a structured dataset showing which sites have a matching account. The easiest way to try it: click **Start** with the prefilled input above. You'll get results in under 2 minutes. This scraper is **pure HTTP** — no browser needed, no login required, no API keys. It uses the same site database as the open-source Sherlock project, fetched fresh on every run so you always check the latest list of supported sites. ### Who is Username Existence Scraper for? 🔍 **OSINT investigators and security researchers** - Trace a person's digital footprint across hundreds of platforms - Map username reuse patterns for investigations - Identify accounts linked to a specific handle 🛡️ **Brand protection and marketing teams** - Check if your brand name is available or already taken on social platforms - Monitor impersonation across 400+ sites at once - Audit your brand's presence for consistency 👨‍💻 **Cybersecurity professionals** - Discover exposed accounts during security assessments - Check for credential reuse indicators - Map shadow IT — find employee accounts on unapproved platforms 📊 **Competitive intelligence analysts** - Track competitor presence across social networks - Discover new platforms where competitors are active - Build profiles of key industry figures ### Why use Username Existence Scraper? - ✅ **400+ sites checked** — the most comprehensive username search available on Apify - ✅ **Cloud-based and API-ready** — run from any language, schedule recurring checks, integrate with 5,000+ apps - ✅ **Always up-to-date** — site database fetched from Sherlock project on every run - ✅ **No browser overhead** — pure HTTP requests, fast and lightweight (256 MB memory) - ✅ **Structured output** — JSON, CSV, or Excel export with existence status per site - ✅ **No login or API key required** — works out of the box - ✅ **Configurable** — filter to specific sites, control concurrency, set timeouts - ✅ **Pay only for what you use** — per-username pricing, no monthly subscription ### What data can you extract? Each result row contains: | Field | Type | Description | |-------|------|-------------| | `username` | string | The username that was checked | | `siteName` | string | Name of the website/platform | | `siteUrl` | string | Base URL of the site | | `exists` | boolean | Whether a profile was found | | `profileUrl` | string | Direct URL to the profile page | | `httpStatus` | number | HTTP status code returned | | `responseTime` | number | Response time in milliseconds | For a single username check across all 400+ sites, you'll get ~478 result rows — one per site. ### How much does it cost to check username existence? This Actor uses **pay-per-event** pricing — you pay only for what you check. No monthly subscription. All platform costs are **included**. | | Free | Starter ($29/mo) | Scale ($199/mo) | Business ($999/mo) | |---|---|---|---|---| | **Per username** | $0.008 | $0.007 | $0.0055 | $0.005 | | **100 usernames** | $0.81 | $0.71 | $0.56 | $0.51 | Higher-tier plans get additional volume discounts. **Real-world cost examples:** | Input | Sites checked | Duration | Cost (Free tier) | |---|---|---|---| | 1 username, all sites | 478 | ~30s | ~$0.013 | | 5 usernames, all sites | 2,390 | ~2.5min | ~$0.045 | | 1 username, 10 sites only | 10 | ~5s | ~$0.013 | 💡 On the **free plan** ($5 credits), you can check approximately **620 usernames** across all sites. ### How to check if a username exists on social media 1. Go to [Username Existence Scraper](https://apify.com/automation-lab/username-existence-scraper) on Apify Store 2. Click **Start** to use the prefilled example, or enter your own usernames 3. Add usernames to the **Usernames** field — one per line 4. (Optional) Filter to specific sites in the **Sites filter** field 5. Click **Start** and wait for results (typically under 2 minutes) 6. Download results as JSON, CSV, or Excel from the **Dataset** tab **Example input — check a single username:** ```json { "usernames": ["johndoe123"] } ```` **Example input — check multiple usernames on specific sites:** ```json { "usernames": ["johndoe", "janedoe"], "sites": ["GitHub", "Reddit", "Twitter", "Instagram", "YouTube"], "maxConcurrency": 30, "timeout": 15 } ``` ### Input parameters | Parameter | Type | Default | Description | |-----------|------|---------|-------------| | `usernames` | string\[] | (required) | Usernames to check across all sites | | `sites` | string\[] | all sites | Filter to specific site names (e.g., "GitHub", "Twitter") | | `maxConcurrency` | integer | 50 | Number of parallel HTTP requests per username | | `timeout` | integer | 10 | Per-request timeout in seconds | ### Output example ```json [ { "username": "johndoe123", "siteName": "GitHub", "siteUrl": "https://www.github.com/", "exists": true, "profileUrl": "https://www.github.com/johndoe123", "httpStatus": 200, "responseTime": 827 }, { "username": "johndoe123", "siteName": "Reddit", "siteUrl": "https://www.reddit.com/", "exists": false, "profileUrl": "https://www.reddit.com/user/johndoe123", "httpStatus": 404, "responseTime": 312 } ] ``` ### Tips for best results - 🚀 **Start small** — run with 1 username first to see the output format and cost - 🎯 **Use site filters** for targeted investigations — checking 10 specific sites is faster than scanning all 400+ - ⏱️ **Increase timeout** to 15-20s if you need results from slow international sites - 📉 **Lower concurrency** to 20-30 if you're getting many timeouts (some sites rate-limit) - 🔄 **Schedule recurring runs** to monitor if new accounts appear under a username - 📊 **Filter results** in the dataset view by `exists: true` to see only found profiles - ⚠️ **Expect some false positives** (~5-7%) — sites like Spotify return 200 for any username. Cross-check critical findings manually. ### Integrations 📊 **Username Existence Scraper → Google Sheets** Export results to a spreadsheet for team review. Set up automatic sync to track username presence over time. 🔔 **Username Existence Scraper → Slack/Discord** Get alerts when a new account appears under a monitored username — useful for brand protection. 🔄 **Username Existence Scraper → Make/Zapier** Trigger enrichment workflows: when a username is found on a platform, automatically pull additional profile data. 📅 **Scheduled monitoring** Run daily or weekly to detect new impersonation accounts. Compare results across runs to spot changes. 🔗 **Webhook integration** Send results directly to your OSINT platform or case management system via POST webhook. ### Using the Apify API #### Node.js ```javascript import { ApifyClient } from 'apify-client'; const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' }); const run = await client.actor('automation-lab/username-existence-scraper').call({ usernames: ['johndoe123', 'janedoe456'], sites: ['GitHub', 'Twitter', 'Reddit'], }); const { items } = await client.dataset(run.defaultDatasetId).listItems(); const found = items.filter(item => item.exists); console.log(`Found ${found.length} profiles`); ``` #### Python ```python from apify_client import ApifyClient client = ApifyClient('YOUR_APIFY_TOKEN') run = client.actor('automation-lab/username-existence-scraper').call(run_input={ 'usernames': ['johndoe123', 'janedoe456'], 'sites': ['GitHub', 'Twitter', 'Reddit'], }) items = client.dataset(run['defaultDatasetId']).list_items().items found = [item for item in items if item['exists']] print(f'Found {len(found)} profiles') ``` #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/automation-lab~username-existence-scraper/runs?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "usernames": ["johndoe123"], "sites": ["GitHub", "Twitter", "Reddit"] }' ``` ### Use with AI agents via MCP Username Existence Scraper is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp). Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one: #### Setup for Claude Code ```bash claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/username-existence-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/username-existence-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: - "Check if the username 'elonmusk' exists on GitHub, Twitter, and Reddit using automation-lab/username-existence-scraper" - "Find all social media accounts for username 'johndoe123' across 400+ sites" - "Monitor if anyone has created accounts with our brand name 'acmecorp' on major platforms" Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp). ### Is it legal to check username existence? This scraper only checks publicly accessible profile pages by making standard HTTP GET requests — the same as visiting a URL in your browser. It does not bypass any authentication, access private data, or violate terms of service. Username existence checking accesses only public information (whether a profile page exists at a URL). Always use scraped data responsibly and in compliance with applicable privacy regulations like GDPR and CCPA. For more details, see Apify's guide on [web scraping legality](https://blog.apify.com/is-web-scraping-legal/). ### FAQ **How fast is the username check?** A single username across all 400+ sites takes approximately 20-40 seconds with default concurrency (50 parallel requests). Filtering to specific sites is nearly instant. **How much does it cost?** Each username check costs $0.008 on the free plan (plus a $0.005 one-time start fee per run). On the free plan ($5 credits), you can check approximately 620 usernames. **How accurate is the detection?** The scraper uses the same detection methods as the open-source Sherlock project. Expect ~93% accuracy — some sites return false positives (e.g., Spotify always returns 200) and some use aggressive anti-bot measures that block detection. **Why are some results showing "exists: true" for usernames that don't exist?** Some websites return HTTP 200 for any profile URL, even if the user doesn't exist (soft 404). This is a known limitation of HTTP-based detection. Cross-check important findings by visiting the profile URL manually. **Why do some sites return null for httpStatus?** This means the request timed out or the site was unreachable. Increase the `timeout` parameter to 15-20 seconds for better coverage of slow sites. **What's the difference between this and the Sherlock actor?** This scraper provides the same core functionality with added benefits: PPE pricing for cost control, API access for automation, structured dataset output, site filtering, configurable concurrency, and cloud scheduling. The Sherlock actor wraps the Python CLI which is slower and heavier. ### Other OSINT and username tools - 🔍 [Email Address Finder](https://apify.com/automation-lab/email-finder) — find email addresses associated with a domain - 🌐 [DNS Lookup](https://apify.com/automation-lab/dns-lookup) — check DNS records for any domain - 🔗 [Website Contact Finder](https://apify.com/automation-lab/website-contact-finder) — extract contact information from websites - 📧 [Email Validator](https://apify.com/automation-lab/email-validator) — verify if email addresses are deliverable - 🔒 [SSL Certificate Checker](https://apify.com/automation-lab/ssl-certificate-checker) — check SSL certificate details for any domain # Actor input Schema ## `usernames` (type: `array`): Enter usernames to check across 400+ websites. Each username is checked on every site. ## `sites` (type: `array`): Limit search to specific sites only. Leave empty to check all 400+ sites. Use exact site names (e.g., "GitHub", "Twitter", "Reddit"). ## `maxConcurrency` (type: `integer`): Set the number of parallel HTTP requests per username. Higher = faster but may trigger rate limits on some sites. ## `timeout` (type: `integer`): Set the timeout for each individual HTTP request. Sites that don't respond within this time are skipped. ## Actor input object example ```json { "usernames": [ "johndoe123" ], "sites": [], "maxConcurrency": 50, "timeout": 10 } ``` # 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 '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "usernames": [ "johndoe123" ], "sites": [], "maxConcurrency": 50, "timeout": 10 }; // Run the Actor and wait for it to finish const run = await client.actor("automation-lab/username-existence-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 '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "usernames": ["johndoe123"], "sites": [], "maxConcurrency": 50, "timeout": 10, } # Run the Actor and wait for it to finish run = client.actor("automation-lab/username-existence-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": [ "johndoe123" ], "sites": [], "maxConcurrency": 50, "timeout": 10 }' | apify call automation-lab/username-existence-scraper --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=automation-lab/username-existence-scraper", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Username Existence Scraper", "description": "Check if a username exists on 400+ websites and social networks. Sherlock-style cross-platform username search via HTTP. Export results as JSON, CSV, or Excel. No login or API key required.", "version": "0.1", "x-build-id": "aYlEKESHUGfcteOrY" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/automation-lab~username-existence-scraper/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-automation-lab-username-existence-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~username-existence-scraper/runs": { "post": { "operationId": "runs-sync-automation-lab-username-existence-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~username-existence-scraper/run-sync": { "post": { "operationId": "run-sync-automation-lab-username-existence-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": "Usernames", "type": "array", "description": "Enter usernames to check across 400+ websites. Each username is checked on every site.", "items": { "type": "string" } }, "sites": { "title": "Sites filter", "type": "array", "description": "Limit search to specific sites only. Leave empty to check all 400+ sites. Use exact site names (e.g., \"GitHub\", \"Twitter\", \"Reddit\").", "items": { "type": "string" } }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 200, "type": "integer", "description": "Set the number of parallel HTTP requests per username. Higher = faster but may trigger rate limits on some sites.", "default": 50 }, "timeout": { "title": "Request timeout (seconds)", "minimum": 3, "maximum": 30, "type": "integer", "description": "Set the timeout for each individual HTTP request. Sites that don't respond within this time are skipped.", "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 } } } } } } } } } } ```