# Website Contact Finder (`fetch_cat/website-contact-finder`) Actor

Find public emails, phone numbers, and social links from websites and domains for lead-ready contact enrichment.

- **URL**: https://apify.com/fetch\_cat/website-contact-finder.md
- **Developed by:** [Hanna Nosova](https://apify.com/fetch_cat) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.05 / 1,000 contact extracteds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Website Contact Finder

Find public emails, phone numbers, and social profile links from company websites and domains. Website Contact Finder turns a list of domains into lead-ready contact records with source URLs, confidence signals, crawl counts, and extraction errors.

### What does Website Contact Finder do?

Website Contact Finder crawls public pages on a website and extracts useful contact details for sales, partnerships, recruiting, agency prospecting, and enrichment workflows.

It can collect:

- 📧 Email addresses
- ☎️ Phone numbers
- 🔗 Social profile links
- 🌐 Source pages where each contact was found
- ✅ Confidence signals and optional email-domain MX status
- 🧭 Crawl diagnostics such as pages crawled and errors

### Who is it for?

This actor is useful for teams that need structured contact data from public websites.

- Sales teams building prospect lists
- Agencies enriching domain lists
- Recruiters looking for company contact channels
- Partnership teams finding business development inboxes
- Data teams cleaning or validating web leads
- Founders researching target accounts

### Why use this actor?

Manually opening every company website and checking the footer, contact page, about page, team page, and social links is slow. Website Contact Finder automates that repetitive work and keeps every discovered contact tied to an evidence URL.

### Key features

- Bounded website crawl with depth and page limits
- Sitemap discovery for faster contact-page discovery
- Contact, about, team, legal, support, and footer-oriented discovery
- Email, phone, and social link extraction
- Optional MX validation for email domains
- Dedupe across pages
- Confidence score for each email
- Lead-ready row per domain

### What data can you extract?

| Field | Description |
|---|---|
| `domain` | Normalized website domain |
| `seedUrl` | Original URL used to start the crawl |
| `sourceUrl` | Best page where contact data was found |
| `contactPageType` | Signal such as contact, about, mailto, or general |
| `emails` | Email records with confidence and source URL |
| `phones` | Public phone numbers found on pages |
| `socialLinks` | LinkedIn, Facebook, Instagram, X/Twitter, YouTube, TikTok |
| `matchedSignals` | Signals that explain why the record was matched |
| `pagesCrawled` | Number of pages visited for the domain |
| `errors` | Non-fatal crawl or fetch errors |

### How much does it cost to find website contacts?

The actor uses pay-per-event pricing. A small start event is charged for each run and a contact record event is charged for each website/domain result saved. Final tiered pricing is set after cloud cost measurement.

### Input options

You can provide full URLs or plain domains.

```json
{
  "startUrls": [{ "url": "https://www.w3.org/contact/" }],
  "maxPagesPerDomain": 10,
  "crawlDepth": 2,
  "includeSitemap": true,
  "includePhones": true,
  "includeSocialLinks": true,
  "validateMx": false,
  "sameDomainOnly": true
}
````

### Start URLs

Use `startUrls` when you already have full URLs such as homepage URLs, contact page URLs, or company website URLs.

### Domains

Use `domains` when your source list contains values like `example.com`. The actor will convert each domain into an HTTPS start URL.

### Crawl settings

`maxPagesPerDomain` controls the maximum number of pages visited per website. Start with 10 to keep runs fast, then increase for larger websites.

`crawlDepth` controls how many link levels the actor follows from the seed URL.

### Contact enrichment settings

Enable phone extraction when you want public telephone numbers. Enable social extraction when you want official social profile links. Enable MX validation when you want to check whether an email domain can receive mail.

### Output example

```json
{
  "domain": "w3.org",
  "seedUrl": "https://www.w3.org/contact/",
  "sourceUrl": "https://www.w3.org/contact/",
  "contactPageType": "mailto",
  "emails": [
    {
      "email": "contact@w3.org",
      "normalizedEmail": "contact@w3.org",
      "sourceUrl": "https://www.w3.org/contact/",
      "confidence": 100,
      "mxValid": null
    }
  ],
  "phones": [],
  "socialLinks": {},
  "matchedSignals": ["email_regex", "mailto"],
  "pagesCrawled": 3,
  "firstSeenAt": "2026-06-22T00:00:00.000Z",
  "errors": []
}
```

### Tips for best results

- Start with homepage URLs or known contact-page URLs.
- Keep page limits modest for first runs.
- Use `sameDomainOnly` for clean company-level results.
- Turn on MX validation only when needed.
- Review `sourceUrl` before importing contacts into outreach tools.

### Integrations

Use the output dataset with:

- CRM enrichment workflows
- Google Sheets exports
- Sales engagement tools
- Lead scoring pipelines
- Internal prospecting dashboards
- No-code automation tools

### API usage with Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('fetch_cat/website-contact-finder').call({
  startUrls: [{ url: 'https://www.w3.org/contact/' }],
  maxPagesPerDomain: 10
});
console.log(run.defaultDatasetId);
```

### API usage with Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('fetch_cat/website-contact-finder').call(run_input={
    'startUrls': [{'url': 'https://www.w3.org/contact/'}],
    'maxPagesPerDomain': 10,
})
print(run['defaultDatasetId'])
```

### API usage with cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/fetch_cat~website-contact-finder/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"startUrls":[{"url":"https://www.w3.org/contact/"}],"maxPagesPerDomain":10}'
```

