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

Scrape US business listings from Yellow Pages including name, address, phone, website, rating, reviews, and more. Export to CSV, Excel, JSON, or XML.

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

## Pricing

from $19.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 📋 Yellow Pages Business Scraper

> 🚀 **Export US business listings from Yellow Pages in seconds.** Search any category and location to get **business names, addresses, phone numbers, websites, ratings, and more** - no API key, no login, no manual copy-paste.

> 🕒 **Last updated:** 2026-05-21 · **📊 15 fields** per record · **🏢 Millions of US businesses** · **🗺️ All 50 states** · **📞 Phone, address, and web data**

The **Yellow Pages Business Scraper** extracts structured business listings from [yellowpages.com](https://www.yellowpages.com) and returns **15 fields per record**, including business name, category, full address, phone number, website, star rating, review count, years in business, and a direct listing URL. Yellow Pages is one of the largest US business directories, covering restaurants, contractors, healthcare providers, legal services, and thousands of other categories across every US city and ZIP code.

The directory spans **all 50 states, hundreds of thousands of cities and towns**, and millions of active business listings. This Actor lets you download any slice of that data - one search term, one location, or a bulk list - as a clean, structured dataset in CSV, Excel, JSON, or XML in minutes.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sales and marketing teams, market researchers, local SEO agencies, lead generation platforms, B2B data providers, directory operators, real-estate analysts | Local lead lists, competitor audits, market sizing, directory enrichment, call list generation, franchise mapping, CRM seeding |

---

### 📋 What the Yellow Pages Scraper does

Four core workflows in a single run:

- 🔍 **Keyword + location search.** Enter any search term (plumber, dentist, pizza, lawyer) and any US location (city + state, ZIP code, or metro area).
- 📞 **Contact data extraction.** Collects phone numbers, websites, and full street addresses for every matching business.
- ⭐ **Review signals.** Captures star ratings and review counts so you can sort and filter by reputation.
- 📄 **Multi-page pagination.** Automatically walks through all result pages until your `maxItems` limit is reached.

Each record includes the direct Yellow Pages URL so you can revisit or deep-dive into any listing.

> 💡 **Why it matters:** manually copying business listings from directory searches is slow and error-prone. This Actor turns a 2-hour spreadsheet job into a 2-minute automated dataset pull, with consistent field names and clean formatting every time.

---

### 🎬 Full Demo

_🚧 Coming soon: a 3-minute walkthrough showing how to go from sign-up to a downloaded CSV of local businesses._

---

### ⚙️ Input

<table>
<thead>
<tr><th>Input</th><th>Type</th><th>Default</th><th>Behavior</th></tr>
</thead>
<tbody>
<tr><td><code>search</code></td><td>string</td><td><code>"plumber"</code></td><td>Business type or keyword (e.g. plumber, dentist, pizza restaurant).</td></tr>
<tr><td><code>location</code></td><td>string</td><td><code>"New York, NY"</code></td><td>US city + state or ZIP code (e.g. New York, NY or 10001).</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td><code>10</code></td><td>Records to return. Free plan caps at 10, paid plan at 1,000,000.</td></tr>
</tbody>
</table>

**Example: 50 plumbers in New York.**

```json
{
    "search": "plumber",
    "location": "New York, NY",
    "maxItems": 50
}
````

**Example: dentists in Los Angeles.**

```json
{
    "search": "dentist",
    "location": "Los Angeles, CA",
    "maxItems": 100
}
```

> ⚠️ **Good to Know:** Yellow Pages shows approximately 30 results per search page. Each record reflects the publicly visible listing data at time of scraping. Business details (phone, address, website) are provided by the businesses themselves and may occasionally be outdated. Always verify critical contact information before use in high-stakes outreach.

***

### 📊 Output

Each business record contains **15 fields**. Download the dataset as CSV, Excel, JSON, or XML.

#### 🧾 Schema

| Field | Type | Example |
|---|---|---|
| 🖼️ `imageUrl` | string | null | `"https://i1.ypcdn.com/blob/7ba86962f4b7..."` |
| 🏢 `businessName` | string | `"Fred Smith Plumbing & Heating Co., Inc."` |
| 🏷️ `category` | string | null | `"Plumbers"` |
| 📍 `address` | string | null | `"1674 1st Ave"` |
| 🏙️ `city` | string | null | `"New York"` |
| 🗺️ `state` | string | null | `"NY"` |
| 📮 `zip` | string | null | `"10128"` |
| 📞 `phone` | string | null | `"(212) 744-1300"` |
| 🌐 `website` | string | null | `"http://www.fredsmithplumbing.com"` |
| ⭐ `rating` | string | null | `"5.0"` |
| 💬 `reviewCount` | string | null | `"68"` |
| 📅 `yearsInBusiness` | string | null | `"112"` |
| 🔗 `url` | string | `"https://www.yellowpages.com/new-york-ny/mip/fred-smith-plumbing-heating-co-inc-460765127"` |
| 🕒 `scrapedAt` | ISO 8601 | `"2026-05-21T23:18:11.435Z"` |
| ❌ `error` | string | null | `null` |

#### 📦 Sample records

<details>
<summary><strong>🔧 Established plumber with ratings: Fred Smith Plumbing & Heating Co.</strong></summary>

```json
{
    "imageUrl": "https://i4.ypcdn.com/blob/e870806cb004505b957f249c133c00dd7bb08592_130x130_crop.jpg",
    "businessName": "Fred Smith Plumbing & Heating Co., Inc.",
    "category": "Plumbers",
    "address": "1674 1st Ave",
    "city": "New York",
    "state": "NY",
    "zip": "10128",
    "phone": "(212) 744-1300",
    "website": "http://www.fredsmithplumbing.com",
    "rating": "5.0",
    "reviewCount": "68",
    "yearsInBusiness": "112",
    "url": "https://www.yellowpages.com/new-york-ny/mip/fred-smith-plumbing-heating-co-inc-460765127",
    "scrapedAt": "2026-05-21T23:18:11.435Z",
    "error": null
}
```

</details>

<details>
<summary><strong>🪠 National plumbing chain: RR Plumbing Roto-Rooter</strong></summary>

```json
{
    "imageUrl": "https://i4.ypcdn.com/blob/94850e1522feb07bd424a37f4165194fe5f8b345_130x130_crop.jpg",
    "businessName": "RR Plumbing Roto-Rooter",
    "category": "Plumbers",
    "address": "450 7th Ave",
    "city": "New York",
    "state": "NY",
    "zip": "10001",
    "phone": "(917) 997-7507",
    "website": "https://www.rotorooter.com/manhattan/",
    "rating": "4.5",
    "reviewCount": "247",
    "yearsInBusiness": null,
    "url": "https://www.yellowpages.com/new-york-ny/mip/rr-plumbing-roto-rooter-574238364",
    "scrapedAt": "2026-05-21T23:18:11.435Z",
    "error": null
}
```

</details>

<details>
<summary><strong>💧 Specialist contractor: Aladdin Plumbing Corp.</strong></summary>

```json
{
    "imageUrl": "https://i1.ypcdn.com/blob/7ba86962f4b790dabcd2af52803d5216c3183720_130x130_crop.jpg",
    "businessName": "Aladdin Plumbing Corp.",
    "category": "Plumbers",
    "address": null,
    "city": "Brooklyn",
    "state": "NY",
    "zip": "11201",
    "phone": "(347) 395-4715",
    "website": "https://www.aladdinplumbingcorp.com/",
    "rating": "4.5",
    "reviewCount": "89",
    "yearsInBusiness": "23",
    "url": "https://www.yellowpages.com/kings-county-ny/mip/aladdin-plumbing-corp-548289617",
    "scrapedAt": "2026-05-21T23:18:11.435Z",
    "error": null
}
```

</details>

***

### ✨ Why choose this Actor

| | Capability |
|---|---|
| 🏢 | **Massive US coverage.** Millions of business listings across all 50 states and every major city. |
| 🔍 | **Any category, any location.** Search plumbers in Austin, divorce lawyers in Chicago, Italian restaurants in Miami - any combination works. |
| 📞 | **Contact-ready output.** Phone numbers and websites in every record, ready to import into a CRM or dialing platform. |
| ⭐ | **Reputation signals.** Star ratings and review counts let you filter for top-rated businesses. |
| 📅 | **Business longevity data.** Years in business field for filtering out new entrants or targeting established operators. |
| 🌐 | **No login required.** Yellow Pages is publicly accessible - no account, no API key, no monthly fee beyond Apify usage. |
| 🔁 | **Always current.** Every run fetches live data reflecting the latest listings, addresses, and ratings. |

> 📊 A single run that takes 2 minutes manually would take days to scale to 1,000 businesses. This Actor handles the pagination, parsing, and formatting automatically.

***

### 📈 How it compares to alternatives

| Approach | Cost | Coverage | Refresh | Contact data | Setup |
|---|---|---|---|---|---|
| **⭐ Yellow Pages Scraper** *(this Actor)* | $5 free credit, then pay-per-use | **Millions of US businesses** | **Live per run** | Phone, website, address | ⚡ 2 min |
| Manual copy-paste | Free | Limited by time | Manual | Yes | 🐢 Hours |
| Data broker subscriptions | $200-2,000+/month | Wide, often stale | Quarterly | Yes | ⏳ Days |
| Google Maps API | $200 credit/month, then pay-per-request | Global | Live | Partial | 🕒 Hours |
| Other YP scrapers | Variable | Partial | Variable | Inconsistent | 🕒 Hours |

Pick this Actor when you need US business listings fast, with direct contact data, at a fraction of data-broker prices.

***

### 🚀 How to use

1. 📝 **Sign up.** [Create a free account with $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp) (takes 2 minutes).
2. 🌐 **Open the Actor.** Go to the Yellow Pages Business Scraper page on the Apify Store.
3. 🎯 **Set input.** Enter your search term and location. Set `maxItems` for how many listings you need.
4. 🚀 **Run it.** Click **Start** and let the Actor collect your data.
5. 📥 **Download.** Grab your results in the **Dataset** tab as CSV, Excel, JSON, or XML.

> ⏱️ Total time from signup to downloaded dataset: **3-5 minutes.** No coding required.

***

### 💼 Business use cases

<table>
<tr>
<td width="50%" valign="top">

#### 🎯 Sales & Lead Generation

- Build targeted call lists by category and city
- Seed CRMs with verified phone numbers and websites
- Identify businesses without websites for outreach
- Filter by rating to find top performers in any market

</td>
<td width="50%" valign="top">

#### 📊 Market Research & Intelligence

- Count competitors in any local market segment
- Map franchise density by ZIP code or metro area
- Track new entrants and business closures over time
- Compare service coverage across cities

</td>
</tr>
<tr>
<td width="50%" valign="top">

#### 🔍 Local SEO & Directory Audits

- Audit NAP consistency (name, address, phone) vs. Google
- Identify citation gaps for local SEO clients
- Benchmark client rating vs. top competitors
- Bulk-export listings for citation cleanup campaigns

</td>
<td width="50%" valign="top">

#### 🏢 B2B Data & Enrichment

- Enrich existing business databases with phone/address
- Power location-based recommendation engines
- Build vertical-specific directories (e.g. all HVAC contractors in Texas)
- Validate business data at scale before outreach

</td>
</tr>
</table>

***

### 🔌 Automating Yellow Pages Scraper

Control the scraper programmatically for scheduled runs and pipeline integrations:

- 🟢 **Node.js.** Install the `apify-client` NPM package.
- 🐍 **Python.** Use the `apify-client` PyPI package.
- 📚 See the [Apify API documentation](https://docs.apify.com/api/v2) for full details.

The [Apify Schedules feature](https://docs.apify.com/platform/schedules) lets you trigger this Actor on any cron interval. Weekly or monthly refreshes keep your lead lists current as new businesses open and old ones close.

***

### 🌟 Beyond business use cases

Structured business directory data powers more than sales and marketing. The same records support research, civic projects, and creative initiatives.

<table>
<tr>
<td width="50%">

#### 🎓 Research and academia

- Local business density studies for urban economics papers
- Small business survival analysis using years-in-business data
- Geographic clustering of service industries for GIS theses
- Reproducible market datasets for peer-reviewed research

</td>
<td width="50%">

#### 🎨 Personal and creative

- Build a "best of" neighborhood guide with real ratings
- Hyperlocal business maps for community newsletters
- Personal CRM for preferred local service providers
- Portfolio project demonstrating data pipeline skills

</td>
</tr>
<tr>
<td width="50%">

#### 🤝 Non-profit and civic

- Map underserved areas where key services are absent
- Identify veteran-owned or minority-owned businesses
- Civic journalism on business vacancy and economic health
- Community resource directories for social services

</td>
<td width="50%">

#### 🧪 Experimentation

- Train local business recommendation ML models
- Test location-based search product concepts with real data
- Prototype CRM enrichment pipelines
- Validate hypotheses about local market saturation

</td>
</tr>
</table>

***

### 🤖 Ask an AI assistant about this scraper

Open a ready-to-send prompt about this ParseForge actor in the AI of your choice:

- 💬 [**ChatGPT**](https://chat.openai.com/?q=How%20do%20I%20use%20the%20Yellow%20Pages%20Business%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🧠 [**Claude**](https://claude.ai/new?q=How%20do%20I%20use%20the%20Yellow%20Pages%20Business%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🔍 [**Perplexity**](https://perplexity.ai/search?q=How%20do%20I%20use%20the%20Yellow%20Pages%20Business%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)
- 🅒 [**Copilot**](https://copilot.microsoft.com/?q=How%20do%20I%20use%20the%20Yellow%20Pages%20Business%20Scraper%20by%20ParseForge%20on%20Apify%3F%20Show%20me%20input%20examples%2C%20output%20fields%2C%20common%20use%20cases%2C%20and%20how%20to%20integrate%20it%20into%20a%20workflow.)

***

### ❓ Frequently Asked Questions

#### 🧩 How does it work?

Enter a search term and location in the input form, click Start, and the Actor navigates Yellow Pages search results using a browser with residential proxy support to bypass bot protection. It extracts all visible listing fields from each result page and pushes structured records to your dataset.

#### 📏 How accurate is the data?

Data is scraped live from Yellow Pages at run time. Business contact details (phone, address, website) are provided by the businesses themselves and Yellow Pages does not guarantee their accuracy. Cross-check critical fields before high-stakes outreach.

#### 🔁 How many results are there per search?

Yellow Pages typically shows approximately 30 organic listings per search page. For popular categories in major cities, there can be hundreds or thousands of results across pages. Set `maxItems` to control how many you collect.

#### 🏙️ What locations does it support?

Any US city, town, neighborhood, or ZIP code that Yellow Pages supports. Enter the location exactly as you would in the Yellow Pages search bar (e.g. "New York, NY", "Austin, TX", "10001").

#### ⏰ Can I schedule regular runs?

Yes. Use Apify Schedules to run this Actor on any cron interval and keep your business lists refreshed as new businesses open and old ones close.

#### ⚖️ Is this data legal to use?

Yellow Pages is a publicly accessible directory. The data is visible to any visitor. You are responsible for complying with Yellow Pages' terms of service and with applicable laws governing commercial use of business contact data in your jurisdiction.

#### 💼 Can I use this data commercially?

Business listings data (names, addresses, phone numbers) is generally factual public information. Consult with a legal advisor for your specific jurisdiction and intended use, particularly for high-volume outreach or resale.

#### 💳 Do I need a paid Apify plan?

No. The free Apify plan is enough for testing (10 records per run). A paid plan lifts the limit to 1,000,000 records per run and gives access to scheduling, higher concurrency, and larger datasets.

#### 🔁 What happens if a run fails?

Apify automatically retries transient errors. If a run fails, inspect the log in the Runs tab, check your input, and re-run. The Actor pushes an error record to the dataset if it hits an unrecoverable issue so you always get diagnostic output.

#### 📞 Are phone numbers included for every listing?

Most listings include a phone number. Businesses without a listed phone will have `null` in the `phone` field. This is expected for businesses that only list a website or address.

#### 🌐 Does it get website URLs?

Yes, when the business has linked a website in their Yellow Pages listing. About 60-70% of listings include a website URL in our testing.

#### 🆘 What if I need help?

Our support team is here to help. Contact us through the Apify platform or use the Tally form linked below.

***

### 🔌 Integrate with any app

Yellow Pages Scraper connects to any cloud service via [Apify integrations](https://apify.com/integrations):

- [**Make**](https://docs.apify.com/platform/integrations/make) - Automate multi-step workflows
- [**Zapier**](https://docs.apify.com/platform/integrations/zapier) - Connect with 5,000+ apps
- [**Slack**](https://docs.apify.com/platform/integrations/slack) - Get run notifications in your channels
- [**Airbyte**](https://docs.apify.com/platform/integrations/airbyte) - Pipe business data into your warehouse
- [**GitHub**](https://docs.apify.com/platform/integrations/github) - Trigger runs from commits and releases
- [**Google Drive**](https://docs.apify.com/platform/integrations/drive) - Export datasets straight to Sheets

You can also use webhooks to trigger downstream actions when a run finishes - push fresh leads into your CRM, or alert your team in Slack the moment a new run completes.

***

### 🔗 Recommended Actors

| Actor | Description |
|---|---|
| [**📋 Yelp Reviews Scraper**](https://apify.com/parseforge/yelp-reviews-scraper) | Scrape Yelp business reviews including ratings, review text, and reviewer details |
| [**🏢 Clutch Reviews Scraper**](https://apify.com/parseforge/clutch-reviews-scraper) | B2B service provider reviews and ratings from Clutch.co |
| [**💼 Upwork Scraper**](https://apify.com/parseforge/upwork-scraper) | Freelancer profiles, job listings, and client reviews from Upwork |
| [**🛍️ Trustpilot Reviews Scraper**](https://apify.com/parseforge/trustpilot-reviews-scraper) | Company reviews and trust scores from Trustpilot |
| [**🍽️ OpenTable Scraper**](https://apify.com/parseforge/opentable-scraper) | Restaurant listings, menus, and availability from OpenTable |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for more business and review data scrapers.

***

**🆘 Need Help?** [**Open our contact form**](https://tally.so/r/BzdKgA) to request a new scraper, propose a custom data project, or report an issue.

***

> **⚠️ Disclaimer:** this Actor is an independent tool and is not affiliated with, endorsed by, or sponsored by Yellow Pages, YP Holdings LLC, or any of its affiliates. All trademarks mentioned are the property of their respective owners. Only publicly available directory data is collected.

# Actor input Schema

## `search` (type: `string`):

Business type or keyword to search for (e.g. plumber, dentist, pizza)

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

City and state or ZIP code (e.g. New York, NY or 10001)

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

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "search": "plumber",
  "location": "New York, NY",
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "search": "plumber",
    "location": "New York, NY",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/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 = {
    "search": "plumber",
    "location": "New York, NY",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/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 '{
  "search": "plumber",
  "location": "New York, NY",
  "maxItems": 10
}' |
apify call parseforge/yellowpages-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yellow Pages Business Scraper",
        "description": "Scrape US business listings from Yellow Pages including name, address, phone, website, rating, reviews, and more. Export to CSV, Excel, JSON, or XML.",
        "version": "0.1",
        "x-build-id": "55MOqLtQkb72t17IW"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~yellowpages-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-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/parseforge~yellowpages-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-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/parseforge~yellowpages-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-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",
                "required": [
                    "search",
                    "location"
                ],
                "properties": {
                    "search": {
                        "title": "Search Terms",
                        "type": "string",
                        "description": "Business type or keyword to search for (e.g. plumber, dentist, pizza)"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City and state or ZIP code (e.g. New York, NY or 10001)"
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
