# Social Media Username Checker — Availability Scanner (`perryay/social-media-username-checker`) Actor Check if a username is available or taken across 50+ social media and professional platforms. Supports batch checking, platform filtering, and concurrent scanning. - **URL**: https://apify.com/perryay/social-media-username-checker.md - **Developed by:** [Perry AY](https://apify.com/perryay) (community) - **Categories:** Social media, Developer tools - **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.025 / actor start This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage. 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/docs.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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 ## Social Media Username Checker — Availability Scanner ### Social Media Username Checker — Availability Scanner **Check if a username is available or already taken across 50+ social media, professional, and creative platforms in a single run.** Whether you're securing brand identity, choosing a consistent online handle, or investigating username squatting, this actor scans the web for you in seconds. --- ### What does it do? This actor takes one or more usernames and checks their availability across a comprehensive list of 50+ platforms — from social media giants like Instagram and TikTok to professional networks like LinkedIn, developer platforms like GitHub and Stack Overflow, and creative hubs like Behance and Dribbble. Each platform is checked using HTTP requests that simulate a real browser visit. The actor intelligently handles different response patterns: some platforms return a 404 for available usernames, others redirect to a different page, and a few require response body analysis. The actor handles all these cases automatically and returns a clear available/taken/error status per platform. Batch mode lets you check dozens of usernames in one run, and platform filtering lets you target specific platforms when you only care about certain services. ### Features 1. **50+ platforms** — Covers Twitter/X, Instagram, GitHub, TikTok, YouTube, Reddit, LinkedIn, Pinterest, Tumblr, Snapchat, Telegram, Discord, Behance, Dribbble, Medium, Dev.to, Hashnode, Stack Overflow, Keybase, AngelList/Wellfound, Product Hunt, Mastodon, Twitch, Steam, Flickr, SoundCloud, Vimeo, Patreon, GitLab, Bitbucket, Codepen, Replit, Gravatar, About.me, VK, Fiverr, Upwork, Squarespace, Carrd, Linktree, Buy Me a Coffee, Ko-fi, Substack, Notion, Wix, WordPress, Threads, Bluesky, and more. 2. **Intelligent detection** — Uses status codes, redirect analysis, and response body patterns per platform for accurate results. 3. **Batch checking** — Check multiple usernames in a single run with concurrent scanning. 4. **Platform filtering** — Choose specific platforms to check instead of the full list. 5. **Configurable concurrency** — Control how many platforms are checked simultaneously (5-30). 6. **Error resilience** — Individual platform failures don't affect other checks. Rate-limited platforms are reported without blocking the rest. ### Why use this? | Problem | Solution | |---------|----------| | You're launching a brand and need consistent handles everywhere | Check 50+ platforms at once to see which usernames are available | | You're researching username squatting | Scan a target username across all major platforms in seconds | | You're choosing a new personal handle | Test variations to find one that's available on the platforms you care about | | You maintain multiple social accounts | Verify your existing usernames are still live across all platforms | | You're a content creator starting out | Find available handles across platforms before committing to a name | ### Who is it for? | Persona | What they use it for | |---------|---------------------| | Brand Manager | Checking brand name availability across social media before launch | | Content Creator | Finding a consistent, available handle across YouTube, Instagram, TikTok, and Twitter | | Security Researcher | Investigating username squatting or impersonation | | Startup Founder | Securing the company name across all platforms before public announcement | | Social Media Manager | Auditing existing account portfolios for dead or hijacked handles | | Indie Developer | Checking username availability on GitHub, Dev.to, and coding platforms | ### Input Parameters | Field | Type | Default | Description | |-------|------|---------|-------------| | `username` | string | — | Single username to check across all platforms | | `usernames` | array | — | Multiple usernames to check in batch mode (e.g., `["user1", "user2"]`) | | `platforms` | array | `[]` (all) | Specific platforms to check. Leave empty to check all 50+. | | `maxConcurrency` | integer | `15` | Maximum simultaneous platform checks. Range: 5-30. | #### Example Input JSON ```json { "username": "perryay" } ```` #### Example Batch Input ```json { "usernames": ["perryay", "starnight", "tech_startup", "brandname"], "maxConcurrency": 20 } ``` #### Example Filtered Input ```json { "username": "mybrand", "platforms": ["Twitter/X", "Instagram", "GitHub", "TikTok", "YouTube"], "maxConcurrency": 10 } ``` ### Output Format | Field | Type | Description | |-------|------|-------------| | `username` | string | The username that was checked | | `total_platforms` | integer | Number of platforms checked | | `available` | integer | Count of platforms where the username is available | | `taken` | integer | Count of platforms where the username is taken | | `results` | array | Per-platform details (see below) | Each result entry in `results`: | Field | Type | Description | |-------|------|-------------| | `platform` | string | Platform name | | `url` | string | Profile URL checked | | `status` | string | One of: `taken`, `available`, `rate_limited`, `error`, `unknown` | | `available` | boolean or null | Whether the username is available on this platform | | `error` | string or null | Error message if the check failed | #### Example Output JSON ```json { "username": "perryay", "total_platforms": 50, "available": 32, "taken": 17, "results": [ { "platform": "GitHub", "url": "https://github.com/perryay", "status": "taken", "available": false, "error": null }, { "platform": "Twitter/X", "url": "https://twitter.com/perryay", "status": "available", "available": true, "error": null } ] } ``` ### API Usage #### cURL ```bash curl -X POST "https://api.apify.com/v2/acts/perryay~social-media-username-checker/runs?token=YOUR_API_TOKEN" \ -H "Content-Type: application/json" \ -d '{"username": "mybrand"}' ``` #### Python (ApifyClient) ```python from apify_client import ApifyClient client = ApifyClient("YOUR_API_TOKEN") run = client.actor("perryay~social-media-username-checker").call( run_input={"username": "mybrand"} ) dataset = client.dataset(run["defaultDatasetId"]).list_items() for item in dataset.items: print(f'Username: {item[\"username\"]} — {item[\"available\"]} available / {item[\"taken\"]} taken') ``` ### Use Cases 1. **Brand launch preparation** — Before announcing a new brand name, check all major platforms to see if the handle is available. If it's taken, try variations before committing. 2. **Username squatting detection** — A common username is taken on half your target platforms. Find out where it's registered and assess whether you need to contact the platform or choose an alternative. 3. **Multi-platform identity audit** — You've been online for years and have accounts scattered across the web. Use this actor to verify which accounts are still active and which have been hijacked or deleted. 4. **Content creator setup** — Starting a YouTube channel? Check availability on YouTube, Instagram, TikTok, Twitter, and Discord in one shot to secure a consistent identity. 5. **Competitive username research** — See what usernames your competitors have registered and where. Identify platforms they're neglecting where you could establish a presence. 6. **Domain + handle bundle** — Combine with Domain Intel to check both domain availability and social handle availability for a unified brand launch plan. 7. **Community management** — A moderator with a well-known handle on Reddit wants to secure the same name on Discord, Telegram, and Mastodon. Run a batch check to plan the rollout. 8. **Platform migration** — Moving from Twitter to Bluesky? Check your handle on both platforms and try alternatives before announcing the move. 9. **Freelancer portfolio audit** — Check your professional handle on LinkedIn, GitHub, Behance, Dribbble, Upwork, and Fiverr to ensure consistent freelancer branding. 10. **Privacy audit** — Find all platforms where a specific username is registered. Useful for personal privacy assessments or OSINT investigations. ### FAQ **Q: How many platforms are supported?** A: The actor checks 50+ platforms including Twitter/X, Instagram, GitHub, TikTok, YouTube, Reddit, LinkedIn, Pinterest, Tumblr, Snapchat, Telegram, Discord, Behance, Dribbble, Medium, Dev.to, Hashnode, Stack Overflow, Keybase, AngelList/Wellfound, Product Hunt, Mastodon, Twitch, Steam, Flickr, SoundCloud, Vimeo, Patreon, GitLab, Bitbucket, Codepen, Replit, Gravatar, About.me, VK, Fiverr, Upwork, Squarespace, Carrd, Linktree, Buy Me a Coffee, Ko-fi, Substack, Notion, Wix, WordPress, Threads, Bluesky, and more. **Q: How does the actor determine if a username is available?** A: It varies by platform. The actor uses HTTP status codes (200 = taken, 404 = available), redirect analysis (some platforms redirect available usernames to a search page), and response body pattern matching. Each platform has a tailored detection method. **Q: Can I check a username on just a few platforms?** A: Yes. Use the `platforms` input field to specify which platforms to check. The platform names are case-insensitive and must match the names listed in the FAQ above. **Q: Is batch mode supported?** A: Yes. Pass an array of usernames in the `usernames` field. Each username is processed sequentially, and results are pushed to the dataset individually. **Q: How fast is it?** A: With default concurrency (15 simultaneous checks), a full 50-platform scan takes approximately 15-30 seconds per username. With max concurrency (30), it can complete in 10-20 seconds. Results are streamed to the dataset as each username completes. **Q: What happens if a platform is rate-limited?** A: The check returns `status: "rate_limited"` and proceeds to the next platform. The run continues and all other platform results are unaffected. You can retry with a lower concurrency setting (e.g., 5-10) to reduce rate limiting. **Q: Does the actor handle platform-specific error pages?** A: Yes. Some platforms return a 200 status code even when a user doesn't exist (they serve a custom error page). The actor handles these cases with platform-specific detection logic that checks for text patterns like "This page doesn't exist" or "User not found" in the response body. **Q: What's the maximum number of usernames I can check in one run?** A: There is no hard limit, but runs are subject to the actor's timeout setting (default 300 seconds). A batch of 10 usernames scanning all 50 platforms typically completes within 3-5 minutes. **Q: Can I use this actor in an automated workflow?** A: Yes. It has a fully documented API with cURL and Python examples. You can integrate it into CI/CD pipelines, monitoring dashboards, or automated brand protection workflows. **Q: Does the actor require any API keys or special permissions?** A: No. The actor uses HTTP requests to check public profile pages on each platform. No API keys or authentication are required. However, the actor itself must be run through the Apify platform, which requires an Apify account. **Q: Why would some checks return "error" or "unknown"?** A: Network timeouts, connection failures, or unexpected HTTP response codes from a platform. These are isolated to the specific platform and do not affect other checks. Common causes include temporary platform downtime or CAPTCHA challenges. ### Usage & Billing This actor uses Apify's PAY\_PER\_EVENT pricing model. You are charged per event: | Event Name | Price (USD) | Trigger | |------------|-------------|---------| | `apify-actor-start` | $0.025 | Charged on every actor start | | `username-check` | $0.015 | Charged per username checked | | `batch-scan` | $0.010 | Charged once per batch run (multiple usernames) | | `platform-filter` | $0.005 | Charged when custom platform filtering is used | Platform infrastructure costs (Apify's compute and storage) are passed through at cost. ### MCP Integration This actor can be used through the [Apify MCP server](https://docs.apify.com/integrations/mcp). Once connected, your MCP client (Claude Desktop, Cursor, etc.) can discover and run this actor from the Apify Store. #### Quick Start 1. **Install the Apify connector** in your MCP client: - **Claude Desktop**: Search for "Apify" in the connector directory, or use the remote server at `https://mcp.apify.com` - **Other clients**: See the [Apify MCP server docs](https://docs.apify.com/integrations/mcp) for setup instructions 2. **Ask your AI assistant** to use the actor. #### Claude Desktop Configuration Add the following to your `claude_desktop_config.json`: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com" } } } ``` On first connection, your browser opens to sign in to Apify and authorize access. #### Bearer Token Alternative For MCP clients that do not support browser-based OAuth (e.g., Cursor, VS Code, Windsurf), use a Bearer token directly: ```json { "mcpServers": { "apify": { "url": "https://mcp.apify.com", "headers": { "Authorization": "Bearer " } } } } ``` Replace `` with your actual Apify API token from [Apify Console](https://console.apify.com/account/integrations). ### Related Tools - **[UUID Lab](https://apify.com/perryay/uuid-lab)** — Generate and decode UUID v4, v7, and nanoid identifiers for consistent cross-platform user and session tracking. - **[Link Quality Analyzer](https://apify.com/perryay/link-quality-analyzer)** — Deep analysis of links including HTTP status, redirect chains, and security posture. - **[Domain Intel](https://apify.com/perryay/domain-intel)** — WHOIS lookups, DNS enumeration, and SSL certificate validation for brand protection and domain research. # Actor input Schema ## `username` (type: `string`): Single username to check across all platforms ## `usernames` (type: `array`): Array of usernames to check in batch mode ## `platforms` (type: `array`): Optional list of platforms to check (leave empty to check all 50+ platforms) ## `maxConcurrency` (type: `number`): Maximum number of simultaneous platform checks (5-30) ## Actor input object example ```json { "username": "testuser", "usernames": [ "user1", "user2" ], "platforms": [ "GitHub", "Twitter/X", "Instagram" ], "maxConcurrency": 15 } ``` # Actor output Schema ## `results` (type: `string`): Username availability check results in the default dataset # 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 = { "username": "testuser", "usernames": [ "user1", "user2" ], "platforms": [ "GitHub", "Twitter/X", "Instagram" ] }; // Run the Actor and wait for it to finish const run = await client.actor("perryay/social-media-username-checker").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 = { "username": "testuser", "usernames": [ "user1", "user2", ], "platforms": [ "GitHub", "Twitter/X", "Instagram", ], } # Run the Actor and wait for it to finish run = client.actor("perryay/social-media-username-checker").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 '{ "username": "testuser", "usernames": [ "user1", "user2" ], "platforms": [ "GitHub", "Twitter/X", "Instagram" ] }' | apify call perryay/social-media-username-checker --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=perryay/social-media-username-checker", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Social Media Username Checker — Availability Scanner", "description": "Check if a username is available or taken across 50+ social media and professional platforms. Supports batch checking, platform filtering, and concurrent scanning.", "version": "1.0", "x-build-id": "Py1zMWeBwzSqxl8Aq" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/perryay~social-media-username-checker/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-perryay-social-media-username-checker", "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/perryay~social-media-username-checker/runs": { "post": { "operationId": "runs-sync-perryay-social-media-username-checker", "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/perryay~social-media-username-checker/run-sync": { "post": { "operationId": "run-sync-perryay-social-media-username-checker", "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": { "username": { "title": "Username", "type": "string", "description": "Single username to check across all platforms" }, "usernames": { "title": "Usernames (Batch)", "type": "array", "description": "Array of usernames to check in batch mode" }, "platforms": { "title": "Platform Filter", "type": "array", "description": "Optional list of platforms to check (leave empty to check all 50+ platforms)", "default": [] }, "maxConcurrency": { "title": "Max Concurrency", "minimum": 5, "maximum": 30, "type": "number", "description": "Maximum number of simultaneous platform checks (5-30)", "default": 15 } } }, "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 } } } } } } } } } } ```