# Username Checker — Find Profiles Across 460+ Platforms (`automation-lab/username-checker`) Actor

Search for any username across 460+ platforms instantly. Like Sherlock but no install needed — runs in the cloud. Find social media accounts, check username availability, or audit your brand. Covers GitHub, Reddit, Twitter/X, Instagram, TikTok, Steam, YouTube, LinkedIn, and 450+ more.

- **URL**: https://apify.com/automation-lab/username-checker.md
- **Developed by:** [Automation Lab](https://apify.com/automation-lab) (community)
- **Categories:** Social media, Developer tools
- **Features:** Limited permissions, Multi-tenant, Server interface
- **Stats:** 787 total users, 44 monthly users, 99.6% runs succeeded, 3 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.25 / 1,000 username checkeds

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Username Checker — Find Profiles Across 460+ Platforms

Username Checker is the most comprehensive username lookup tool on Apify. Enter any username and instantly see where it is registered across **460+ social media, developer, gaming, music, video, and creative platforms** — with direct profile links, platform categories, and availability status.

Powered by the same platform database as the popular open-source [Sherlock project](https://github.com/sherlock-project/sherlock), but delivered as a fully managed, no-install cloud API with batch processing, JSON/CSV/Excel export, and Zapier/Make integrations.

### What does Username Checker do?

Username Checker scans **460+ social media and web platforms** in seconds to tell you exactly where a username is registered. Enter any username and get a full report showing which platforms have a matching profile, complete with direct links, platform categories, and availability status.

The actor sends lightweight HTTP requests to each platform's profile URL and checks whether the profile exists. No browser automation, no headless Chrome, no Puppeteer — just fast, reliable HTTP checks that run on 256 MB of memory and finish in under a minute.

Use it to audit your own online presence, investigate a brand name before registering it, research someone's digital footprint, or verify that your desired handle is available everywhere you want it.

### Who is it for?

🔎 **OSINT researchers** — Map a person's digital footprint across 460+ platforms in a single API call. Feed results into investigation pipelines or link analysis tools. Works like Sherlock username checker but with no local install required.

🏢 **Brand managers** — Check if your company or product name is already taken on major platforms before launching. Identify squatters and impersonators.

🎨 **Content creators** — Secure a consistent username across YouTube, TikTok, Instagram, Twitch, and 456 other platforms before someone else grabs it.

🛡️ **Cybersecurity professionals** — Detect fake accounts, monitor brand impersonation, and enumerate user presence across services during security assessments.

📊 **Marketing agencies** — Run username audits for clients. Export results to spreadsheets or feed them into dashboards via the API.

👤 **Anyone picking a new username** — Before you commit to a handle, find out where it is already taken and where it is still available.

### Why use this checker?

| | Manual checking | Username Checker |
|---|---|---|
| ⏱️ **Speed** | 30–60 minutes per username | Under 60 seconds per username |
| 🌐 **Coverage** | 10–15 platforms you remember | 460+ platforms, every time |
| 📋 **Output** | Notes in a spreadsheet | Structured JSON with direct profile links |
| 🔄 **Automation** | Copy-paste in browser tabs | API, webhooks, scheduled runs |
| 💰 **Cost** | Your time | $0.005 per saved username-platform result |
| 🔗 **Integrations** | None | Zapier, Make, Google Sheets, Slack, 1000+ apps |
| 📈 **Scalability** | One at a time | Batch check up to 100 usernames per run |
| 🔧 **Setup** | Install Python + Sherlock locally | Zero install — runs in the cloud |

### Platforms checked

Username Checker covers **460+ platforms** across 9 categories:

#### 📱 Social (50+ platforms)

Twitter/X, Instagram, Reddit, TikTok, Snapchat, Pinterest, Tumblr, LinkedIn, Mastodon, Threads, VK, Signal, Telegram, Gravatar, About.me, Linktree, AllMyLinks, Bluesky, Clubhouse, Disqus, Kik, Facebook, Quora, Minds, Mewe, Parler, Gab, Diaspora, Ello, MeWe, and more

#### 💻 Development (80+ platforms)

GitHub, GitLab, BitBucket, HackerOne, Replit, CodePen, npm, PyPI, Docker Hub, HackerRank, LeetCode, Kaggle, Codeforces, DEV Community, Hashnode, Medium, Apple Developer, Asciinema, Codecademy, SourceForge, Stack Overflow, Exercism, Codeberg, Launchpad, and many more

#### 🎨 Creative (60+ platforms)

DeviantArt, Behance, Dribbble, ArtStation, Flickr, Unsplash, VSCO, Wattpad, Archive of Our Own, Imgur, Giphy, Audiojungle, Issuu, 500px, SmugMug, Artfight, Cara, Cohost, and more

#### 🎮 Gaming (50+ platforms)

Steam Community, Xbox Gamertag, Roblox, Minecraft, Lichess, Chess.com, Itch.io, Kongregate, Speedrun, Twitch, Faceit, Tracker.gg, Battlefield, and more

#### 🎵 Music (20+ platforms)

Spotify, SoundCloud, Last.fm, Bandcamp, Genius, Mixcloud, Audiomack, Beatport, and more

#### 📹 Video (15+ platforms)

YouTube, Twitch, Vimeo, DailyMotion, Rumble, Kick, Odysee, PeerTube, and more

#### 💼 Business (30+ platforms)

Freelancer, HubPages, Product Hunt, Gumroad, BuyMeACoffee, Patreon, SlideShare, Redbubble, Fiverr, Ko-fi, and more

#### 📰 News & Blogging (20+ platforms)

Hacker News, Slashdot, WordPress, Blogger, BuzzFeed, Flipboard, Substack, Ghost, and more

#### 🔧 Other (100+ platforms)

Duolingo, Goodreads, Strava, MyAnimeList, Letterboxd, Trello, Instructables, Anilist, Apple Discussions, OpenStreetMap, Wikipedia, Scribd, Keybase, and 90+ more niche platforms

### Data you get

Every result row contains the following fields:

| Field | Type | Description |
|---|---|---|
| `username` | String | The username that was checked |
| `platform` | String | Name of the platform (e.g., "GitHub", "Twitter") |
| `category` | String | Platform category: Social, Development, Creative, Gaming, Music, Video, Business, News, or Other |
| `url` | String | Direct link to the profile page |
| `found` | Boolean | `true` if the username exists on this platform, `false` if available |

By default, results include only found profiles. Turn on `includeNotFound` to save availability rows too, or use `platforms` and `categories` to limit checks to the sites relevant to your workflow.

### How much does it cost to check usernames?

Username Checker uses pay-per-event pricing on Apify:

| Event | Price |
|---|---|
| 🏁 Actor start | $0.005 (one-time per run) |
| ✅ Username-platform result saved | $0.005 per saved result |

#### Cost examples

| Scenario | Saved results | Cost |
|---|---|---|
| One username with ~45 found profiles | 45 | $0.23 |
| One username, 4 selected platforms, all rows saved | 4 | $0.025 |
| Five usernames with ~45 found profiles each | 225 | $1.13 |
| One username, all 463 availability rows saved | 463 | $2.32 |

The result event is charged **per row saved to the dataset**, not per input username. With the default `includeNotFound: false`, only found profiles are saved and charged. Enabling `includeNotFound` saves and charges both found and not-found rows. Platform/category filters can reduce runtime and saved-row charges.

### How to use

1. 🔗 Go to [Username Checker on Apify Store](https://apify.com/automation-lab/username-checker)
2. ✏️ Enter one or more usernames in the **Usernames** field (no @ symbol needed)
3. 🎯 Optionally select exact **Platforms** or whole **Categories**; leave both empty for all 460+
4. ⚙️ Choose whether to include not-found rows and set **Max Usernames**
5. ▶️ Click **Start** to run the actor
6. 📊 View results in the **Dataset** tab — use the "Found Profiles" view to see only confirmed matches
7. ⬇️ Export results as JSON, CSV, Excel, or XML
8. 🔗 Click any profile URL in the results to visit the profile directly

### Input parameters

| Parameter | Type | Required | Default | Description |
|---|---|---|---|---|
| `usernames` | String array | Yes | — | List of usernames to check. Plain usernames only — no @ symbol, no URLs. |
| `platforms` | String array | No | All | Exact platform names to check, matched case-insensitively. |
| `categories` | String array | No | All | Categories to check: Social, Development, Creative, Gaming, Music, Video, Business, News, or Other. |
| `includeNotFound` | Boolean | No | `false` | Save both found and not-found rows. |
| `maxUsernames` | Integer | No | 10 | Maximum number of usernames to process from the list. Range: 1–100. |

When both filters are supplied, the Actor checks their union and removes duplicate platform names. Unknown values are reported; a run fails clearly if none of the supplied names or categories match.

#### Example input

```json
{
    "usernames": ["johndoe", "janedoe", "elonmusk"],
    "platforms": ["GitHub", "Reddit", "TikTok", "Instagram"],
    "categories": ["Development"],
    "maxUsernames": 10
}
```

### Output example

```json
[
    {
        "username": "johndoe",
        "platform": "GitHub",
        "category": "Development",
        "url": "https://www.github.com/johndoe",
        "found": true
    },
    {
        "username": "johndoe",
        "platform": "Twitter",
        "category": "Social",
        "url": "https://x.com/johndoe",
        "found": true
    },
    {
        "username": "johndoe",
        "platform": "Instagram",
        "category": "Social",
        "url": "https://instagram.com/johndoe",
        "found": false
    },
    {
        "username": "johndoe",
        "platform": "Reddit",
        "category": "Social",
        "url": "https://www.reddit.com/user/johndoe",
        "found": true
    },
    {
        "username": "johndoe",
        "platform": "Steam Community (User)",
        "category": "Gaming",
        "url": "https://steamcommunity.com/id/johndoe/",
        "found": false
    }
]
```

Each run produces up to `selected platform count * processed username count` result rows when `includeNotFound` is enabled. With default settings, only found profiles are saved.

### Tips for best results

🔤 **Use plain usernames** — Enter `johndoe`, not `@johndoe` or `https://twitter.com/johndoe`. The actor builds the correct URL for each platform automatically.

📝 **Check variations** — If your preferred username is taken, try variations in the same run: `johndoe`, `john_doe`, `johndoe_`, `thejohndoe`.

📦 **Batch similar checks** — Checking 10 usernames in one run is cheaper than 10 separate single-username runs (you save $0.09 on start fees).

⚡ **Keep batches reasonable** — The actor processes usernames sequentially. A batch of 100 usernames takes longer than a batch of 10. Use `maxUsernames` to cap large lists.

🎯 **Select relevant sites** — Use `platforms` for exact names and `categories` for groups. Selections are case-insensitive and combined, so `platforms: ["GitHub"]` plus `categories: ["Social"]` checks GitHub and every Social platform.

🔍 **Filter results** — Use the "Found Profiles" dataset view in Apify Console to see only platforms where the username exists, or the "All Results" view for the complete picture.

### Integrations

Connect Username Checker to your existing tools and workflows:

🔗 **Zapier** — Trigger username checks when a new row is added to Google Sheets, then write results back automatically.

🔗 **Make (Integromat)** — Build multi-step workflows that check usernames, filter results, and send alerts to Slack or email.

🔗 **Google Sheets** — Export results directly to a spreadsheet for easy sharing and analysis.

🔗 **Slack / Discord** — Get notified when a username is found on specific platforms.

🔗 **Webhooks** — Receive results via HTTP webhook as soon as the run finishes.

🔗 **REST API** — Call the actor programmatically from any language or platform.

Learn more about integrations in the [Apify integrations documentation](https://docs.apify.com/platform/integrations).

### API usage

Call Username Checker programmatically using the Apify API. Here are examples in popular languages:

#### Node.js

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/username-checker').call({
    usernames: ['johndoe', 'janedoe'],
    maxUsernames: 10,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

// Filter to found profiles only
const found = items.filter((item) => item.found);
console.log(`Found ${found.length} profiles across ${new Set(found.map((i) => i.platform)).size} platforms`);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/username-checker').call(run_input={
    'usernames': ['johndoe', 'janedoe'],
    'maxUsernames': 10,
})

items = list(client.dataset(run['defaultDatasetId']).iterate_items())

found = [item for item in items if item['found']]
print(f"Found {len(found)} profiles")
```

#### cURL

```bash
## Start the actor and wait for it to finish
curl -X POST "https://api.apify.com/v2/acts/automation-lab~username-checker/run-sync-get-dataset-items?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "usernames": ["johndoe"],
    "maxUsernames": 10
  }'
```

Get your API token from [Apify Console Settings](https://console.apify.com/account/integrations).

### Server API: check a username over HTTP

Username Checker is also a Server Actor. Besides normal runs, it answers short HTTP requests directly, without starting a run for each username. Copy the server URL from the Actor's **Server** tab (do not build it from the Actor name) and authenticate with your Apify token. Use normal Actor runs for several usernames.

```bash
curl -sS "$SERVER_URL/username?username=apify" -H "Authorization: Bearer $APIFY_TOKEN"
curl -sS "$SERVER_URL/username?username=apify&platforms=GitHub,Reddit&categories=Gaming&includeNotFound=true" -H "Authorization: Bearer $APIFY_TOKEN"
```

| Method and path | Input | Output and charge |
| --- | --- | --- |
| `GET /` | None | `ready: true`, the route, limits, platform count and categories; no check or charge |
| `GET /username` | Query `username` (letters, digits, `.`, `_`, `-`, at most 64; a leading `@` is removed); optional `platforms` (exact names) and `categories`, repeated or comma-separated, combined as a union like normal runs; optional `includeNotFound` (`true`/`false`, default `false`) | `{ok,count,results}` with the same rows as a normal run's dataset: the platforms where the username exists, or every answered platform with `includeNotFound=true`; one Username checked event per returned row, the same unit as a normal run; no start fee |

A request checks every platform by default (460+), at most 100 at a time and 8 seconds per platform, and usually answers in 20–25 seconds; select platforms or categories for a faster answer. Platforms that have not answered when the 45-second deadline approaches are left out of the response (neither found nor not found). Unlike normal runs, an unknown platform or category name is rejected instead of ignored. A username found nowhere is a free 404. Each response is capped at 256 KiB, and one server works on at most three requests at once. Nothing is cached. Errors use `{ "ok": false, "error": { "code": "...", "message": "...", "retryable": false } }`: 400 `INVALID_USERNAME`, `UNKNOWN_PLATFORM`, `UNKNOWN_CATEGORY` or `INVALID_INPUT`; 402 spending limit; 404 `USERNAME_NOT_FOUND` or unknown route; 405 wrong method; 502 `PLATFORMS_UNREACHABLE` (none of the selected platforms answered), `UPSTREAM_ERROR` or charging failure; 503 server busy or stopping; 504 `TIMEOUT` (no platform answered in time). Errors are free. Retry only when `retryable` is true. A successful answer can carry `warning: { code: "CHARGE_INCOMPLETE" }` when only part of its charge went through; you are charged only for what went through. The Server tab shows the full OpenAPI description.

### Diagnostic reporting

When a run or server request fails, Username Checker sends sanitized diagnostic input, the exception and the Actor, build and run IDs to our private GlitchTip service so we can repair it. Secret fields and URL queries are removed, and reports are kept for 30 days.

### MCP integration

Use Username Checker as a tool inside AI assistants via the Model Context Protocol (MCP).

#### Claude Code

Add the actor as an MCP tool from your terminal:

```bash
claude mcp add --transport http apify https://mcp.apify.com?tools=automation-lab/username-checker
```

Or add this to your Claude Code MCP configuration:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/username-checker"
        }
    }
}
```

#### Claude Desktop

Add this to your Claude Desktop configuration file (`claude_desktop_config.json`):

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com?tools=automation-lab/username-checker"
        }
    }
}
```

#### Cursor

Add the same `mcpServers` JSON to `.cursor/mcp.json` in your project.

#### VS Code

Add the server URL to your workspace MCP configuration under `.vscode/mcp.json`, using `apify` as the server name.

#### Example prompts

Once connected, Claude can check usernames for you directly in conversation. Try prompts like:

- "Check if the username `techguru` is available across social media and developer platforms."
- "Find where `brandlaunch2026` is already registered and return the found profile URLs."
- "Check these usernames for GitHub, Reddit, TikTok, and Instagram presence before I pick a brand handle."

### Legality

✅ **Yes.** Username Checker only accesses publicly available profile pages — the same pages any person can visit in a web browser. It does not bypass any login walls, CAPTCHAs, or access controls. It does not scrape private data, personal information, or protected content.

The actor checks whether a profile URL returns a valid page or a "not found" response. This is functionally identical to typing a URL into your browser's address bar.

Key points:

📌 No authentication is used or bypassed on any platform.

📌 No private or protected data is accessed.

📌 No rate-limiting mechanisms are circumvented.

📌 Results contain only the username, platform name, profile URL, and existence status — no personal data is extracted from profiles.

Always ensure your use case complies with applicable laws in your jurisdiction and the terms of service of individual platforms.

### FAQ

**How long does a run take?**
A single username typically completes in 30–60 seconds. Checking 10 usernames takes roughly 5–10 minutes. The actor runs checks concurrently to keep execution times short.

**Why does the actor show 460+ platforms but I see fewer results?**
You should see 460+ results per username — one for each platform. If a platform is temporarily down, it may be marked as `found: false`. Check the "All Results" view to see the complete list.

**Can I check if a username is available (not taken)?**
Yes. Look for results where `found` is `false` — those are platforms where the username is available. Use the dataset filter or export to CSV and sort by the `found` column.

**Does it work with usernames that contain special characters?**
The actor passes usernames as-is to each platform's URL template. Most platforms support letters, numbers, underscores, and hyphens. Spaces and special characters like `@`, `#`, or `!` may produce unreliable results because most platforms do not allow them in usernames.

