Gmail Username Availability Checker

Gmail Username Checker

Check Gmail username availability in bulk. Gmail Username Checker validates @gmail.com usernames, checks whether Gmail returns a final available or taken result, and exports clean rows for brand naming, account planning, and workflow automation.

Validate up to 500 Gmail usernames per run, normalize mixed username and @gmail.com inputs, and download definitive availability results in JSON, CSV, or Excel.

Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

Actor: parsebird/gmail-username-checker - checks Gmail @gmail.com username availability in bulk. Input: {"targets": ["brandname2026", "launch.team@gmail.com"], "proxyConfiguration": {"useApifyProxy": true}}. targets is required, accepts 1-500 strings, supports usernames, full @gmail.com addresses, newline-separated text, comma-separated text, or a mix. Output fields: input, username, email, validUsername, availabilityStatus, available, reason, sourceProvider, sourceQueryType, runStatus, checkedAt. Run with ApifyClient("YOUR_TOKEN").actor("parsebird/gmail-username-checker").call(run_input=input). API spec: https://apify.com/parsebird/gmail-username-checker/api. Token: https://console.apify.com/account#/integrations.

What does Gmail Username Checker do?

Gmail Username Checker is a Gmail username availability checker for bulk @gmail.com name validation. Paste usernames such as brandname2026 or full addresses such as launch.team@gmail.com, and the Actor normalizes each value into a Gmail username and email address.

• Bulk username checks - Process up to 500 Gmail usernames in one run.
• Input cleanup - Accept one value per line, comma-separated text, or a mixed list.
• Gmail format validation - Return invalid rows for usernames that do not match supported Gmail username rules.
• Final-result output only - Save available, taken, or invalid rows. If Gmail does not return a clear availability result at that moment, the Actor skips that username.
• Apify platform workflow - Use scheduling, API access, integrations, and export formats including JSON, CSV, and Excel.

Gmail Username Checker is useful when you need a lightweight Gmail availability API alternative for checking public registration availability signals. It does not create, reserve, or manage Google Accounts.

What data can you extract with Gmail Username Checker?

Field	Type	Description
input	string	Original username or Gmail address you entered
username	string	Normalized Gmail username
email	string	Full normalized @gmail.com address
validUsername	boolean	Whether the input matched the supported Gmail username format
availabilityStatus	string	available, taken, or invalid
available	boolean/null	true when available, false when taken, otherwise null
reason	string/null	Gmail validation message when invalid, otherwise null
sourceProvider	string	Source provider, set to gmail
sourceQueryType	string	Query type, set to registration_availability
runStatus	string	Row status, set to ok for final saved rows
checkedAt	string	UTC timestamp when the username was checked

How to use Gmail Username Checker

1. Open Gmail Username Checker and click Try for free.
2. Add Gmail usernames or full @gmail.com addresses to Gmail usernames.
3. Keep proxy settings empty for the default no-proxy behavior, or enable Apify Proxy for larger batches.
4. Click Start.
5. Open the Dataset tab and download the final rows as JSON, CSV, Excel, or HTML.

You can also run Gmail Username Checker via the Apify API, schedule recurring checks with Apify Scheduler, or connect results to Apify integrations.

Input parameters

Parameter	Type	Required	Default	Description
targets	string[]	Yes	-	Gmail usernames or full @gmail.com addresses. Supports one per line, comma-separated text, or mixed values.
proxyConfiguration	object	No	No proxy	Optional Apify Proxy settings for environments where direct requests are restricted.

Output example

[
  {
    "input": "brandname2026",
    "username": "brandname2026",
    "email": "brandname2026@gmail.com",
    "validUsername": true,
    "availabilityStatus": "available",
    "available": true,
    "reason": null,
    "sourceProvider": "gmail",
    "sourceQueryType": "registration_availability",
    "runStatus": "ok",
    "checkedAt": "2026-06-15T21:36:54.744Z"
  },
  {
    "input": "bad",
    "username": "bad",
    "email": "bad@gmail.com",
    "validUsername": false,
    "availabilityStatus": "invalid",
    "available": null,
    "reason": "Gmail usernames must be 6-30 characters and use only letters, numbers, and periods.",
    "sourceProvider": "gmail",
    "sourceQueryType": "registration_availability",
    "runStatus": "ok",
    "checkedAt": "2026-06-15T21:36:55.102Z"
  }
]

Download results in JSON, CSV, HTML, or Excel format from Apify Console or through the dataset API.

Use cases

