# Gmail Username Checker (`maximedupre/gmail-username-checker`) Actor

Check Gmail username availability in bulk. Paste usernames or @gmail.com addresses and get clean available, taken, or invalid rows without creating accounts.

- **URL**: https://apify.com/maximedupre/gmail-username-checker.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Developer tools
- **Stats:** 4 total users, 2 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 gmail 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.

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 for bulk availability

Gmail Username Checker helps you check whether Gmail usernames are available for new account registration. Paste usernames such as `brandname2026`, full `@gmail.com` addresses, or a comma/newline-separated list, then get one clean dataset row per normalized Gmail username.

Use it when you are choosing brand email ideas, checking personal handle options, monitoring name availability, or preparing a list of possible Gmail addresses before a launch. The Actor checks Gmail's public signup availability flow and does not create accounts or ask for Google credentials.

For a small first run, keep the prefilled examples or paste 5-10 username ideas. Results are saved to the Apify dataset, where you can export them as JSON, CSV, Excel, or connect them to your own API workflow.

### ✅ What this Gmail username checker does

- Checks Gmail username availability in bulk.
- Accepts plain usernames, full `@gmail.com` addresses, and pasted comma/newline-separated text.
- Normalizes each valid input into a `username` and full Gmail `email`.
- Returns only final usable `available`, `taken`, or `invalid` source results.
- Adds a plain-English `reason` when Gmail reports a username-level validation issue.
- Saves a `checkedAt` timestamp for every row.
- Skips malformed inputs and temporary source failures instead of saving placeholder rows.

This Actor is focused only on Gmail registration availability. It does not reserve usernames, create accounts, log in to Google, verify inbox ownership, recover accounts, or check non-Gmail domains.

### 📊 What data you get

Each output row represents one requested Gmail username after normalization:

| Field | Description |
| --- | --- |
| `input` | Original value you entered. |
| `username` | Normalized Gmail username. |
| `email` | Full normalized `@gmail.com` address. |
| `validUsername` | Whether the input matches Gmail username format rules used by this Actor. |
| `availabilityStatus` | `available`, `taken`, or `invalid`. |
| `available` | `true` when clearly available, `false` when clearly taken, otherwise `null`. |
| `reason` | Helpful explanation when Gmail returns a username-level validation message. |
| `sourceProvider` | Always `gmail`. |
| `sourceQueryType` | Always `registration_availability`. |
| `runStatus` | Always `ok` for emitted rows. |
| `checkedAt` | UTC timestamp when the username was checked. |

### 🚀 How to run it

1. Open the Actor input.
2. Add Gmail usernames or Gmail addresses in **Gmail usernames**.
3. Leave **Deduplicate usernames** on unless you intentionally want repeated inputs skipped only by your own downstream system.
4. Set **Maximum results** to cap the run size.
5. Start the Actor and open the dataset when the run finishes.

For best first-run clarity, use a short list of specific ideas instead of a very large generated list. You can scale up once the output shape matches your workflow.

### 🧾 Input example

```json
{
	"targets": [
		"brandname2026",
		"launch.team@gmail.com",
		"newproductideas"
	],
	"deduplicate": true,
	"maxResults": 100,
	"country": "US"
}
````

### 📤 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-05-22T18:00:46.596Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing:

- A small Actor start charge applies when a run starts.
- Each valid Gmail username availability result saved to the dataset is charged as one `gmail-username-checked` event.
- Malformed inputs and temporary source failures are skipped and are not charged as username checks.

Use **Maximum results** to keep a first run small or to cap larger batches.

### ⚠️ Limits and caveats

- Only `@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.

### ❓ FAQ

#### Does this create Gmail accounts?

No. The Actor only checks whether Gmail reports a username as available for registration. It does not create accounts, reserve names, or ask for Google login details.

#### Can I paste full Gmail addresses?

Yes. You can paste `name@gmail.com` or just `name`. The output normalizes valid inputs into both `username` and `email`.

#### Does it check Google Workspace or custom domains?

No. This Actor checks Gmail username availability for `@gmail.com` registration only.

#### Why did a row return `invalid`?

The input did not match the supported Gmail username format, or Gmail returned a validation message for that username.

#### Can I schedule repeat checks?

Yes. You can schedule the Actor on Apify and compare datasets over time. Remember that availability reflects the moment each run was checked.

### 📝 Changelog

- 0.1: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~gmail-username-checker/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Find public contact emails from company websites.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Extract physical business addresses from company websites.
- [App Store Ratings Scraper ↗](https://apify.com/maximedupre/app-store-ratings-scraper) - Monitor Google Play and Apple App Store ratings.
- [YouTube Channel Scraper ↗](https://apify.com/maximedupre/youtube-channel-scraper) - Export public YouTube channel and video data.
- [Quora Search Scraper ↗](https://apify.com/maximedupre/quora-search-scraper) - Collect public Quora question rows from search terms or URLs.

**Made with ❤️ by Maxime Dupré**

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

## `deduplicate` (type: `boolean`):

Skip repeated normalized usernames so each Gmail username is checked once per run.

## `maxResults` (type: `integer`):

Maximum number of valid Gmail usernames to process in this run.

## `country` (type: `string`):

Country used for Gmail source access. Keep United States for most runs unless you need another listed market.

## Actor input object example

```json
{
  "targets": [
    "brandname2026",
    "example@gmail.com"
  ],
  "deduplicate": true,
  "maxResults": 100,
  "country": "US"
}
```

# Actor output Schema

## `results` (type: `string`):

Open the dataset with Gmail username checker results.

# 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 = {
    "targets": [
        "brandname2026",
        "example@gmail.com"
    ]
};

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

# Prepare the Actor input
run_input = { "targets": [
        "brandname2026",
        "example@gmail.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/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",
    "example@gmail.com"
  ]
}' |
apify call maximedupre/gmail-username-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=maximedupre/gmail-username-checker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Gmail Username Checker",
        "description": "Check Gmail username availability in bulk. Paste usernames or @gmail.com addresses and get clean available, taken, or invalid rows without creating accounts.",
        "version": "0.1",
        "x-build-id": "EC6SPVOJYHM2OWKOR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~gmail-username-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-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/maximedupre~gmail-username-checker/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-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/maximedupre~gmail-username-checker/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-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.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "deduplicate": {
                        "title": "Deduplicate usernames",
                        "type": "boolean",
                        "description": "Skip repeated normalized usernames so each Gmail username is checked once per run.",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of valid Gmail usernames to process in this run.",
                        "default": 100
                    },
                    "country": {
                        "title": "Proxy country",
                        "enum": [
                            "US",
                            "CA",
                            "GB",
                            "AU",
                            "DE",
                            "FR",
                            "NL"
                        ],
                        "type": "string",
                        "description": "Country used for Gmail source access. Keep United States for most runs unless you need another listed market.",
                        "default": "US"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```