# Phone Number Validation API (`automation-lab/phone-number-validation-api`) Actor

📞 Validate, normalize, format, and deduplicate phone numbers in bulk. Get E.164, country, type, extension, and validation reasons.

- **URL**: https://apify.com/automation-lab/phone-number-validation-api.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

## Phone Number Validation API

Validate, normalize, format, and deduplicate phone numbers in bulk on Apify.

This actor uses maintained libphonenumber metadata locally, so you do not need a paid validation API key, cookies, or a website account.

### What does Phone Number Validation API do?

Phone Number Validation API turns messy phone lists into structured validation rows.

It accepts raw phone numbers, optional free-form text, and a default country for national numbers.

For every candidate, it returns validity, possibility, E.164 format, international format, national format, region, calling code, type, extension, duplicate metadata, and a clear validation reason.

### Who is it for?

Sales operations teams use it before importing leads into a CRM.

Growth teams use it before calling or SMS campaigns.

Data enrichment teams use it inside Apify workflows.

Developers use it when they need a simple phone validation API without adding another vendor.

QA teams use it to check web-form submissions and CSV uploads.

### Why use this actor?

- ✅ No external API key required
- ✅ Works with bulk phone lists
- ✅ Normalizes to E.164
- ✅ Supports international formats
- ✅ Detects invalid and possible-only numbers
- ✅ Extracts phone numbers from text
- ✅ Flags duplicates
- ✅ Produces clean dataset rows

### What data can you validate?

You can validate phone numbers copied from CRMs, spreadsheets, form submissions, lead databases, support tickets, or free-form notes.

The actor is best for structural validation and normalization.

It does not call carriers and does not verify whether a subscriber currently owns the number.

### Output data

| Field | Description |
| --- | --- |
| `input` | Original candidate value |
| `source` | `numbers` or `text` |
| `isValid` | Whether the number is valid |
| `isPossible` | Whether the number shape is possible |
| `validationStatus` | `valid`, `possible`, `invalid`, `parse_error`, or `duplicate` |
| `reason` | Human-readable validation explanation |
| `e164` | Canonical E.164 number |
| `internationalFormat` | Human-readable international format |
| `nationalFormat` | Local national format |
| `rfc3966` | Phone URI format |
| `country` | Detected ISO country code |
| `countryCallingCode` | Calling code |
| `numberType` | Mobile, fixed line, toll free, etc. when known |
| `extension` | Parsed extension |
| `normalizedDigits` | Digits-only value |
| `duplicateOf` | First normalized duplicate value |
| `processedAt` | Processing timestamp |

### How much does it cost to validate phone numbers?

The actor uses pay-per-event pricing.

There is a small run start fee and a per-result fee for each emitted validation row.

Because the actor runs locally against metadata and does not use proxies, large batches are usually inexpensive.

Check the Pricing tab on the Apify Store page for current tiered prices.

### How to use it

1. Open the actor on Apify.
2. Paste phone numbers into the `numbers` input.
3. Set `defaultCountry` for national numbers without a `+` prefix.
4. Optionally paste notes into `text` to extract phone numbers automatically.
5. Choose whether to include invalid rows.
6. Choose whether to remove duplicates.
7. Run the actor.
8. Download the dataset as JSON, CSV, Excel, or via API.

### Input example