• Brand name research - Check whether campaign, product, or startup Gmail names are available.
• Launch planning - Validate candidate Gmail addresses before creating public account naming docs.
• Creator workflows - Test Gmail username ideas for newsletters, channels, and community projects.
• Agency operations - Check client naming options in repeatable batches.
• No-code automation - Send results to Google Sheets, Zapier, Make, Slack, or a CRM through Apify integrations.
• Monitoring - Schedule recurring checks for a shortlist of target usernames.

How it works

1. Input expansion - Splits newline-separated and comma-separated values.
2. Normalization - Converts full @gmail.com addresses into usernames and lowercases the Gmail domain.
3. Validation - Allows 6-30 characters using letters, numbers, and periods, and rejects malformed period placement.
4. Availability check - Opens a headless browser, walks the Google Account signup flow, and reads the final Gmail username validation result.
5. Final-row filtering - Saves only available, taken, or invalid rows. Ambiguous Google responses are logged and skipped.
6. Export - Pushes final rows to the default Apify dataset.

How much does it cost to check Gmail username availability?

Gmail Username Checker uses pay-per-event pricing. One event is charged for each final row pushed to the dataset, including invalid rows. Ambiguous Gmail responses that are skipped are not charged by the Actor.

Plan	Price per event	Price per 1,000 Gmail usernames
Free, Bronze, Silver	$0.008	$8.00
Gold	$0.007	$7.00

Example: Checking 1,000 final Gmail username rows costs $8.00 on Free, Bronze, or Silver, and $7.00 on Gold. You can try Gmail Username Checker with the free monthly credits included on Apify plans where applicable. Because Gmail Username Checker uses a browser-based validation flow, review run costs after the first Apify platform runs and adjust pricing if needed.

Integrations and API access

Gmail Username Checker runs on the Apify platform, so you can use:

• Scheduling - Run checks daily, weekly, or on a custom interval.
• API access - Start runs from the REST API or Apify client libraries.
• Integrations - Connect to Google Sheets, Slack, Zapier, Make, webhooks, and other workflows.
• Export formats - Download dataset rows as JSON, CSV, Excel, HTML, RSS, or XML.

Python example

from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run_input = {
    "targets": [
        "brandname2026",
        "launch.team@gmail.com"
    ]
}

run = client.actor("parsebird/gmail-username-checker").call(run_input=run_input)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["email"], item["availabilityStatus"])

JavaScript example

import { ApifyClient } from 'apify-client';

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

const input = {
    targets: [
        'brandname2026',
        'launch.team@gmail.com'
    ]
};

const run = await client.actor('parsebird/gmail-username-checker').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();

for (const item of items) {
    console.log(`${item.email}: ${item.availabilityStatus}`);
}

Limits and caveats

• Only Gmail @gmail.com usernames are supported.
• Usernames must be 6-30 characters and can use letters, numbers, and periods.
• Gmail availability can change after a run if someone registers a username later.
• If Gmail does not return a clear availability result at that moment, the Actor skips that username instead of saving a non-final row.
• The Actor checks availability only. It does not create, reserve, or manage Google accounts.

Is it legal to check Gmail username availability?

Gmail Username Checker only checks public registration availability signals for usernames supplied by the user. It does not log in, access inboxes, create accounts, reserve usernames, or bypass account controls. You are responsible for using the Actor in compliance with Google's terms, privacy rules, and applicable laws. For general context, read Apify's guide on the legality of web scraping.

Other ParseBird actors and related tools

• Website Contact Finder - Extract emails, phone numbers, and social profiles from websites.
• HTTP Request - Send HTTP requests from Apify workflows.
• Data Deduplicator - Remove duplicate records from datasets.
• Data Cleaner - Clean and normalize structured dataset rows.

FAQ

Can Gmail Username Checker create or reserve a Gmail account? No. The Actor only checks availability signals. It does not create, reserve, or manage Google accounts.

Can I check non-Gmail addresses? No. Only Gmail @gmail.com usernames are supported. Inputs with other domains are returned as invalid rows.

Why was a valid username skipped? The Actor skips a username when Gmail does not return a clear final availability result at that moment. This avoids saving guessed rows.

Can I schedule recurring Gmail username checks? Yes. Use Apify Scheduler to run the Actor at a recurring interval.

Can I use Gmail Username Checker as an API? Yes. Use the API tab, Apify REST API, or the Python and JavaScript client examples above.

What should I do if Gmail blocks or rate-limits checks? Reduce batch size, wait before retrying, or enable Apify Proxy in the advanced input section. The Actor skips unclear responses instead of saving non-final rows.

Where can I report issues or request changes? Use the Issues tab on the Apify Actor page and include a sample input that reproduces the problem.