# Email Account Checker - Gmail, Outlook, Yahoo, iCloud (`clearpath/email-account-checker`) Actor

Check email addresses in bulk for real account registration on Gmail, Outlook, Yahoo, iCloud, and Mail.ru. Find which addresses are real and active, clean lists before campaigns. Export to CSV, JSON, or Excel.

- **URL**: https://apify.com/clearpath/email-account-checker.md
- **Developed by:** [ClearPath](https://apify.com/clearpath) (community)
- **Categories:** Lead generation, Integrations
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.99 / 1,000 emails

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

## Email Account Checker

Check email addresses in bulk for **real account registration** on Gmail, Outlook, Yahoo, iCloud, and Mail.ru.

The actor processes **2,000 to 100,000 addresses per run**. Larger inputs are deduped, then trimmed to the first 100,000 unique normalized addresses. Each address returns one of three statuses: `registered`, `unregistered`, or `unknown`.

Use it to **clean lists before campaigns**, **find which addresses belong to real, active accounts**, **validate signups**, and keep CRM email data fresh.

<table><tr>
<td style="border-left:4px solid rgb(76,148,94);padding:12px 16px;font-weight:600">Check up to 100,000 email addresses per run for real account registration in one result file.</td>
</tr></table>

&nbsp;

<table>
<tr>
<td colspan="2" style="padding:10px 14px;background:#006D77;border:none;border-radius:4px 4px 0 0">
<span style="color:#FAFAF9;font-size:14px;font-weight:700;letter-spacing:0.5px">Clearpath Email Intelligence</span>
<span style="color:#EDF6F9;font-size:13px">&nbsp;&nbsp;&bull;&nbsp;&nbsp;Bulk email validation, verification &amp; lookup</span>
</td>
</tr>
<tr>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-radius:0 0 0 4px;border-right:none;border-top:none;vertical-align:top;width:50%">
<a href="https://apify.com/clearpath/email-validation-api" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">Email Validator</a><br>
<span style="color:#78716C;font-size:12px">Deliverability, MX &amp; SMTP checks</span>
</td>
<td style="padding:12px 16px;border:1px solid #E7E5E4;border-radius:0 0 4px 0;border-top:none;vertical-align:top;width:50%">
<a href="https://apify.com/clearpath/email-finder-api" style="color:#1C1917;text-decoration:none;font-weight:700;font-size:14px">Email Finder</a><br>
<span style="color:#78716C;font-size:12px">B2B email lookup &amp; verify</span>
</td>
</tr>
</table>

#### Copy to your AI assistant

````

clearpath/email-account-checker on Apify. Bulk-check email addresses for real account registration on Gmail, Outlook, Yahoo, iCloud, and Mail.ru, returning registered, unregistered, or unknown per address. Call ApifyClient("TOKEN").actor("clearpath/email-account-checker").call(run\_input={...}), then client.dataset(run\["defaultDatasetId"]).list\_items().items. Real runs need testMode=false and 2,000-100,000 addresses via emailAddresses or csvFile. Full spec: GET https://api.apify.com/v2/acts/clearpath~email-account-checker/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Token: https://console.apify.com/account/integrations

````

### Quick Start

Preview sample output without charges:

```json
{
  "testMode": true,
  "emailAddresses": ["john.doe@gmail.com"]
}
````

Check a direct list:

```json
{
  "testMode": false,
  "emailAddresses": [
    "john.doe@gmail.com",
    "jane@outlook.com"
  ],
  "onlyRegistered": false
}
```

Upload a CSV file and return only registered addresses:

```json
{
  "testMode": false,
  "csvFile": "uploaded-file.csv",
  "csvEmailColumn": "email",
  "onlyRegistered": true
}
```

### Input

At least one of `emailAddresses` or `csvFile` is required.

| Parameter | Type | Description |
|-----------|------|-------------|
| `testMode` | boolean | Returns sample output without checking real addresses or charging credits. |
| `emailAddresses` | array | Email addresses to check. Real runs require at least 2,000 supported-provider addresses; the first 100,000 are used after dedupe. |
| `csvFile` | string | Uploaded CSV or Excel file containing email addresses. |
| `csvEmailColumn` | string | Column name or 0-based index of the email column. Auto-detected if left empty. |
| `onlyRegistered` | boolean | Output only addresses where `status` is `registered`. |

#### CSV/Excel File Requirements

- **Supported formats**: `.csv`, `.xlsx`
- **Delimiters**: Comma, semicolon, tab, pipe (auto-detected)
- **Column detection**: Automatically finds email columns including `email`, `e-mail`, and common variations
- **No headers?** Scans content to find email-like columns automatically

### Output

```json
{
  "email": "john.doe@gmail.com",
  "originalInput": "John.Doe@gmail.com",
  "provider": "gmail",
  "isValidFormat": true,
  "status": "registered",
  "isRegistered": true,
  "skipReason": null,
  "checkedAt": "2026-06-16T08:00:00Z"
}
```

### Output Fields

| Field | Description |
|-------|-------------|
| `email` | Normalized, lowercase email address (null when the input could not be parsed as a valid address). |
| `originalInput` | Original value supplied by the user. |
| `provider` | Detected provider slug (`gmail`, `outlook`, `yahoo`, `icloud`, `mailru`); null for unsupported or invalid addresses. |
| `isValidFormat` | Whether the input was recognized as a valid email address. |
| `status` | `registered`, `unregistered`, `unknown`, or `skipped`. |
| `isRegistered` | `true` when a real account exists, `false` when none found, `null` when unknown or not checked. |
| `skipReason` | Why an address was not checked: `unsupported_provider` (domain not a supported provider) or `invalid_format` (not a valid email); null for checked addresses. |
| `checkedAt` | ISO timestamp of the check. |
| `isSample` | Present and `true` only in test mode. |

Addresses on unsupported domains or that are malformed are returned with `status: skipped` and a `skipReason`, never submitted and never charged, so nothing in your input silently disappears. Only valid supported-provider addresses count toward the per-run minimum.

### Pricing

The actor uses pay-per-event pricing with one `email_checked` event per checked address.

Current rates per 1,000 checked addresses:

| Plan | Price per 1,000 |
|------|----------------:|
| No subscription / Bronze | $4.99 |
| Silver | $4.29 |
| Gold and above | $3.99 |

Duplicates are removed before checking, so you pay for unique addresses checked.

### Notes

- `unknown` means the registration status could not be determined for that address; it still counts as a checked address.
- Uploaded CSV/XLSX files can use common email columns such as `email` or `e-mail`; the column is auto-detected.
- `onlyRegistered` filters output rows, but billing still applies to every checked address.

***

### FAQ

**Q: What does this actor check?**
A: It checks, in bulk, which email addresses have a real registered account on Gmail, Outlook/Hotmail/Live/MSN, Yahoo, iCloud, or Mail.ru.

**Q: How accurate are the results?**
A: Statuses reflect account registration at the time of the check.

**Q: Which providers are supported?**
A: Gmail, Outlook/Hotmail/Live/MSN, Yahoo, iCloud, and Mail.ru. Addresses on other domains are returned with `status: skipped` and are never charged.

**Q: How fast is it?**
A: A 2,000-address batch typically completes in a few minutes. Larger batches scale accordingly.

**Q: What about duplicates?**
A: Auto-removed before checking. You are only charged for unique addresses.

**Q: What does `unknown` mean?**
A: The registration status could not be determined for that address. It still counts as a checked address.

**Q: Is there a minimum batch size?**
A: Yes, 2,000 unique supported-provider addresses per run. The maximum is 100,000.

### Related Actors

**More from Clearpath (Phone intelligence):**

- **[WhatsApp Phone Number Validator](https://apify.com/clearpath/whatsapp-phone-number-validator-api)** - Bulk validate phone numbers for WhatsApp accounts.
- **[Telegram Phone Number Validator](https://apify.com/clearpath/telegram-phone-number-validator)** - Bulk validate phone numbers for Telegram accounts.
- **[WhatsApp Profile Avatar, Age & Gender](https://apify.com/clearpath/whatsapp-profile-avatar-age-gender-api)** - Enrich WhatsApp numbers with avatar, inferred age, and gender.
- **[Phone Number Active Status Checker](https://apify.com/clearpath/phone-number-active-checker)** - Bulk carrier-level active, inactive, or unknown status checks.
- **[MAX Messenger Number Checker](https://apify.com/clearpath/max-messenger-number-checker)** - Bulk MAX messenger registration checks.
- **[Social & Crypto Phone Number Checker](https://apify.com/clearpath/social-crypto-phone-number-checker)** - Bulk account checks across 25 platforms (Instagram, Facebook, Binance, and more).

***

### 📧 Support

- **Email**: max@mapa.slmail.me
- **Feature Requests**: Email or submit via issues
- **Response Time**: Typically within 24 hours

***

### Legal

This actor checks email account registration status. Users are responsible for complying with applicable data protection regulations (GDPR, CCPA) when processing email lists.

# Actor input Schema

## `testMode` (type: `boolean`):

Return sample records without checking real addresses or charging credits.<br><br><b>Disable this for real runs.</b>

## `emailAddresses` (type: `array`):

Add email addresses to check, for example <code>name@gmail.com</code>.<br><br>Supported providers: Gmail, Outlook/Hotmail/Live/MSN, Yahoo, iCloud, Mail.ru. Minimum 2,000 supported addresses per run; oversized inputs are trimmed to the first 100,000 unique addresses.

## `csvFile` (type: `string`):

Upload a CSV or Excel <code>.xlsx</code> file containing email addresses.<br><br>The actor detects common email columns such as <code>email</code> and <code>e-mail</code>.<br><br><b>Tip:</b> Use the upload button above for best results. Files you upload here, and files in your own Apify storage, are read automatically. For a link to a private Key-Value Store in another account, make the store public or re-upload the file here.

## `csvEmailColumn` (type: `string`):

Column name or 0-based index that holds the email addresses. Leave empty to auto-detect.

## `onlyRegistered` (type: `boolean`):

Output only addresses where <code>status</code> is <code>registered</code>.<br><br>Billing still applies to every checked address.

## Actor input object example

```json
{
  "testMode": true,
  "emailAddresses": [
    "john.doe@gmail.com"
  ],
  "onlyRegistered": false
}
```

# Actor output Schema

## `results` (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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "testMode": true,
    "emailAddresses": [
        "john.doe@gmail.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("clearpath/email-account-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 = {
    "testMode": True,
    "emailAddresses": ["john.doe@gmail.com"],
}

# Run the Actor and wait for it to finish
run = client.actor("clearpath/email-account-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 '{
  "testMode": true,
  "emailAddresses": [
    "john.doe@gmail.com"
  ]
}' |
apify call clearpath/email-account-checker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Email Account Checker - Gmail, Outlook, Yahoo, iCloud",
        "description": "Check email addresses in bulk for real account registration on Gmail, Outlook, Yahoo, iCloud, and Mail.ru. Find which addresses are real and active, clean lists before campaigns. Export to CSV, JSON, or Excel.",
        "version": "0.0",
        "x-build-id": "LrTq2WGa4LBkED1wH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/clearpath~email-account-checker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-clearpath-email-account-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/clearpath~email-account-checker/runs": {
            "post": {
                "operationId": "runs-sync-clearpath-email-account-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/clearpath~email-account-checker/run-sync": {
            "post": {
                "operationId": "run-sync-clearpath-email-account-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",
                "properties": {
                    "testMode": {
                        "title": "Test Mode",
                        "type": "boolean",
                        "description": "Return sample records without checking real addresses or charging credits.<br><br><b>Disable this for real runs.</b>",
                        "default": false
                    },
                    "emailAddresses": {
                        "title": "Email Addresses",
                        "minItems": 1,
                        "maxItems": 100000,
                        "type": "array",
                        "description": "Add email addresses to check, for example <code>name@gmail.com</code>.<br><br>Supported providers: Gmail, Outlook/Hotmail/Live/MSN, Yahoo, iCloud, Mail.ru. Minimum 2,000 supported addresses per run; oversized inputs are trimmed to the first 100,000 unique addresses.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "csvFile": {
                        "title": "CSV/Excel File",
                        "type": "string",
                        "description": "Upload a CSV or Excel <code>.xlsx</code> file containing email addresses.<br><br>The actor detects common email columns such as <code>email</code> and <code>e-mail</code>.<br><br><b>Tip:</b> Use the upload button above for best results. Files you upload here, and files in your own Apify storage, are read automatically. For a link to a private Key-Value Store in another account, make the store public or re-upload the file here."
                    },
                    "csvEmailColumn": {
                        "title": "CSV Email Column (Optional)",
                        "type": "string",
                        "description": "Column name or 0-based index that holds the email addresses. Leave empty to auto-detect."
                    },
                    "onlyRegistered": {
                        "title": "Only Registered Addresses",
                        "type": "boolean",
                        "description": "Output only addresses where <code>status</code> is <code>registered</code>.<br><br>Billing still applies to every checked address.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