```json
{
  "numbers": [
    "+1 415 555 2671",
    "(020) 7946 0958",
    "+420 777 123 456 ext. 9",
    "555-0100"
  ],
  "text": "Sales contacts: +1 212 555 0199 and +44 20 7946 0018",
  "defaultCountry": "US",
  "includeInvalid": true,
  "deduplicate": false,
  "maxItems": 100
}
````

### Output example

```json
{
  "input": "+1 415 555 2671",
  "source": "numbers",
  "isValid": true,
  "isPossible": true,
  "validationStatus": "valid",
  "reason": "Number is valid according to libphonenumber metadata.",
  "e164": "+14155552671",
  "internationalFormat": "+1 415 555 2671",
  "nationalFormat": "(415) 555-2671",
  "country": "US",
  "countryCallingCode": "1",
  "numberType": "FIXED_LINE_OR_MOBILE"
}
```

### Tips for best results

Use international `+` prefixes when available.

Set `defaultCountry` when validating national numbers.

Keep invalid rows on during audits so you can see reasons.

Turn deduplication on for clean CRM imports.

Use `maxItems` to cap accidental large text extraction runs.

### CRM hygiene workflow

Export contacts from your CRM as phone-number strings.

Run them through this actor with your main market as `defaultCountry`.

Filter rows where `isValid` is true.

Import the E.164 column back into your CRM.

Review invalid rows separately before deleting them.

### Sales operations workflow

Before a calling campaign, validate phone numbers and remove duplicates.

Use `numberType` and `country` to route lists by market.

Use `reason` to explain rejected rows to upstream lead vendors.

### Lead enrichment workflow

Add this actor after a scraper or lead finder.

Pass extracted phone numbers to this actor.

Join results back to the source dataset by input value or row order.

### Form QA workflow

Paste exported form submissions into the text field.

The actor extracts phone-like candidates and validates them.

This helps detect broken country selectors, missing prefixes, and short test numbers.

### Integrations

Use the actor with Apify tasks for recurring CRM checks.

Use webhooks to send finished datasets to Make, Zapier, or your backend.

Use the Apify API to validate phone lists from internal tools.

Use dataset exports for spreadsheet review.

### API usage with Node.js

```js
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/phone-number-validation-api').call({
  numbers: ['+1 415 555 2671'],
  defaultCountry: 'US'
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient

