# Social Media Profile Finder | Username Search (`arjun_code/username-profile-finder`) Actor

Find public social media profiles by username across social networks, forums and community sites. Search in bulk and extract available LinkedIn, Reddit and GitHub profile details. Export matching profile URLs and structured data to JSON, CSV or Excel.

- **URL**: https://apify.com/arjun\_code/username-profile-finder.md
- **Developed by:** [Arjun AI](https://apify.com/arjun_code) (community)
- **Categories:** Social media
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 username search — up to 100 websites

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

### Find social media profiles by username

Turn a username into a list of matching public profiles, with profile links and available account details in one dataset. **Social Media Profile Finder** searches social networks, forums and developer websites, helping you review a brand's online presence, research public accounts or check your own digital footprint.

Enter one handle or a batch of usernames. Choose specific websites, filter by site category, or start with the default 50-site search. Export successful matches to JSON, CSV or Excel without installing a command-line OSINT tool.

### Why use this profile finder?

- **Bulk username search:** check multiple handles in one run. Duplicate inputs are searched once.
- **Targeted coverage:** choose from a catalog of 2,555 site definitions, with 144 category and region tags. Catalog coverage is not a guarantee of live availability.
- **More than profile links:** extract available public details, including supported LinkedIn, Reddit and GitHub fields.
- **Results you can work with:** get one row per successful username-and-site match. Unsuccessful and unresolved checks stay out of the results table.
- **Built-in retrieval:** Reddit authentication and eligible residential-proxy retries are handled internally. There are no proxy or Reddit credential fields to configure.
- **Ready for workflows:** run in Apify Console or through the API, schedule repeat searches, and export results for a spreadsheet or another application.

For searches across multiple sites or usernames, available matches may appear before the full run finishes, so you can begin reviewing the results while the search continues.

#### What can you use it for?

- **Brand research:** find accounts using a brand handle and review their links and public descriptions.
- **Your own account audit:** check where your usernames appear and identify profiles to review or update.
- **Public developer research:** find matching profiles on developer websites and collect available biographies and project-related account metrics.
- **Authorized OSINT research:** gather username matches as leads for manual review, with source URLs you can inspect.

Matching usernames are leads, not proof that profiles belong to the same person.

### How to find profiles in three steps

1. Enter one or more **Usernames**. Use account handles, not full names, email addresses or profile URLs.
2. Optionally choose **Specific sites** or **Site categories / regions**. Leave both empty for the default 50-site search.
3. Select **Start**, open **Profile results**, and export the matches. Open **Search summary** if you need to understand missing or unresolved results.

The only required input is `usernames`:

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

Leading `@` and surrounding whitespace are removed. For a smaller first search, select a few websites:

```json
{
  "usernames": ["apify"],
  "sites": ["GitHub", "Reddit"]
}
```

#### Search LinkedIn by profile identifier

For LinkedIn, enter the identifier after `/in/` in a profile URL. For example, `https://www.linkedin.com/in/williamhgates` uses the username `williamhgates`:

```json
{
  "usernames": ["williamhgates"],
  "sites": ["LinkedIn"]
}
```

This retrieves a known profile identifier; it is not a LinkedIn full-name search. LinkedIn lookup does not include email enrichment.

#### Search a category of websites

```json
{
  "usernames": ["apify", "crawlee"],
  "tags": ["coding"],
  "maxSites": 50
}
```

This selects up to 50 matching developer-related websites for each username. Tags describe the websites, not a person's interests, profession or location.

### What data will you get?

The default table keeps five columns: **Username**, **Site**, **Profile URL**, **Public profile fields** and **Checked at**. Each row is a successful match on one website. The underlying JSON also retains `status` and technical check metadata.

| Source | Available profile details |
|---|---|
| LinkedIn | Name, headline, about, photo, location, current positions, experience, education, skills, connections and followers |
| Reddit | Username, account creation time, avatar, karma and available public profile-page details |
| GitHub | Available native fields such as display name, bio, website, avatar, followers and public repository counts |
| Other websites | Profile URL and available public account details |

Fields vary by website and account. A matching account may return a profile URL with `profile: {}` when account details are unavailable or extraction is not supported.

#### Example output

These are shortened excerpts from an actual run for the username `apify` on September 7, 2026. Technical metadata and some profile fields are omitted here for readability; subsequent runs can return different values.

```json
[
  {
    "username": "apify",
    "site": "GitHub",
    "url": "https://github.com/apify",
    "status": "found",
    "profile": {
      "fullname": "Apify",
      "bio": "Put the web to work.",
      "blog_url": "https://apify.com/",
      "follower_count": "2295",
      "public_repos_count": "259"
    },
    "checkedAt": "2026-09-07T14:37:09.120249+00:00"
  },
  {
    "username": "apify",
    "site": "Reddit",
    "url": "https://www.reddit.com/user/apify",
    "status": "found",
    "profile": {
      "name": "Apify",
      "created_utc": 1538483006,
      "total_karma": 1,
      "link_karma": 1,
      "comment_karma": 0
    },
    "checkedAt": "2026-09-07T14:37:09.120249+00:00"
  }
]
```

Profile field names and JSON types vary by website. For example, GitHub's `follower_count` can be a string, while Reddit's `total_karma` is a number. These are website-specific account details, not a single normalized person record.

### Input parameters

Most searches need only a username and, optionally, a website selection. Timing and extraction settings are grouped under **Advanced settings**.

| Parameter | Default | What it controls |
|---|---|---|
| `usernames` | Required | One or more account handles. Duplicate entries are checked once. |
| `sites` | Empty | Exact website names, case-insensitive. An explicit selection overrides `maxSites`; `tags` still applies. |
| `tags` | Empty | Website category or region filters. Multiple tags match any selected tag. |
| `maxSites` | `50` | Maximum sites per username when `sites` is empty, ordered by the bundled database's site rank. |
| `timeoutSeconds` | `15` | Per-site timeout for ordinary website checks. LinkedIn uses the run's overall timeout. |
| `maxConcurrency` | `20` | Concurrent ordinary website checks per username. It does not change LinkedIn concurrency. |
| `extractProfile` | `true` | Include available public account details. Turning it off leaves `profile` empty but still performs all selected account checks. |

Specific sites and tags are filters for the same username search, not different search modes. If you combine them, a website must match your site selection and at least one selected tag. No matches between the filters means there are no sites to search.

### Export, API and scheduled searches

Use the results table for a quick review, or export to **JSON, CSV or Excel** from Apify Console. Choose JSON when you need to preserve nested profile objects, arrays and source field types. The complete records also contain `httpStatus`, `tags`, `rank`, `error`, `proxyRetries` and `initialError`; these are hidden from the default table to keep it readable.

Use this Actor's **API** tab for ready-made request examples. API clients send the same input JSON and read the run's default Dataset. The **Search summary** output links to the `OUTPUT` record, which contains selected sites and per-username outcome counts.

Apify schedules let you run the same search again at a chosen time. Each run is a fresh snapshot; the Actor does not automatically compare runs or produce change alerts. You can pass the resulting datasets to your own comparison or reporting workflow.

### Pricing

The Actor charges **$0.02 per username-search unit**. One unit covers one username checked across up to 100 websites. Each additional block of up to 100 checked websites adds another unit. For example, one username checked on 50 websites costs $0.02; on 150 websites it costs $0.04. Ten usernames checked on 50 websites each cost $0.20.

Profile extraction and automatic retries are included. There is no separate startup fee or per-result fee. Completed searches are charged even when no profiles are found or a website response is inconclusive. Duplicate input usernames, filtered-out websites, and website checks rejected before a request are not charged again or counted as billable checks. One result means one successful username-and-site match, not one unique person.

Set your **maximum cost per run** in Apify Console. Before searching, the Actor allocates this budget to usernames in input order using the selected website count. If the budget cannot cover the full request, later usernames or websites may be skipped. This allocation is conservative: checks that do not run are not charged, and unused capacity is not reassigned during that run. **Search summary** shows the planned scope, billable checks and charged units. Check the current price in Console before a larger batch.

### Frequently asked questions

#### How many websites can I search?

The Actor's catalog contains 2,555 active HTTP site definitions and 144 tags. By default, the Actor selects the top 50 sites per username. Increase `maxSites` to broaden the search or select specific websites directly. Disabled entries, non-HTTP protocols and known non-profile entries are excluded; mirror websites are not added automatically.

These counts describe the bundled Maigret 0.6.5 catalog, not thousands of independently verified live integrations. Websites can change their pages, require login, limit requests or become unavailable. Account detection and full-profile extraction also have different coverage.

#### Why is there no result for a website?

Only successful matches are written to Dataset. An absent row can mean the username was not found, was invalid for that site's rules, or could not be checked conclusively. Check the final run message and **Search summary** for the distinction. A blocked or timed-out request is not treated as proof that an account does not exist.

For a focused follow-up, select the website directly and confirm its exact name in the site selector. If a category filter excludes it, clear that filter. When no eligible websites remain, the Actor stops with an input error and explains the selection problem in Search summary. For LinkedIn, use the profile identifier rather than the person's display name.

#### Why is a found profile empty?

The Actor can find a matching profile URL even when account details cannot be extracted. `extractProfile: false` also produces an empty profile. This does not remove the successful profile link.

#### Do I need proxies, cookies or Reddit credentials?

There are no proxy, cookie or Reddit authentication inputs. The Actor manages Reddit authentication internally and retries eligible blocked website checks once through Apify Residential Proxy. Successful checks are not retried. Switching a proxy does not guarantee access, and the Actor does not solve CAPTCHAs or unlock private profiles.

#### Does it search by name, email address or phone number?

No. This Actor searches usernames and handles only. It does not offer email or phone-number lookup, recursively search newly discovered identities, or prove that matching accounts belong to the same person.

#### How long does a search take?

Runtime depends on the number of usernames, selected websites, timeouts and website response times. Choose fewer sites for a smaller search; increasing concurrency alone does not guarantee faster results.

### Data sources and support

Powered by [Maigret](https://github.com/soxoj/maigret).

Use the Actor for your own accounts, public organizations or authorized research. Review source profiles before drawing conclusions, and follow applicable website terms and data-use requirements.

For a website issue or feature request, open this Actor's **Issues** tab with the affected site, expected behavior and run ID. Do not include API tokens, passwords or other credentials. If the username is sensitive, use Apify's run-sharing controls instead of posting it publicly.

[Try a username search in Apify Console](https://console.apify.com/actors/NUhkaUhxM5GvFDCzJ).

# Actor input Schema

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

Enter account usernames or handles, not full names or profile URLs. Leading @ and surrounding whitespace are removed; duplicate inputs are checked once. For LinkedIn, use the identifier after /in/ in the profile URL.

## `sites` (type: `array`):

Optional: select websites from the list or enter their exact names, such as GitHub, Reddit or LinkedIn. Names are case-insensitive. Leave empty to search the highest-ranked matching sites (50 by default). This selection overrides Maximum sites; site-category filters still apply.

## `tags` (type: `array`):

Select or enter Maigret site tags. Labels show counts across the Actor's eligible website catalog, not live availability. Multiple tags use OR; explicit sites further narrow the selection. These describe websites, not account owners.

## `maxSites` (type: `integer`):

Number of highest-ranked matching websites to search per username when Specific sites is empty. Default 50. This limit is ignored when you choose specific websites.

## `timeoutSeconds` (type: `integer`):

Time allowed for each ordinary website check. LinkedIn retrieval uses a separate provider and the run's overall timeout.

## `maxConcurrency` (type: `integer`):

Simultaneous ordinary website checks per username. Usernames are processed sequentially in that pipeline, alongside a separate LinkedIn batch. This does not change the LinkedIn provider's concurrency.

## `extractProfile` (type: `boolean`):

Return available account details inside profile, including supported LinkedIn, Reddit and GitHub fields. Availability varies by site. Turn off to return profile links without details; all selected account checks still run. No additional usernames are searched.

## Actor input object example

```json
{
  "usernames": [
    "apify"
  ],
  "sites": [],
  "tags": [],
  "maxSites": 50,
  "timeoutSeconds": 15,
  "maxConcurrency": 20,
  "extractProfile": true
}
```

# Actor output Schema

## `profiles` (type: `string`):

Successful username matches with profile URLs and available public account details.

## `summary` (type: `string`):

Selected sites, completed checks, match counts, unresolved checks and billing units. Includes searches skipped by the run budget.

# 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": [
        "apify"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("arjun_code/username-profile-finder").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": ["apify"] }

# Run the Actor and wait for it to finish
run = client.actor("arjun_code/username-profile-finder").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "apify"
  ]
}' |
apify call arjun_code/username-profile-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,arjun_code/username-profile-finder"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/NUhkaUhxM5GvFDCzJ/builds/ilZU4aic0pPwj9RbL/openapi.json