### MCP usage

Connect this actor to Apify MCP and ask your assistant to find public contacts for a list of company websites.

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com/?tools=fetch_cat/website-contact-finder
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?tools=fetch_cat/website-contact-finder"
    }
  }
}
```

Example prompts:

- "Find public emails and LinkedIn links for these domains."
- "Crawl these company websites and return contact-page evidence URLs."
- "Validate email domains with MX checks for this prospect list."

### Data quality notes

The actor extracts public information from web pages. Email confidence scores are heuristics based on source page and contact signals. Always review results before using them in outreach.

### Legality

Only use this actor for lawful purposes and follow applicable privacy, anti-spam, and marketing rules. The actor is intended for public business contact discovery, not private or restricted data access.

### Troubleshooting

#### Why did a website return no contacts?

Some websites hide contact information behind forms, images, scripts, or login walls. Increase `maxPagesPerDomain`, provide a known contact page, or review the `errors` field.

#### Why are there fewer pages crawled than my limit?

The actor stops when it runs out of same-domain links or reaches the configured crawl depth.

#### Should I enable proxies?

Most public websites do not need proxies. Leave proxy settings disabled unless a target blocks direct requests.

### Related scrapers

Explore other Apify actors from this account for content crawling, website monitoring, lead enrichment, and business data collection.

### FAQ

#### Can it crawl multiple websites in one run?

Yes. Add multiple entries to `startUrls` or `domains`.

#### Does it validate every email address?

It can optionally validate the email domain with MX records. It does not send email or verify inbox ownership.

#### Does it charge per page?

No. The current design charges per saved website/domain contact record, not per crawled page.

#### Can it find social links?

Yes. It detects common public social profile domains including LinkedIn, Facebook, Instagram, X/Twitter, YouTube, and TikTok.

### Changelog

Initial version: domain crawl, sitemap discovery, email extraction, phone extraction, social link extraction, confidence scoring, optional MX validation, and crawl diagnostics.

### Limits

The actor uses strict depth and page caps to keep runs predictable. Very large websites may require higher limits or a targeted contact-page URL.

### Support

If you need a specific website pattern supported, include an example URL and the expected contact fields when opening an issue.

### Version

Current build target: `0.1`.

# Actor input Schema

## `startUrls` (type: `array`):

Website URLs to crawl for public contact details.

## `domains` (type: `array`):

Optional plain domains. Use this when you have example.com instead of a full URL.

## `maxPagesPerDomain` (type: `integer`):

Hard cap on pages crawled for each domain. Lower values keep runs faster and cheaper.

## `crawlDepth` (type: `integer`):

How many link levels to follow from each start URL.

## `includeSitemap` (type: `boolean`):

Use sitemap URLs to discover contact, about, team, legal, and support pages faster.

## `sameDomainOnly` (type: `boolean`):

Only follow links on the same website domain.

## `includePhones` (type: `boolean`):

Find public phone numbers in page text.

## `includeSocialLinks` (type: `boolean`):

Find LinkedIn, Facebook, Instagram, X/Twitter, YouTube, and TikTok profile links.

## `validateMx` (type: `boolean`):

Check whether each email domain has mail exchange records. This can add DNS latency.

## `proxyConfiguration` (type: `object`):

Optional Apify Proxy settings. Leave empty for normal public websites.

## Actor input object example

```json
{
  "startUrls": [
    {
      "url": "https://www.w3.org/contact/"
    }
  ],
  "domains": [],
  "maxPagesPerDomain": 10,
  "crawlDepth": 2,
  "includeSitemap": true,
  "sameDomainOnly": true,
  "includePhones": true,
  "includeSocialLinks": true,
  "validateMx": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `contacts` (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 = {
    "startUrls": [
        {
            "url": "https://www.w3.org/contact/"
        }
    ],
    "domains": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("fetch_cat/website-contact-finder").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 = {
    "startUrls": [{ "url": "https://www.w3.org/contact/" }],
    "domains": [],
}

# Run the Actor and wait for it to finish
run = client.actor("fetch_cat/website-contact-finder").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 '{
  "startUrls": [
    {
      "url": "https://www.w3.org/contact/"
    }
  ],
  "domains": []
}' |
apify call fetch_cat/website-contact-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fetch_cat/website-contact-finder",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Website Contact Finder",
        "description": "Find public emails, phone numbers, and social links from websites and domains for lead-ready contact enrichment.",
        "version": "0.1",
        "x-build-id": "eBtBAkQNqK3urfjuI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fetch_cat~website-contact-finder/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fetch_cat-website-contact-finder",
                "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/fetch_cat~website-contact-finder/runs": {
            "post": {
                "operationId": "runs-sync-fetch_cat-website-contact-finder",
                "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/fetch_cat~website-contact-finder/run-sync": {
            "post": {
                "operationId": "run-sync-fetch_cat-website-contact-finder",
                "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": {
                    "startUrls": {
                        "title": "Start URLs",
                        "type": "array",
                        "description": "Website URLs to crawl for public contact details.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "domains": {
                        "title": "Domains",
                        "type": "array",
                        "description": "Optional plain domains. Use this when you have example.com instead of a full URL.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPagesPerDomain": {
                        "title": "Maximum pages per domain",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on pages crawled for each domain. Lower values keep runs faster and cheaper.",
                        "default": 10
                    },
                    "crawlDepth": {
                        "title": "Crawl depth",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "How many link levels to follow from each start URL.",
                        "default": 2
                    },
                    "includeSitemap": {
                        "title": "Check sitemap.xml",
                        "type": "boolean",
                        "description": "Use sitemap URLs to discover contact, about, team, legal, and support pages faster.",
                        "default": true
                    },
                    "sameDomainOnly": {
                        "title": "Stay on the same domain",
                        "type": "boolean",
                        "description": "Only follow links on the same website domain.",
                        "default": true
                    },
                    "includePhones": {
                        "title": "Extract phone numbers",
                        "type": "boolean",
                        "description": "Find public phone numbers in page text.",
                        "default": true
                    },
                    "includeSocialLinks": {
                        "title": "Extract social links",
                        "type": "boolean",
                        "description": "Find LinkedIn, Facebook, Instagram, X/Twitter, YouTube, and TikTok profile links.",
                        "default": true
                    },
                    "validateMx": {
                        "title": "Validate email domains with MX lookup",
                        "type": "boolean",
                        "description": "Check whether each email domain has mail exchange records. This can add DNS latency.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional Apify Proxy settings. Leave empty for normal public websites.",
                        "default": {
                            "useApifyProxy": 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
