Brand Username Finder & Monitor

Find matching brand usernames across websites and track changes to confirmed public profiles. Check GitHub, GitLab, YouTube, DEV Community, Hugging Face and Keybase, then export profiles to JSON, CSV or Excel.

Use it to audit your brand’s public handles, review similar usernames, maintain a list of creator accounts or monitor profile changes. No source API token or customer login is required. A matching username is a candidate for review; it does not prove that the account belongs to the brand.

What you can do

• Audit brand handles and export confirmed candidate profiles for review.
• Build deduplicated lists of creator or partner accounts across supported websites.
• Monitor known profiles for name, bio, website and public-counter changes.

The Actor checks live public profile pages, supports exact and formatting-variant usernames, and provides coverage reports alongside JSON, CSV and Excel profile exports.

Quick start

1. Enter Brand names or usernames, such as apify.
2. Keep the selected Platforms, or choose the websites you need.
3. Keep Maximum profiles at five for a small run, then click Start.

The form has only these three controls. It is ready to run without configuring technical settings. Known profile URLs, change monitoring, variants, imports and custom request limits remain available through the Console JSON editor or API.

{
  "mode": "usernameSearch",
  "brandNames": ["apify"],
  "maxResults": 5
}

This API example uses all six platforms. It explicitly sets the five-profile limit. The Console starter has a ten-request allowance. The schema retains a three-request API default; the brand-search runtime uses 12 only when maxPublicPages is absent from the input it receives. Schema defaults are applied by Apify, while prefills apply to the Console form.

Five profiles does not guarantee all six platforms are checked. Result, request, time and spending limits can leave pending targets. Read the run summary and coverage before treating a search as complete. Definitive missing or unchanged checks can incur a fee even when they produce no exported row.

The Actor constructs username URLs and checks native public profile markers. It does not search posts, mentions or the entire web. A company’s display name may differ from its handle; use the actual username when you know it.

Supported websites

Website	Input selection	Public profile checked
GitHub	github	User and organization profiles
GitLab	gitlab	Public top-level user and group profiles
YouTube	youtube	@handle pages and known channel URLs
DEV Community	devto	Public member and organization profiles
Hugging Face	huggingface	Public user and organization profiles
Keybase	keybase	Public user profiles

Use this Actor for technology brands and creators with profiles on these six sites. Instagram, Facebook, TikTok, X, LinkedIn and other websites are not included. Public page access can vary, so inspect Platform checks and coverage for blocked or inconclusive checks.

What you receive

Each confirmed profile becomes one dataset row. The same profile found for several input brands is deduplicated, with its matching names attached. The check-results report includes missing, unchanged and inconclusive checks, with their billing status. Only definitive results are eligible for a check fee.

A shortened output example:

{
  "recordType": "profile",
  "searchedName": "apify",
  "platform": "GitHub",
  "username": "apify",
  "profileUrl": "https://github.com/apify",
  "displayName": "Apify",
  "matchedBrands": ["apify"],
  "matchedUsernames": ["apify"],
  "matchType": "exact",
  "affiliationStatus": "unverified",
  "sourceVerified": true,
  "dataInputSource": "web"
}

The default table focuses on matched brands, platform, username, display name, bio, profile URL, website, change type, observation time and source verification. Open Profile details for additional metadata or Watchlist changes for the existing monitoring view. Raw dataset exports retain the complete field set.

Field	Meaning
matchedBrands	Input names that matched this profile; one profile can match several names
platform, username, profileUrl	Website, public handle and actual profile URL
displayName, bio, websiteUrl	Public profile details when the source provides them
scrapedAt	When the profile was observed
changeType, changedFields	Monitoring classification and previous/current values when available
sourceVerified, dataInputSource	Whether native profile markers were confirmed live or the record was imported
followersCountIsApproximate, followersCountText	Whether a count is rounded and how the source displayed it

Available fields include names, bios, profile descriptions, avatars, public website/social links and observation timestamps. Link destinations are not fetched, and links do not prove brand ownership. GitHub organization profiles and user profiles can also include websites, locations, companies, follower counts and public repository counts. Field availability differs by website. Unavailable values remain unknown.

