# Yellow Pages Scraper (`maximedupre/yellowpages-scraper`) Actor

Scrape YellowPages.com business listings by keyword, location, search URL, or listing URL. Export names, phone numbers, addresses, websites, categories, ratings, reviews, hours, and source links for lead lists or market research.

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

## Pricing

from $1.35 / 1,000 scraped businesses

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

### 📌 Scrape Yellow Pages business listings

Yellow Pages Scraper collects public business listings from [YellowPages.com](https://www.yellowpages.com/). Search by business type and location, or paste YellowPages.com search and listing URLs, then export business names, phone numbers, addresses, websites, categories, ratings, review counts, opening hours when available, and source links.

Use this Actor when you need Yellow Pages business data for lead lists, local market research, territory checks, CRM enrichment, vendor discovery, or competitor mapping. The output is built for practical follow-up work: one saved item per business, with source URLs and scrape metadata so you can trace where each lead came from.

For a first run, keep the prefilled input: `dentist` in `Los Angeles, CA` with a 25-listing cap.

### ✅ What this Yellow Pages scraper does

- Scrapes public YellowPages.com search results.
- Accepts search terms with a city, state, or ZIP code.
- Accepts YellowPages.com search result URLs and business listing URLs.
- Saves one output item per business listing.
- Extracts phone numbers, street addresses, websites, categories, ratings, review counts, and source URLs.
- Can visit listing pages for richer details such as opening hours, coordinates, descriptions, and listing IDs.
- Lets you sort source results by relevance, distance, rating, or name.
- Charges only for saved business listings.
- Works with Apify API, exports, schedules, webhooks, and integrations.

The Actor is focused on public US YellowPages.com business listings. It does not scrape Yellow Pages Canada, Australia, German Gelbe Seiten, private data, email addresses, or third-party enrichment services.

### 📊 What data you get

Each output item is one Yellow Pages business listing. Fields can be empty when YellowPages.com does not show that data for a specific business.

| Field | Description |
| --- | --- |
| `businessName` | Business name shown on YellowPages.com. |
| `phone` | Public phone number when shown. |
| `website` | Business website link when shown. |
| `yellowPagesUrl` | Source YellowPages.com listing URL. |
| `listingId` | YellowPages listing ID when available. |
| `categories` | Business categories such as dentists or plumbers. |
| `address` | Parsed street, city, state, ZIP, country, and full address. |
| `rating`, `reviewCount` | Source rating and review count when shown. |
| `yearsInBusiness` | Years in business when shown in the listing card. |
| `openStatus`, `openingHours` | Open/closed text and listing-page hours when available. |
| `latitude`, `longitude` | Coordinates when YellowPages.com exposes them on the listing page. |
| `description`, `reviewSnippet` | Public description and snippet text when shown. |
| `searchTerm`, `searchLocation` | Search context that produced the row. |
| `sourceUrl`, `sourcePage`, `sourcePosition` | Source page, page number, and listing position. |
| `scrapedAt` | UTC timestamp when the row was saved. |

### 🧭 Common use cases

- Build local business lead lists by category and city.
- Find phone numbers and websites for outreach prep.
- Compare businesses in a city by category, rating, or review count.
- Enrich CRM accounts with Yellow Pages source data.
- Map service providers in a sales territory.
- Monitor local competitors with scheduled Apify runs.
- Export business listings to CSV, Excel, JSON, API clients, webhooks, or downstream Apify integrations.

### 🚀 How to run it

1. Add **Search terms**, such as `dentist`, `plumber`, `pizza`, or `family lawyer`.
2. Add a **Location**, such as `Los Angeles, CA` or `90210`.
3. Set **Max results** to control the number of saved business listings.
4. Optional: choose **Sort by** to request relevance, distance, highest rated, or name order from YellowPages.com.
5. Optional: paste YellowPages.com search result or listing URLs in **YellowPages URLs**.
6. Run the Actor and open the dataset when it finishes.

For a quick trust check, keep the default detail options enabled and use the prefilled 25-result cap. For larger lead lists, raise **Max results** up to 500.

### 🧾 Input example

```json
{
	"searchTerms": "dentist",
	"location": "Los Angeles, CA",
	"maxResults": 25,
	"sortBy": "relevance",
	"includeBusinessHours": true,
	"includeListingDetails": true,
	"includeClosedBusinesses": false
}
````

You can also start from source URLs:

```json
{
	"startUrls": [
		{
			"url": "https://www.yellowpages.com/search?search_terms=dentist&geo_location_terms=Los%20Angeles%2C%20CA"
		}
	],
	"maxResults": 25
}
```

### 📦 Output example

```json
{
	"businessName": "Frieden, Richard A DDS",
	"phone": "(323) 655-3854",
	"website": "http://friedenrichardadds.localsearch.com",
	"yellowPagesUrl": "https://www.yellowpages.com/los-angeles-ca/mip/frieden-richard-a-dds-14640832?lid=1002105049104",
	"listingId": "14640832",
	"categories": ["Dentists"],
	"address": {
		"street": "6360 Wilshire Blvd, Ste 506",
		"city": "Los Angeles",
		"state": "CA",
		"postalCode": "90048",
		"country": "US",
		"fullAddress": "6360 Wilshire Blvd, Ste 506, Los Angeles CA 90048"
	},
	"rating": 5,
	"reviewCount": 3,
	"yearsInBusiness": 33,
	"openingHours": ["Mo-Fr 09:00-17:00"],
	"latitude": 34.063534,
	"longitude": -118.36774,
	"searchTerm": "dentist",
	"searchLocation": "Los Angeles, CA",
	"sourceUrl": "https://www.yellowpages.com/search?search_terms=dentist&geo_location_terms=Los+Angeles%2C+CA",
	"sourcePage": 1,
	"sourcePosition": 1,
	"scrapedAt": "2026-06-02T23:01:17.628Z"
}
```

### 💳 Pricing

This Actor uses pay-per-event pricing. You pay for each saved business listing, not for searches that return no saved rows. Current local pricing starts at `$0.00135` per scraped business on Free, Bronze, Silver, and Gold tiers, with lower prices on Platinum and Diamond tiers.

Apify platform costs, exports, API access, scheduling, and integrations follow your Apify account setup.

### ⚠️ Limits and notes

- This Actor targets public US YellowPages.com pages.
- Some fields can be missing because YellowPages.com does not show the same data for every business.
- Opening hours, coordinates, descriptions, and listing IDs depend on listing detail pages.
- **Max results** is a saved-listing cap. If a source page has fewer matching businesses, the Actor returns fewer rows.
- Email addresses are not extracted because YellowPages.com usually does not show them on listing pages.
- Use scraped business data responsibly and follow applicable laws, platform rules, and outreach requirements.

### ❓ FAQ

#### 🔍 Can I scrape YellowPages.com without a search term?

Yes. Paste a YellowPages.com search results page or individual business listing URL in **YellowPages URLs**. If you use search terms, include a location so YellowPages.com can return local listings.

#### 📧 Does this scrape email addresses?

No. This Actor focuses on Yellow Pages listing data such as business names, phone numbers, addresses, websites, ratings, reviews, categories, and hours. Use a separate website contact tool if you want to inspect business websites for public emails.

#### ↕️ Can I sort results?

Yes. When using search terms and location, you can request relevance, distance, highest rated, or name sorting. YellowPages.com controls the final source ordering.

#### 🗓️ Can I run it on a schedule?

Yes. You can schedule runs in Apify, call the Actor through the API, connect webhooks, or export results to formats such as JSON, CSV, and Excel.

### 📝 Changelog

- 0.0: Initial release.

### 🆘 Support

For issues, questions, or feature requests, [file a ticket](https://console.apify.com/actors/maximedupre~yellowpages-scraper/issues) and I'll fix or implement it in less than 24h 🫡

### 🔗 Other actors

- [Company Address Scraper from Website Domains ↗](https://apify.com/maximedupre/business-address-scraper) - Find physical business addresses from company websites.
- [Website Emails Scraper ↗](https://apify.com/maximedupre/website-emails-scraper) - Extract public contact emails from websites you already care about.
- [Email MX Verifier ↗](https://apify.com/maximedupre/email-mx-verifier) - Check email syntax, MX records, disposable domains, and list-cleaning signals.
- [SMTP Email Verifier ↗](https://apify.com/maximedupre/smtp-email-verifier) - Verify email deliverability through SMTP checks without sending email.
- [LinkedIn Company Scraper ↗](https://apify.com/maximedupre/linkedin-company-scraper) - Export public LinkedIn company profile data for known companies.

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

# Actor input Schema

## `searchTerms` (type: `string`):

Business type, service, or keyword to search on YellowPages.com. Examples: dentist, plumber, pizza, family lawyer.

## `location` (type: `string`):

City and state or ZIP code to search. Examples: Los Angeles, CA or 90210.

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

Optional YellowPages.com search result URLs or individual business listing URLs. Use this when you already have source pages to scrape.

## `maxResults` (type: `integer`):

Maximum number of business listings to save. The Actor stops as soon as this many valid listings are collected.

## `sortBy` (type: `string`):

How YellowPages.com should order search results when using search terms and location.

## `includeBusinessHours` (type: `boolean`):

Visit listing pages to include source-provided opening hours when available.

## `includeListingDetails` (type: `boolean`):

Visit listing pages for richer fields such as coordinates, descriptions, listing IDs, and source-normalized ratings.

## `includeClosedBusinesses` (type: `boolean`):

Include businesses that YellowPages.com marks as closed when that status is visible.

## Actor input object example

```json
{
  "searchTerms": "dentist",
  "location": "Los Angeles, CA",
  "maxResults": 25,
  "sortBy": "relevance",
  "includeBusinessHours": true,
  "includeListingDetails": true,
  "includeClosedBusinesses": false
}
```

# 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 = {
    "searchTerms": "dentist",
    "location": "Los Angeles, CA",
    "maxResults": 25
};

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/yellowpages-scraper").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 = {
    "searchTerms": "dentist",
    "location": "Los Angeles, CA",
    "maxResults": 25,
}

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/yellowpages-scraper").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 '{
  "searchTerms": "dentist",
  "location": "Los Angeles, CA",
  "maxResults": 25
}' |
apify call maximedupre/yellowpages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yellow Pages Scraper",
        "description": "Scrape YellowPages.com business listings by keyword, location, search URL, or listing URL. Export names, phone numbers, addresses, websites, categories, ratings, reviews, hours, and source links for lead lists or market research.",
        "version": "0.0",
        "x-build-id": "nN89FawFGDoSIeDZd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~yellowpages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-yellowpages-scraper",
                "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~yellowpages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-yellowpages-scraper",
                "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~yellowpages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-yellowpages-scraper",
                "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": {
                    "searchTerms": {
                        "title": "Search terms",
                        "type": "string",
                        "description": "Business type, service, or keyword to search on YellowPages.com. Examples: dentist, plumber, pizza, family lawyer."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state or ZIP code to search. Examples: Los Angeles, CA or 90210."
                    },
                    "startUrls": {
                        "title": "YellowPages URLs",
                        "type": "array",
                        "description": "Optional YellowPages.com search result URLs or individual business listing URLs. Use this when you already have source pages to scrape.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "description": "A YellowPages.com search results page or business listing page.",
                                    "type": "string"
                                }
                            }
                        }
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of business listings to save. The Actor stops as soon as this many valid listings are collected.",
                        "default": 25
                    },
                    "sortBy": {
                        "title": "Sort by",
                        "enum": [
                            "relevance",
                            "distance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How YellowPages.com should order search results when using search terms and location.",
                        "default": "relevance"
                    },
                    "includeBusinessHours": {
                        "title": "Include business hours",
                        "type": "boolean",
                        "description": "Visit listing pages to include source-provided opening hours when available.",
                        "default": true
                    },
                    "includeListingDetails": {
                        "title": "Include listing details",
                        "type": "boolean",
                        "description": "Visit listing pages for richer fields such as coordinates, descriptions, listing IDs, and source-normalized ratings.",
                        "default": true
                    },
                    "includeClosedBusinesses": {
                        "title": "Include closed businesses",
                        "type": "boolean",
                        "description": "Include businesses that YellowPages.com marks as closed when that status is visible.",
                        "default": false
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```