BULK GMAIL CHECKER API v.1

Complete API Documentation for Developers

REST API JSON Bearer Token

API Overview

The Bulk Gmail Checker API provides programmatic access to our Google (Gmail) account checking service. With this API, you can:

  • Bulk check Google (Gmail) account status
  • Get status types (Live, Verify, Disabled, Unregistered, Bad)
  • Monitor your API usage statistics
  • Integrate Google (Gmail) account status checking into your applications

Note: All API requests require authentication using a Bearer token. API keys are automatically generated when you visit our main application and have a limit of 500,000 requests per day.

Base URL

https://gmail-validation.mbahbabat.workers.dev

Response Format

All API responses are returned in JSON format with appropriate HTTP status codes.

Authentication

All API requests must include a valid API key in the Authorization header using the Bearer token scheme.

GET Automatic API Key Generation

An API key is automatically generated when you visit our main application. No manual registration needed!

How to Get Your API Key

  1. Visit Bulk Gmail Checker
  2. Click the "MY ACCOUNT" button in the top right corner
  3. Your API key will be automatically generated and displayed in the "API Key" section
  4. Copy the API key for use in your applications

Auto-Generated: Your API key is automatically generated on your first visit and stored in your browser's local storage.

Using Your API Key

Include your API key in the Authorization header of all requests:

Authorization: Bearer YOUR_API_KEY_HERE

Important: Your API key must be kept secure and not exposed in client-side code. API keys are limited to 500,000 requests per day and reset every 24 hours.

Security & Origin Restrictions

For security reasons, API key generation is restricted to our official domains:

https://mbahbabat.github.io

Requests from other domains will be rejected. This ensures that only legitimate users can generate and use our API keys.

Google (Gmail) Account Status Checking Endpoints

Check Google (Gmail) account status using our dedicated servers. We offer normal and fast checking options.

Normal Servers 1

These servers provide detailed status information but process Gmail addresses in smaller batches (100 emails per request).

POST /check1

The server will provide detailed account status information.

Request Headers

Header Value Required
Content-Type application/json Yes
Authorization Bearer <API_KEY> Yes

Request Body

{
	  "mail": [
		"example1@gmail.com",
		"example2@gmail.com",
		"example3@gmail.com",
		"example4@gmail.com",
		"example5@gmail.com"	
	  ]
	}

Response

[
	  {
		"email": "example1@gmail.com",
		"status": "live",
		"details": "Active"
	  },
	  {
		"email": "example2@gmail.com",
		"status": "verify",
		"details": "Requires verification"
	  },
	  {
		"email": "example3@gmail.com",
		"status": "disabled",
		"details": "Non-active"
	  },
	  {
		"email": "example4@gmail.com",
		"status": "unregistered",
		"details": "not found"
	  },  
	  {
		"email": "example5@gmail.com",
		"status": "bad",
		"details": "verify, disabled, or unregistered"
	  }
	]

Status Types

Status Description
live Active and accessible account
verify Account that requires additional verification
disabled Disabled account
unregistered Account not registered with Google (Gmail) Platforms
bad Account that is disabled, unregistered, or requires verification.
POST /check2

Normal Server 2 - An alternative server with the same functionality as /check1.

Fast Server

These servers process Google (Gmail) accounts very quickly and in large quantities (10,000 emails per request) but only return a binary status (live or bad).

POST /fastcheck1

Fast Server 1 - Processes large batches quickly with binary status results.

Status Mapping for Fast Server

The server will map all non-live statuses to "bad":

Original Status Fast Server Status
live live
verify, disabled, unregistered, bad bad
POST /fastcheck2

Fast Server 2 - An alternative fast server with the same functionality as /fastcheck1.

API Statistics

Monitor your API usage and limits with the statistics endpoint.

GET /stats?key=<API_KEY>

Retrieve usage statistics for your API key.

Query Parameters

Parameter Description Required
key Your API key Yes

Response

{
	  "type": "free",
	  "requestsUsed": 150,
	  "maxRequests": 500000,
	  "remainingRequests": 850,
	  "resetPeriod": "24 hours",
	  "nextResetUTC": "Mon, 01 Jan 2024 00:00:00 GMT",
	  "owner": "Anonymous",
	  "resetTimestamp": 1704067200000
	}

Response Fields

Field Description
type API type (free/paid)
requestsUsed Number of requests used in the current period
maxRequests Maximum requests allowed in that period
remainingRequests Remaining requests in the current period
resetPeriod Period after which the limit resets
nextResetUTC Next reset time in UTC
owner Identifier of the API key owner
resetTimestamp Next reset time as a timestamp