sourceVerified: true means that native public profile markers confirmed the page during collection. It does not verify brand ownership. Missing or blocked pages do not establish that a username is available for registration.

GitHub may abbreviate counts: 2.5k is returned as followersCount: 2500, followersCountIsApproximate: true and followersCountText: "2.5k". Prefer the displayed-count flag when interpreting changes.

Check similar usernames

In the Console JSON editor or API input, set includeVariants to true to check formatting variants such as joined words, hyphens and underscores. Each platform’s username rules apply; unsupported formats are recorded in coverage. The maximum includes the base username.

{
  "mode": "usernameSearch",
  "brandNames": ["Acme Studio"],
  "platforms": ["github", "devto", "youtube"],
  "includeVariants": true,
  "maxVariantsPerName": 3,
  "maxResults": 10,
  "maxPublicPages": 15
}

An exact match uses the supplied username or its basic joined form; a variant match uses an additional formatting variant. Neither classification is an impersonation verdict or a measure of affiliation.

Collect profiles you already know

In the Console JSON editor or API input, set mode to profileUrls and supply exact URLs in ownedProfileUrls. Brand names and platform selections are ignored in this mode. GitHub usernames are also accepted.

{
  "mode": "profileUrls",
  "ownedProfileUrls": ["https://github.com/apify", "https://www.youtube.com/@apify"],
  "maxResults": 5,
  "maxPublicPages": 8
}

The API field ownedProfileUrls is retained for compatibility. Profiles do not need to belong to you. API calls that omit mode retain the original GitHub-only workflow, including the one-profile and three-request defaults; brandNames remains a label in that original workflow.

Monitor profile changes

In the Console JSON editor or API input, set historyName to a monitoring list name and changePolicy to newOrChanged. Run it again with the same list name to compare profiles.

{
  "mode": "usernameSearch",
  "brandNames": ["apify"],
  "platforms": ["github", "youtube"],
  "maxResults": 10,
  "maxPublicPages": 8,
  "historyName": "my-brand-watch",
  "changePolicy": "newOrChanged",
  "monitorFields": ["displayName", "bio", "websiteUrl"]
}

The first run returns baseline profiles. Later runs return new or updated profiles, with changedFields containing previous/current values. Unchanged profiles are suppressed in this mode. Under completed-check pricing, each definitive unchanged check incurs one check fee, with no additional profile-export fee. The start fee still applies.

Monitor available names, bios, websites, avatars, locations, companies or public counters. Use minimumCountChange for a minimum absolute counter change, measured against the last delivered snapshot so smaller changes can accumulate. A positive threshold ignores abbreviated counts that cannot establish an exact change. Missing counters do not erase known counts.

Changing the monitored fields or threshold starts a separate baseline. Cross-platform lists are separate from lists created through the original GitHub-only workflow. Run one job at a time per monitoring list. History retains at most 10,000 profiles and expires observations not seen for 90 days. Failed or omitted checks are not treated as deleted accounts.

Connect change alerts

Open Profile changes and integration report for the CHANGES JSON report. It contains notificationCount, a readable summary and the new/updated profiles with previous/current values. Initial baselines are excluded from notificationCount.

To connect Make, Zapier or a webhook workflow:

1. Configure your Apify integration to trigger when a run succeeds.
2. Read CHANGES from that run’s default key-value store using your authenticated Apify connection.
3. Continue only when notificationCount > 0; send the report’s changes to your chosen destination.
4. Route failed runs or partial coverage to an operational notification separately.

For a webhook, the event’s run resource provides defaultKeyValueStoreId. Retrieve GET https://api.apify.com/v2/key-value-stores/{defaultKeyValueStoreId}/records/CHANGES with your normal Apify authentication. Keep credentials in the integration connection, never in a public webhook URL.

The Actor does not create schedules or send notifications itself. You control run frequency and alert destinations through Apify and your integrations. See the official Make, Zapier and webhook guides for connection setup.

Larger searches and resume

maxResults limits rows delivered in the current run, up to 5,000. maxPublicPages limits HTTP requests, including redirects and retries, up to 1,000. The Console starter uses five profiles and ten requests. Existing schema/API defaults remain one profile and three requests; the brand-search runtime falls back to five profiles and 12 requests only when those fields are absent from the input it receives. Set limits explicitly for predictable API calls. Collection also stops at spending and time limits, leaving a shutdown margin below the five-minute default timeout.

