Username Profile Finder

Find public profile pages for one or more usernames across a curated set of social, developer, publishing, and community websites. This public profile finder is a practical username checker when you need exportable evidence rather than a manual browser search.

Use this Actor for brand monitoring, OSINT triage, trust and safety checks, recruiting research, lead enrichment, or manual impersonation audits where you need structured public profile-existence evidence instead of screenshots or one-off browser checks.

At a glance

• Primary job: Check whether a handle has observable public profile pages on selected platforms.
• Input: Usernames plus an optional platform allowlist, output mode, concurrency, and timeout controls.
• Output: One dataset row per saved profile/check with status, HTTP code, final URL, detection method, timing, and rule metadata.
• Best for: Public profile discovery, brand handle audits, manual OSINT workflows, and repeatable exports to CSV, JSON, Excel, API, or automations.

Who is it for?

• Brand and trust teams checking whether public handles appear across selected websites.
• Recruiters and researchers building a small, auditable set of public profile links from known usernames.
• Developers and analysts who need structured status rows rather than manual browser checks.

Common workflows

• Profile discovery: Enter one handle and get confirmed public profile URLs across the curated default platforms.
• Brand monitoring: Check brand, product, or executive handles and compare repeat runs manually.
• Trust and safety triage: Export all statuses to see which checks were found, not found, blocked, or uncertain.
• Lead/recruiting research: Enrich a short list of public usernames with developer and community profile URLs.

Ready-to-run examples

Open a public example to inspect its input, run it, or reuse it as a task:

• Export Username Platform Statuses
• Check Brand Username Presence
• Find Public Username Profiles

What data can you extract?

Field	Description
username	Original input username.
normalizedUsername	Username after trimming whitespace and leading @.
platform / platformKey	Human-readable platform name and stable platform key.
platformDomain	Domain checked for the platform.
profileUrl	Public profile URL template filled with the username.
found	Boolean indicating a confirmed public profile match.
status	found, not_found, blocked, skipped, invalid_username, timeout, error, or unknown.
httpStatus	HTTP status code when a request was made.
finalUrl	Final URL after redirects, when available.
detectionMethod	Rule used to classify the result.
matchedPattern	HTTP code, text pattern, or regex that influenced classification.
category / isNsfw	Platform metadata from the bundled rules.
elapsedMs	Milliseconds spent on the check.
errorType / errorMessage	Request error details for timeout/error rows.
checkedAt	ISO timestamp for the check.
rulesVersion	Bundled rule snapshot version.

Input configuration

Setting	JSON key	Use it for	Example
Usernames	usernames	Handles to check; leading @ is removed.	["octocat", "github"]
Platforms	platforms	Optional allowlist of supported platform keys.	["github", "npm"]
Output mode	outputMode	Save only found profiles or every check status.	"foundOnly"
Maximum platforms	maxPlatforms	Cap checks per username.	10
Maximum concurrency	maxConcurrency	Parallel platform checks.	5
Timeout seconds	timeoutSecs	Per-platform request timeout.	8
Include rule metadata	includeRuleMetadata	Keeps metadata fields in output.	true

Example input

{
  "usernames": ["octocat"],
  "platforms": ["github", "gitlab", "npm", "hackernews", "devto"],
  "outputMode": "foundOnly",
  "maxPlatforms": 5,
  "maxConcurrency": 3,
  "timeoutSecs": 8,
  "includeRuleMetadata": true
}

Example output

{
  "username": "octocat",
  "normalizedUsername": "octocat",
  "platform": "GitHub",
  "platformKey": "github",
  "platformDomain": "github.com",
  "profileUrl": "https://github.com/octocat",
  "found": true,
  "status": "found",
  "httpStatus": 200,
  "finalUrl": "https://github.com/octocat",
  "detectionMethod": "http_status_final_url",
  "matchedPattern": "200",
  "category": "developer",
  "isNsfw": false,
  "elapsedMs": 542,
  "errorType": null,
  "errorMessage": null,
  "checkedAt": "2026-07-25T08:15:04.000Z",
  "rulesVersion": "2026-07-25-curated-v1"
}

Pricing

The Actor charges when a run starts and once for each saved profile or requested check-diagnostic row. foundOnly charges only for confirmed profile rows; allChecks also saves and charges for the requested diagnostic rows. See the live Apify Pricing tab for current rates and volume tiers.

Tips for best results

• Start with found-only mode: It keeps datasets focused on confirmed public profile URLs.
• Use all-checks mode for audits: It records blocked and not-found checks so you can see coverage gaps.
• Keep lists bounded: Public websites may throttle broad sweeps, so use focused usernames and platform sets.
• Read statuses carefully: blocked, unknown, or timeout does not mean a username is available; it means the public check could not confirm a profile.

API usage

Node.js:

import { ApifyClient } from "apify-client";

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor("fetch_cat/username-profile-finder").call({
  usernames: ["octocat"],
  platforms: ["github", "npm", "devto"],
  outputMode: "foundOnly",
  maxPlatforms: 3
});
console.log(run.defaultDatasetId);

Python:

from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("fetch_cat/username-profile-finder").call(run_input={
    "usernames": ["octocat"],
    "platforms": ["github", "npm", "devto"],
    "outputMode": "foundOnly",
    "maxPlatforms": 3,
})
print(run["defaultDatasetId"])

cURL:

curl -X POST "https://api.apify.com/v2/acts/fetch_cat~username-profile-finder/runs?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"usernames":["octocat"],"platforms":["github","npm","devto"],"outputMode":"foundOnly","maxPlatforms":3}'

MCP and AI agents

Use this Actor from MCP-compatible tools through the official Apify MCP Server.

$claude mcp add --transport http apify "https://mcp.apify.com?tools=fetch_cat/username-profile-finder"

JSON config example:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=fetch_cat/username-profile-finder"
    }
  }
}

Example prompt: "Run Username Profile Finder for octocat on GitHub, npm, and DEV, then summarize found profile URLs and blocked checks."

Limits and caveats

• Public-only: This Actor checks public profile pages only. It does not use credentials or access private account data.
• Not an availability guarantee: A not-found or blocked status must not be treated as proof that a username can be registered.
• Platform blocking varies: Some websites return 403, challenges, redirects, or soft-404 pages; those are recorded as diagnostic statuses.
• Curated V1 coverage: V1 uses a smaller high-confidence rule set rather than claiming exhaustive Sherlock/Maigret coverage.

Legality and responsible use

Process only data you are allowed to access. Follow website terms, Apify's terms, and applicable laws. Do not use this Actor for harassment, credential attacks, private enrichment, or breach/leak workflows.

Related actors

• Website Contact Finder
• Website Social Profile Finder
• GitHub Profile Scraper
• LinkedIn Jobs Scraper
• Google Maps Lead Finder

FAQ

Why did a known profile show as blocked or unknown?

The website may have returned a challenge, redirect, temporary error, or response that the V1 rule cannot safely classify. The Actor avoids false positives from blocked or uncertain pages.

Can I export results?

Yes. Apify datasets support JSON, CSV, Excel, XML, RSS, and API access.

Support

Open an issue from the Actor page if a run fails or output looks wrong. Include the run ID or run URL, input JSON, expected output, actual output, and one reproducible public URL or username/platform pair.