Code Examples

Here are examples of how to use the Bulk Gmail Checker API in various programming languages and environments.

JavaScript (Fetch API)

const API_KEY = 'your_api_key_here';
	const SERVER_URL = 'https://gmail-validation.mbahbabat.workers.dev';

	// Check Google (Gmail) Account Status
	async function validateEmails(emails) {
	  try {
		const response = await fetch(`${SERVER_URL}/check1`, {
		  method: 'POST',
		  headers: {
			'Authorization': `Bearer ${API_KEY}`,
			'Content-Type': 'application/json'
		  },
		  body: JSON.stringify({
			mail: emails
		  })
		});
		
		if (!response.ok) {
		  throw new Error(`HTTP ${response.status}: ${response.statusText}`);
		}
		
		const data = await response.json();
		return data;
	  } catch (error) {
		console.error('Validation error:', error);
		throw error;
	  }
	}

	// Get API statistics
	async function getApiStats() {
	  try {
		const response = await fetch(`${SERVER_URL}/stats?key=${API_KEY}`);
		
		if (!response.ok) {
		  throw new Error(`HTTP ${response.status}: ${response.statusText}`);
		}
		
		const data = await response.json();
		return data;
	  } catch (error) {
		console.error('Stats error:', error);
		throw error;
	  }
	}

	// Example Usage
	const emails = ['test1@gmail.com', 'test2@gmail.com', 'test3@gmail.com'];
	validateEmails(emails)
	  .then(results => console.log('Validation results:', results))
	  .catch(error => console.error('Error:', error));

cURL

# Check Google (Gmail) Account Status
	curl -X POST "https://gmail-validation.mbahbabat.workers.dev/check1" \
	  -H "Authorization: Bearer YOUR_API_KEY" \
	  -H "Content-Type: application/json" \
	  -d '{
		"mail": [
		  "example1@gmail.com",
		  "example2@gmail.com",
		  "example3@gmail.com"
		]
	  }'

	# Get API statistics
	curl "https://gmail-validation.mbahbabat.workers.dev/stats?key=YOUR_API_KEY"

Python

import requests

	API_KEY = 'your_api_key_here'
	SERVER_URL = 'https://gmail-validation.mbahbabat.workers.dev'

	def validate_emails(emails):
		headers = {
			'Authorization': f'Bearer {API_KEY}',
			'Content-Type': 'application/json'
		}
		
		data = {
			'mail': emails
		}
		
		response = requests.post(f'{SERVER_URL}/check1', headers=headers, json=data)
		response.raise_for_status()
		return response.json()

	def get_api_stats():
		response = requests.get(f'{SERVER_URL}/stats?key={API_KEY}')
		response.raise_for_status()
		return response.json()

	# Example Usage
	emails = ['test1@gmail.com', 'test2@gmail.com', 'test3@gmail.com']
	try:
		results = validate_emails(emails)
		print('Validation results:', results)
	except requests.exceptions.RequestException as e:
		print('Error:', e)

PHP

$api_key = 'your_api_key_here';
	$server_url = 'https://gmail-validation.mbahbabat.workers.dev';

	// Check Google (Gmail) Account Status
	function validateEmails($emails) {
		global $api_key, $server_url;
		
		$data = json_encode(['mail' => $emails]);
		
		$ch = curl_init("$server_url/check1");
		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
		curl_setopt($ch, CURLOPT_POST, true);
		curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
		curl_setopt($ch, CURLOPT_HTTPHEADER, [
			"Authorization: Bearer $api_key",
			"Content-Type: application/json"
		]);
		
		$response = curl_exec($ch);
		$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
		curl_close($ch);
		
		if ($http_code !== 200) {
			throw new Exception("HTTP $http_code: $response");
		}
		
		return json_decode($response, true);
	}

	// Get API Statistics
	function getApiStats() {
		global $api_key, $server_url;
		
		$ch = curl_init("$server_url/stats?key=$api_key");
		curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
		
		$response = curl_exec($ch);
		$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
		curl_close($ch);
		
		if ($http_code !== 200) {
			throw new Exception("HTTP $http_code: $response");
		}
		
		return json_decode($response, true);
	}

	// Usage example
	$emails = ['test1@gmail.com', 'test2@gmail.com', 'test3@gmail.com'];
	try {
		$results = validateEmails($emails);
		echo 'Validation results: ' . print_r($results, true);
	} catch (Exception $e) {
		echo 'Error: ' . $e->getMessage();
	}