There are no search-results pages to paginate: the Actor checks a finite list of username URLs. For a longer search, supply an optional resumeKey in the Console JSON editor or API input. Reuse that key with identical search and monitoring settings to continue pending work. You may increase result, request or spending limits. The next run returns remaining profiles in its own dataset; the summary links all datasets for the job.

{
  "mode": "usernameSearch",
  "brandNames": ["apify", "openai"],
  "maxResults": 10,
  "maxPublicPages": 12,
  "resumeKey": "brand-audit-october"
}

Use one active run per resume key. A completed key returns its existing completion summary; use a fresh key, or omit it, for a new monitoring cycle. Source checks already completed for a job are not repeated on resume. Start a fresh job to retry checks reported as blocked or inconclusive.

Delivery checkpoints prevent automatic duplicate delivery of confirmed rows. If an append cannot be reconciled, the job stops with DELIVERY_UNCONFIRMED instead of attempting another charge. Inspect the previous dataset or share the run link with support.

Download results and understand coverage

Use All username check results (JSON/CSV) to download the full check list, including requested usernames, outcomes, observation times, change classifications and billing status. These exports are separate from the profile dataset and have no additional export fee. Active pricing and check charges shows the run’s effective rates, charged profile rows, other charged checks and a conservative planned upper-bound price. Blocked, ambiguous, invalid and duplicate checks have no check fee.

Output	Use it for
Current run results	Export confirmed profiles as JSON, CSV or Excel
Run coverage and monitoring summary	Read delivered profiles, job progress, pending targets and stopping reason
All username check results	See found, missing, unchanged and inconclusive outcomes, including check charges
Platform checks and coverage	Review blocked sources, skipped targets and pending work
Profile changes and integration report	Read new/updated profiles and previous/current field values
Active pricing and check charges	Check effective rates and charges for this run

The completion log distinguishes profiles delivered in this run from targets checked across the job. Partial coverage remains partial even when the Actor run succeeds.

After a resumed job, the check-results report includes earlier completed checks as well. The billing summary counts charges for the current run only. The run summary links the profile datasets created across the job.

Import existing profiles

Use providedRecords or providedDatasetId in the Console JSON editor or API input. Imports replace live collection. Each record needs meaningful searchedName, platform and profileUrl values. Imported records are marked sourceVerified: false; original websites are not fetched. Exact duplicate snapshots are removed, with a maximum of 5,000 source records read.

Imports retain the original comparison and validation behavior. The cross-platform monitored-field settings, resume key and change integration report apply to live searches. Optional Profile analysis can find a literal phrase in delivered profile text, without AI or an additional analysis fee.

Pricing and spending limits

The completed-check model is $0.75 per 1,000 definitive website-and-username checks, plus $0.001 per run start at supported memory settings. A check confirms either a public profile or a platform-recognized missing username. Confirmed unchanged profiles count as completed checks.

Each check is billed once. When its profile is exported, the existing profile-result event covers the check. A separate, equally priced completed-check event applies to definitive missing profiles and unchanged profiles suppressed from the dataset. These two fees are mutually exclusive for the same check. Repeated input targets and confirmed duplicate profiles are deduplicated.

Work	Completed-check price
Six definitive checks, including one start	$0.0055
Forty definitive checks, including one start	$0.031
Forty unchanged checks, including one start	$0.031
Imported profile row	$0.00075, plus the run-start fee

Blocked, timed-out, invalid or inconclusive checks incur no check fee. A generic HTTP 404 alone does not establish a chargeable missing profile. A partially completed job charges only its confirmed outcomes. Profile exports, coverage CSV/JSON and profile analysis have no additional feature fee.

The Actor reads each run’s effective pricing and reports it in Active pricing and check charges. Check the Pricing tab for current rates and any scheduled changes. Runs created under an earlier pricing record retain that record; completed work is not retroactively charged.

Set Maximum cost per run to control spending. The default/recommended memory is 256 MB. The Console example has a 10-request allowance; API defaults and accepted input ranges are retained. Resuming a job can incur another start fee, but confirmed prior deliveries and check charges are not charged again. An unresolved charge or append stops the job for review instead of attempting a second charge.

