# Gmail Username Availability Checker (`parsebird/gmail-username-checker`) Actor
Check Gmail username availability in bulk. Validate @gmail.com usernames, detect available or taken names, schedule runs, use the API, and export JSON, CSV, or Excel.
- **URL**: https://apify.com/parsebird/gmail-username-checker.md
- **Developed by:** [ParseBird](https://apify.com/parsebird) (community)
- **Categories:** Automation, Developer tools, Agents
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet
## Pricing
from $7.00 / 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/platform/actors/running/actors-in-store#pay-per-event
## What's an Apify Actor?
Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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
### 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](https://accounts.google.com/).
### 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](https://apify.com/parsebird/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](https://docs.apify.com/platform/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](https://docs.apify.com/api/v2), schedule recurring checks with [Apify Scheduler](https://docs.apify.com/platform/schedules), or connect results to [Apify integrations](https://docs.apify.com/platform/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
```json
[
{
"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](https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event). 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](https://apify.com/pricing) 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](https://docs.apify.com/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
```python
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
```javascript
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](https://blog.apify.com/is-web-scraping-legal/).
### Other ParseBird actors and related tools
- [Website Contact Finder](https://apify.com/parsebird/website-contact-finder) - Extract emails, phone numbers, and social profiles from websites.
- [HTTP Request](https://apify.com/parsebird/http-request-actor) - Send HTTP requests from Apify workflows.
- [Data Deduplicator](https://apify.com/parsebird/dataset-deduplicator) - Remove duplicate records from datasets.
- [Data Cleaner](https://apify.com/parsebird/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](https://docs.apify.com/platform/schedules) to run the Actor at a recurring interval.
**Can I use Gmail Username Checker as an API?**
Yes. Use the [API tab](https://apify.com/parsebird/gmail-username-checker/api), 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.
# Actor input Schema
## `targets` (type: `array`):
Enter Gmail usernames or full @gmail.com addresses. You can paste one value per line, comma-separated text, or a mix of both. Only @gmail.com usernames are supported.
## `proxyConfiguration` (type: `object`):
Optional Apify Proxy settings. Leave empty for the default no-proxy behavior.
## Actor input object example
```json
{
"targets": [
"brandname2026",
"launch.team@gmail.com"
]
}
```
# Actor output Schema
## `dataset` (type: `string`):
No description
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"targets": [
"brandname2026",
"launch.team@gmail.com"
]
};
// Run the Actor and wait for it to finish
const run = await client.actor("parsebird/gmail-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "targets": [
"brandname2026",
"launch.team@gmail.com",
] }
# Run the Actor and wait for it to finish
run = client.actor("parsebird/gmail-username-checker").call(run_input=run_input)
# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
print(item)
# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start
```
## CLI example
```bash
echo '{
"targets": [
"brandname2026",
"launch.team@gmail.com"
]
}' |
apify call parsebird/gmail-username-checker --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=parsebird/gmail-username-checker",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Gmail Username Availability Checker",
"description": "Check Gmail username availability in bulk. Validate @gmail.com usernames, detect available or taken names, schedule runs, use the API, and export JSON, CSV, or Excel.",
"version": "1.1",
"x-build-id": "yTPDk4qquoAhSkpch"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/parsebird~gmail-username-checker/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-parsebird-gmail-username-checker",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/parsebird~gmail-username-checker/runs": {
"post": {
"operationId": "runs-sync-parsebird-gmail-username-checker",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/parsebird~gmail-username-checker/run-sync": {
"post": {
"operationId": "run-sync-parsebird-gmail-username-checker",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"targets"
],
"properties": {
"targets": {
"title": "Gmail usernames",
"minItems": 1,
"maxItems": 500,
"type": "array",
"description": "Enter Gmail usernames or full @gmail.com addresses. You can paste one value per line, comma-separated text, or a mix of both. Only @gmail.com usernames are supported.",
"items": {
"type": "string",
"minLength": 1
}
},
"proxyConfiguration": {
"title": "Proxy configuration",
"type": "object",
"description": "Optional Apify Proxy settings. Leave empty for the default no-proxy behavior."
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```