client = ApifyClient('MY-APIFY-TOKEN')
run = client.actor('automation-lab/phone-number-validation-api').call(run_input={
    'numbers': ['+1 415 555 2671'],
    'defaultCountry': 'US',
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~phone-number-validation-api/runs?token=$APIFY_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"numbers":["+1 415 555 2671"],"defaultCountry":"US"}'
```

### MCP usage

Use the actor from Claude Desktop or Claude Code through Apify MCP.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/phone-number-validation-api
```

Claude Code setup:

```bash
claude mcp add apify-phone-validation https://mcp.apify.com/?tools=automation-lab/phone-number-validation-api
```

Claude Desktop JSON config:

```json
{
  "mcpServers": {
    "apify-phone-validation": {
      "url": "https://mcp.apify.com/?tools=automation-lab/phone-number-validation-api"
    }
  }
}
```

Example prompts:

- Validate these CRM phone numbers and return E.164 values.
- Extract phone numbers from this sales note and flag invalid ones.
- Deduplicate this list before I import it into HubSpot.

### Limitations

This actor validates number structure using metadata.

It does not perform live carrier lookup.

It does not guarantee the number is currently active.

It does not identify the owner of a number.

It does not bypass consent or compliance requirements.

### Legality

Phone-number formatting and structural validation is generally allowed for data you are permitted to process.

You are responsible for complying with privacy, telemarketing, SMS, and consent laws in your jurisdiction.

Do not use validated numbers for unsolicited outreach where prohibited.

### Troubleshooting

If a national number parses incorrectly, set `defaultCountry` to the correct ISO country code.

If you only want clean rows, set `includeInvalid` to false.

If duplicates appear, enable `deduplicate`.

If no text numbers are detected, paste clearer separators or use the `numbers` list directly.

### FAQ

#### Does this verify whether a phone line is active?

No. It validates structure and metadata, not live subscriber status.

#### Does it need Twilio or another API key?

No. It runs against bundled libphonenumber metadata.

#### Can it process thousands of numbers?

Yes. Use `maxItems` to control batch size and cost.

#### Can it validate international numbers?

Yes. Use `+` country prefixes or set a default country for local numbers.

### Related scrapers and actors

Explore other Automation Lab actors at https://apify.com/automation-lab/ for lead enrichment, website contact extraction, and data cleanup workflows.

### Changelog

Initial version validates and normalizes phone numbers, extracts text candidates, and detects duplicates.

### Support

If a number parses differently than expected, include the raw input, default country, and expected format when reporting the issue.

# Actor input Schema

## `numbers` (type: `array`):

Raw phone numbers to validate. Include country codes when available, or set Default country for national numbers.

## `text` (type: `string`):

Optional free-form text. The actor will detect phone-like values and validate them after processing the explicit phone numbers above.

## `defaultCountry` (type: `string`):

ISO 3166-1 alpha-2 country code used to parse national numbers without a + country prefix.

## `includeInvalid` (type: `boolean`):

When enabled, the dataset includes invalid and possible-only numbers with validation reasons. Disable for clean CRM exports.

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

When enabled, repeated normalized numbers are skipped from the output dataset.

## `maxItems` (type: `integer`):

Maximum phone-number candidates to process from the combined numbers and text inputs.

## Actor input object example

```json
{
  "numbers": [
    "+1 415 555 2671",
    "(020) 7946 0958",
    "+420 777 123 456 ext. 9",
    "555-0100"
  ],
  "text": "Sales contacts: US +1 212 555 0199, UK +44 20 7946 0018, duplicate +1 (212) 555-0199.",
  "defaultCountry": "US",
  "includeInvalid": true,
  "deduplicate": false,
  "maxItems": 20
}
```

# Actor output Schema

## `overview` (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 = {
    "numbers": [
        "+1 415 555 2671",
        "(020) 7946 0958",
        "+420 777 123 456 ext. 9",
        "555-0100"
    ],
    "text": "Sales contacts: US +1 212 555 0199, UK +44 20 7946 0018, duplicate +1 (212) 555-0199.",
    "defaultCountry": "US",
    "includeInvalid": true,
    "deduplicate": false,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/phone-number-validation-api").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 = {
    "numbers": [
        "+1 415 555 2671",
        "(020) 7946 0958",
        "+420 777 123 456 ext. 9",
        "555-0100",
    ],
    "text": "Sales contacts: US +1 212 555 0199, UK +44 20 7946 0018, duplicate +1 (212) 555-0199.",
    "defaultCountry": "US",
    "includeInvalid": True,
    "deduplicate": False,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/phone-number-validation-api").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 '{
  "numbers": [
    "+1 415 555 2671",
    "(020) 7946 0958",
    "+420 777 123 456 ext. 9",
    "555-0100"
  ],
  "text": "Sales contacts: US +1 212 555 0199, UK +44 20 7946 0018, duplicate +1 (212) 555-0199.",
  "defaultCountry": "US",
  "includeInvalid": true,
  "deduplicate": false,
  "maxItems": 20
}' |
apify call automation-lab/phone-number-validation-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=automation-lab/phone-number-validation-api",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Phone Number Validation API",
        "description": "📞 Validate, normalize, format, and deduplicate phone numbers in bulk. Get E.164, country, type, extension, and validation reasons.",
        "version": "0.1",
        "x-build-id": "r5mxO4959Atfp4shQ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~phone-number-validation-api/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-phone-number-validation-api",
                "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/automation-lab~phone-number-validation-api/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-phone-number-validation-api",
                "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/automation-lab~phone-number-validation-api/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-phone-number-validation-api",
                "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": {
                    "numbers": {
                        "title": "Phone numbers",
                        "type": "array",
                        "description": "Raw phone numbers to validate. Include country codes when available, or set Default country for national numbers.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "text": {
                        "title": "Extract numbers from text",
                        "type": "string",
                        "description": "Optional free-form text. The actor will detect phone-like values and validate them after processing the explicit phone numbers above."
                    },
                    "defaultCountry": {
                        "title": "Default country",
                        "type": "string",
                        "description": "ISO 3166-1 alpha-2 country code used to parse national numbers without a + country prefix.",
                        "default": "US"
                    },
                    "includeInvalid": {
                        "title": "Include invalid numbers",
                        "type": "boolean",
                        "description": "When enabled, the dataset includes invalid and possible-only numbers with validation reasons. Disable for clean CRM exports.",
                        "default": true
                    },
                    "deduplicate": {
                        "title": "Remove duplicates",
                        "type": "boolean",
                        "description": "When enabled, repeated normalized numbers are skipped from the output dataset.",
                        "default": false
                    },
                    "maxItems": {
                        "title": "Maximum candidates",
                        "minimum": 1,
                        "maximum": 100000,
                        "type": "integer",
                        "description": "Maximum phone-number candidates to process from the combined numbers and text inputs.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```