Measured cloud examples

Observed on 28 October 2026 at 256 MB. Prices below describe those particular runs, including one start:

Workflow	Result	Runtime	Charge at that run’s effective rates
Prefilled one-brand search	5 profiles	5.5 seconds	$0.00380 under the earlier pricing record; $0.00475 at current rates
Monitor 40 known profiles and one missing username	39 unchanged, 1 newly confirmed profile, 1 definitive missing check	180.5 seconds	$0.03175
Resume a four-target job, second run	2 remaining profiles and 1 definitive missing check; no repeated profile delivery	4.0 seconds	$0.00325 for this run

The initial 40-profile collection confirmed 39 profiles; one source response was inconclusive. The monitoring run then confirmed the remaining profile. All six supported websites were confirmed across those runs. A successful run can have partial source coverage: check the reports before treating it as complete.

These are measured examples, not guaranteed runtimes. Bulk runs can take several minutes because public-page response times vary. For larger lists, use request limits and resume; no 500-profile cloud benchmark is claimed.

Common questions

Do I need an API key or login? No source API key, login cookies or paid data API is needed. Programmatic use requires your normal Apify connection. The Actor collects reviewed public HTML pages.

Does a missing profile mean the username is available? No. A missing public page does not establish registration availability. A matching username also does not prove ownership or impersonation.

Why is the profile dataset empty? A monitoring run may confirm that every profile is unchanged, or a search may find only missing accounts. Read the check-results and billing reports. Blocked or inconclusive pages are reported separately; if no public profile can be confirmed and source checks are inconclusive, the run fails with a diagnostic.

How do I check every selected website? Set Maximum profiles high enough for the confirmed profiles you expect, and give the run enough public page requests for redirects and retries. The small default stops after five delivered profiles. Read pending targets in the summary; use a resume key to continue unfinished work.

Why can a run with no exported profiles have a charge? Definitive missing and confirmed unchanged checks are completed work and each costs $0.00075, plus the start fee. Blocked and inconclusive checks have no check fee. An exported profile is never also charged the separate check fee.

Python API example

import os
from apify_client import ApifyClient

client = ApifyClient(os.environ["APIFY_TOKEN"])
run = client.actor("thescrapelab/brand-username-profile-monitor").call(
    run_input={
        "mode": "usernameSearch",
        "brandNames": ["apify"],
        "maxResults": 5,
    },
    memory_mbytes=256,
    timeout_secs=300,
    max_total_charge_usd=0.01,
)
if run is None or run["status"] != "SUCCEEDED":
    raise RuntimeError("Collection failed; inspect the run summary.")
for profile in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(profile["platform"], profile["profileUrl"], profile.get("matchedBrands"))
summary = client.key_value_store(run["defaultKeyValueStoreId"]).get_record("RUN_SUMMARY")
print(summary["value"])

Existing API integrations

Keep mode: "usernameSearch" in new brand-search API requests. Omitting mode intentionally selects the original GitHub workflow; brandNames alone does not switch it to cross-platform search. Existing field names, accepted values, defaults and output fields are retained.

The form contains no legacy or advanced sections. Existing JSON/API inputs remain accepted with the same values and defaults. Inactive fields (maxSitesPerName, scanMode, sources, proxyConfiguration) do not enable extra websites or change collection.

Coverage and support

Only reviewed public HTML pages are collected. No source APIs, customer login sessions, search engines or child Actors are used. Public access can change. Inspect coverage for per-platform outcomes and pending work; a successful Actor run can still have partial coverage.

Use the Store Issues tab with the run link and a sanitized input example for support. Avoid sharing credentials or private profile information.

Two pilot workflows

Brand-handle audit: enter a brand, enable up to three formatting variants, and review the profile dataset alongside the full check-results CSV. Share confirmed candidate URLs with your team for manual affiliation review.

Profile-change watchlist: provide your known profile URLs, choose a monitoring list name, select names/bios/websites as monitored fields, and return new or changed observations. Connect the change report to your own Apify integration. Run once to establish a baseline and again to evaluate whether the changes are useful for your workflow.