# SMTP Email Verifier (`maximedupre/smtp-email-verifier`) Actor

Check email addresses in bulk with syntax validation, MX records, SMTP RCPT TO mailbox probes, catch-all detection, disposable and role flags, confidence, and recommended actions. No email is sent.

- **URL**: https://apify.com/maximedupre/smtp-email-verifier.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.55 / 1,000 email 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

### 📬 SMTP email verifier for cleaner outreach lists

Use this SMTP email verifier to check email addresses in bulk before you import, enrich, or send to a lead list. It validates syntax, looks up DNS [MX records](https://www.rfc-editor.org/rfc/rfc5321), opens an SMTP conversation, and checks the recipient with `RCPT TO` without sending an email.

The Actor is built for email list cleaning, CRM hygiene, cold email prep, signup review, and lead data QA. Paste emails from a spreadsheet, CSV export, CRM field, or mixed copied text, then get one saved item per checked address with status, confidence, risk flags, mail server evidence, and a recommended action.

### ✅ What this bulk email verifier checks

- Email syntax and malformed input, including missing `@`, bad domains, and invalid local parts.
- MX records and detected mail provider, so addresses on domains with no receiving mail server are suppressed early.
- SMTP mailbox response through `EHLO`, `MAIL FROM`, and `RCPT TO`, then `QUIT`; no message body is sent.
- Catch-all domains where servers accept random recipients and mailbox-level SMTP checks are not trustworthy.
- Disposable email domains that are often temporary or low quality.
- Role-based addresses such as `info@`, `sales@`, `support@`, `admin@`, and `noreply@`.
- Common domain typo suggestions for addresses that look misspelled.

### 📊 Data returned

Each saved email check includes the original input, normalized email, domain, status, confidence, risk level, and recommended action. Technical evidence is included when available: syntax errors, MX records, detected provider, SMTP code and message, catch-all result, disposable flag, role-based flag, attempt count, verification method, and timestamp.

Statuses can be `valid`, `invalid`, `invalid_syntax`, `no_mx`, `catch_all`, `temporary_failure`, `blocked`, `timeout`, or `unknown`. That lets you separate addresses to keep, suppress, retry, or review instead of treating every uncertain mailbox as either good or bad.

### 🧭 When to use it

- Clean a cold email or newsletter list before outreach.
- Check imported CRM emails before assigning leads.
- Filter disposable and role-based addresses from signup exports.
- Review data quality from scraped contact lists or purchased lead data.
- Find domains with no MX records before spending time on enrichment.
- Export verification results to JSON, CSV, Excel, API clients, webhooks, or downstream Apify integrations.

### ▶️ How to run

1. Paste email addresses into **Email list**. One per line is easiest, but comma-separated text and copied CRM/export text also work.
2. Keep the default checks enabled for a full syntax, MX, disposable, role-based, catch-all, and SMTP pass.
3. Set **Maximum emails** if you only want to process part of a larger list.
4. Run the Actor and open the dataset to review status, confidence, risk flags, and recommended action for each email.

Advanced SMTP settings are available for teams that need a custom `MAIL FROM` address, SMTP port, timeout, retry count, or per-domain cap. Most users can leave those defaults unchanged.

### 🧾 Input

The required input is an email list. The Actor normalizes and caps the run using your **Maximum emails** setting. Optional toggles control catch-all detection, disposable domain detection, role-based detection, typo suggestions, and SMTP timing.

The per-domain limit is useful when a list contains many addresses on the same company domain. It reduces repeated probing of one mail server and helps the run return useful results across more domains.

### 🧪 Output example

```json
{
  "inputIndex": 0,
  "sourceEmail": "invalid-email",
  "email": "invalid-email",
  "normalizedEmail": "invalid-email",
  "domain": null,
  "status": "invalid_syntax",
  "isDeliverable": false,
  "confidence": 1,
  "riskLevel": "high",
  "recommendedAction": "Suppress this address before outreach.",
  "riskFlags": ["invalid_syntax"],
  "isValidSyntax": false,
  "syntaxErrors": ["Missing @ symbol"],
  "hasMxRecords": null,
  "mxRecords": [],
  "mxProvider": null,
  "isDisposable": false,
  "isRoleBased": false,
  "isCatchAll": false,
  "catchAllConfidence": null,
  "smtpCode": null,
  "smtpMessage": null,
  "verificationMethod": "syntax",
  "attemptCount": 0,
  "errorMessage": null,
  "suggestion": null,
  "checkedAt": "2026-06-01T22:45:20.042Z"
}
````

### 💳 Pricing

This Actor charges per email checked. There is no actor-start event.

| Apify plan | Price per 1,000 emails |
| --- | ---: |
| FREE | $0.90 |
| BRONZE | $0.80 |
| SILVER | $0.70 |
| GOLD | $0.55 |
| PLATINUM | $0.45 |
| DIAMOND | $0.35 |

### ⚠️ Limits and caveats

SMTP verification is a real mailbox-level check, but it is not a guarantee that an inbox exists or will accept future mail. Some large consumer and enterprise providers intentionally block SMTP probing, hide recipient validity, rate-limit connections, or return temporary responses. In those cases, the Actor saves a successful row with `blocked`, `timeout`, `temporary_failure`, `catch_all`, or `unknown` and gives a recommended action.

The Actor never sends an email. It stops after the SMTP recipient check. Use the result as a list-cleaning signal, not as permission to contact someone.

### ❓ FAQ

#### 📮 Does this do a true SMTP check?

Yes. After syntax and MX checks, the Actor connects to the target mail server and performs an SMTP recipient probe with `RCPT TO`. It then closes the connection without sending a message.

#### 🧱 Why does it check MX records first?

MX records tell the Actor which mail servers receive email for a domain. If a domain has no usable MX records, there is no mailbox server to probe, so the Actor can return `no_mx` without wasting SMTP attempts.

#### 🕵️ Why are some results marked unknown, blocked, or catch\_all?

Many mail servers protect recipient privacy or reduce automated probing. Those responses are useful signals, but they are not hard proof of deliverability. The Actor keeps them separate from confirmed invalid syntax, no-MX domains, and successful mailbox checks.

#### 🔑 Do I need email provider credentials?

No. The Actor does not need Gmail, Outlook, SMTP account, or inbox credentials. You only provide the email addresses you want to check.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~smtp-email-verifier/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 websites before you verify deliverability.
- [Gmail Username Checker ↗](https://apify.com/maximedupre/gmail-username-checker) - Check Gmail username availability for new account ideas.
- [LinkedIn Company People Scraper ↗](https://apify.com/maximedupre/linkedin-company-people-scraper) - Export LinkedIn company people for prospect research and CRM prep.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Pull public company profile facts, websites, industries, and size data from LinkedIn.
- [Business Address Scraper ↗](https://apify.com/maximedupre/business-address-scraper) - Find website-published business addresses with source evidence.

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

# Actor input Schema

## `emails` (type: `array`):

Enter the email addresses to check. You can paste one value per line, comma-separated text, or copied CRM/export text.

## `maxEmails` (type: `integer`):

Maximum number of normalized email addresses to check in this run.

## `detectCatchAll` (type: `boolean`):

Check whether a domain accepts random recipients before trusting mailbox-level SMTP results.

## `detectDisposable` (type: `boolean`):

Flag common temporary and disposable email providers.

## `detectRoleBased` (type: `boolean`):

Flag role addresses such as info@, support@, sales@, admin@, and noreply@.

## `suggestCorrections` (type: `boolean`):

Suggest fixes for common mailbox provider domain typos.

## `smtpPort` (type: `integer`):

TCP port to connect to on the target MX server. Port 25 is the standard SMTP verification port.

## `fromEmail` (type: `string`):

Address used in the SMTP MAIL FROM command. No email is sent.

## `smtpTimeoutSecs` (type: `integer`):

Maximum seconds to wait for each SMTP connection and response.

## `retryCount` (type: `integer`):

Extra attempts for temporary SMTP failures or connection errors.

## `maxEmailsPerDomain` (type: `integer`):

Maximum emails checked per domain in one run. Extra emails for the same domain are skipped to reduce blocking risk.

## Actor input object example

```json
{
  "emails": [
    "postmaster@gmail.com",
    "abuse@yahoo.com",
    "test@mailinator.com"
  ],
  "maxEmails": 1000,
  "detectCatchAll": true,
  "detectDisposable": true,
  "detectRoleBased": true,
  "suggestCorrections": true,
  "smtpPort": 25,
  "fromEmail": "verify@smtp-check.test",
  "smtpTimeoutSecs": 15,
  "retryCount": 1,
  "maxEmailsPerDomain": 20
}
```

# Actor output Schema

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

Open the saved email verification 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 = {
    "emails": [
        "postmaster@gmail.com",
        "abuse@yahoo.com",
        "test@mailinator.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/smtp-email-verifier").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 = { "emails": [
        "postmaster@gmail.com",
        "abuse@yahoo.com",
        "test@mailinator.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/smtp-email-verifier").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 '{
  "emails": [
    "postmaster@gmail.com",
    "abuse@yahoo.com",
    "test@mailinator.com"
  ]
}' |
apify call maximedupre/smtp-email-verifier --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "SMTP Email Verifier",
        "description": "Check email addresses in bulk with syntax validation, MX records, SMTP RCPT TO mailbox probes, catch-all detection, disposable and role flags, confidence, and recommended actions. No email is sent.",
        "version": "0.0",
        "x-build-id": "scZQU5kvsKw3arxqS"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~smtp-email-verifier/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-smtp-email-verifier",
                "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~smtp-email-verifier/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-smtp-email-verifier",
                "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~smtp-email-verifier/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-smtp-email-verifier",
                "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": [
                    "emails"
                ],
                "properties": {
                    "emails": {
                        "title": "Email list",
                        "minItems": 1,
                        "maxItems": 10000,
                        "type": "array",
                        "description": "Enter the email addresses to check. You can paste one value per line, comma-separated text, or copied CRM/export text.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxEmails": {
                        "title": "Run limit",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of normalized email addresses to check in this run.",
                        "default": 1000
                    },
                    "detectCatchAll": {
                        "title": "Catch-all check",
                        "type": "boolean",
                        "description": "Check whether a domain accepts random recipients before trusting mailbox-level SMTP results.",
                        "default": true
                    },
                    "detectDisposable": {
                        "title": "Disposable domain check",
                        "type": "boolean",
                        "description": "Flag common temporary and disposable email providers.",
                        "default": true
                    },
                    "detectRoleBased": {
                        "title": "Role address check",
                        "type": "boolean",
                        "description": "Flag role addresses such as info@, support@, sales@, admin@, and noreply@.",
                        "default": true
                    },
                    "suggestCorrections": {
                        "title": "Typo suggestions",
                        "type": "boolean",
                        "description": "Suggest fixes for common mailbox provider domain typos.",
                        "default": true
                    },
                    "smtpPort": {
                        "title": "SMTP port",
                        "minimum": 1,
                        "maximum": 65535,
                        "type": "integer",
                        "description": "TCP port to connect to on the target MX server. Port 25 is the standard SMTP verification port.",
                        "default": 25
                    },
                    "fromEmail": {
                        "title": "MAIL FROM address",
                        "type": "string",
                        "description": "Address used in the SMTP MAIL FROM command. No email is sent.",
                        "default": "verify@smtp-check.test"
                    },
                    "smtpTimeoutSecs": {
                        "title": "SMTP timeout",
                        "minimum": 5,
                        "maximum": 60,
                        "type": "integer",
                        "description": "Maximum seconds to wait for each SMTP connection and response.",
                        "default": 15
                    },
                    "retryCount": {
                        "title": "Temporary failure retries",
                        "minimum": 0,
                        "maximum": 3,
                        "type": "integer",
                        "description": "Extra attempts for temporary SMTP failures or connection errors.",
                        "default": 1
                    },
                    "maxEmailsPerDomain": {
                        "title": "Per-domain limit",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum emails checked per domain in one run. Extra emails for the same domain are skipped to reduce blocking risk.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```