**Can I schedule recurring checks?**
Yes. Use [Apify Schedules](https://docs.apify.com/platform/schedules) to run the actor on any interval — hourly, daily, weekly. Combine with webhooks to get notified of changes.

**What happens if a platform is temporarily down?**
If a platform returns an error (timeout, 5xx response), the actor may report `found: false` for that platform. Re-run the check later if you suspect a false negative.

**How do I export results?**
In Apify Console, go to the run's Dataset tab and click the export button. Supported formats: JSON, CSV, Excel (XLSX), XML, and RSS. You can also fetch results programmatically via the API.

**Is there a limit on how many usernames I can check?**
Each run supports up to 100 usernames (controlled by the `maxUsernames` parameter). For larger volumes, run the actor multiple times or use the [Apify API](https://docs.apify.com/api/v2) to start multiple concurrent runs.

**Why is a username showing as "found" when the profile does not exist?**
Some platforms return a 200 OK status for non-existent profiles (redirecting to a search page or showing a generic page). The actor handles this with response-body checks where possible, but edge cases may produce false positives. If you notice a consistent false positive, please report it.

**Can I check only specific platforms?**
Yes. Select exact names in `platforms`, whole groups in `categories`, or both. Matching is case-insensitive, mixed selections form a deduplicated union, and leaving both empty preserves the full 460+ platform scan.

### Username Checker vs Sherlock

[Sherlock](https://github.com/sherlock-project/sherlock) is a popular open-source command-line tool for hunting down social media accounts by username. Username Checker is built on the same platform database but runs in the cloud with no installation required.

| | Sherlock (open-source) | Username Checker (this actor) |
|---|---|---|
| 🔧 **Setup** | Python install, pip, CLI | Zero install — just click Run |
| ☁️ **Runs on** | Your local machine | Apify cloud |
| 📤 **Export** | Terminal output / CSV | JSON, CSV, Excel, XML, API |
| 🔗 **Automation** | Shell scripts | Apify API, Zapier, Make, webhooks |
| 📦 **Batch input** | One username at a time | Up to 100 usernames per run |
| 🔔 **Alerts** | None | Webhooks, scheduled runs |
| 🌐 **Platform count** | ~400 | 460+ |

Use Username Checker when you want Sherlock's power without the local setup overhead, or when you need API access, batch processing, or integrations.

### Related tools

🔗 [Username Checker](https://apify.com/automation-lab/username-checker) — This actor

🔗 [Sherlock (open-source)](https://github.com/sherlock-project/sherlock) — The Python CLI this actor is inspired by

Explore more actors from automation-lab on the [Apify Store](https://apify.com/automation-lab).

# Changelog

This Actor's version history is a separate document: https://apify.com/automation-lab/username-checker/changelog.md

# Actor input Schema

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

Usernames to check across platforms. Just the username — no @ symbol needed.

## `platforms` (type: `array`):

Check only these exact platform names. Matching is case-insensitive. Combine with categories to check the union of both selections; leave both empty to check every platform.

## `categories` (type: `array`):

Check every platform in the selected categories. Matching is case-insensitive and selections are combined with specific platforms.

## `includeNotFound` (type: `boolean`):

Include platforms where the username was NOT found. Useful for checking username availability. When off (default), only platforms where the username exists are returned.

## `maxUsernames` (type: `integer`):

Maximum number of usernames to check.

## Actor input object example

```json
{
  "usernames": [
    "apify"
  ],
  "includeNotFound": false,
  "maxUsernames": 3
}
```

# Actor output Schema

## `found` (type: `string`):

Dataset view containing only profiles detected as existing.

## `all` (type: `string`):

Dataset view containing every saved found and not-found row.

# 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"
    ],
    "maxUsernames": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "usernames": ["apify"],
    "maxUsernames": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/username-checker").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"
  ],
  "maxUsernames": 3
}' |
apify call automation-lab/username-checker --silent --output-dataset

```

## MCP server setup

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

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/hXTZCQheAIQW7TFuE/builds/BTUgAkFSnKEhTzCeK/openapi.json