# YellowPagesScraper (`ahmed_hrid/yellowpagesscraper`) Actor

Extract comprehensive business data from YellowPages.com including contact information, ratings, business hours, and location details. Search by business category and location to build targeted business databases for lead generation, market research, and competitive analysis.

- **URL**: https://apify.com/ahmed\_hrid/yellowpagesscraper.md
- **Developed by:** [Ahmed hrid](https://apify.com/ahmed_hrid) (community)
- **Categories:** Lead generation, Automation, Developer tools
- **Stats:** 46 total users, 6 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.50 / 1,000 listings

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Yellow Pages Scraper

Extract comprehensive business data from YellowPages.com including contact information, ratings, business hours, and location details. Search by business category and location to build targeted business databases for lead generation, market research, and competitive analysis.

### What is Yellow Pages Scraper?

Yellow Pages Scraper is a powerful tool that extracts publicly available business listings from YellowPages.com, one of America's largest business directories. Simply enter a business category (like "dentist" or "plumber") and location, and get structured data with phone numbers, addresses, ratings, websites, and more. Perfect for **sales prospecting, market research, and competitive intelligence**.

**Key advantages of using this Actor on Apify:**
- ⏰ **Scheduling** - Set up automatic scraping runs daily, weekly, or monthly
- 🔄 **API access** - Integrate directly into your CRM or database
- 🌐 **Proxy rotation** - Reliable scraping without getting blocked
- 📊 **Multiple export formats** - JSON, CSV, Excel, XML
- 🔗 **Integrations** - Connect with 1000+ apps via Zapier, Make, and webhooks
- 📈 **Monitoring** - Track scraping performance and get alerts

### What can Yellow Pages Scraper do?

This Actor provides powerful features for extracting Yellow Pages business data:

✅ **Search by category and location** - Find businesses in any category across any US city, state, or ZIP code
✅ **Extract complete contact details** - Get phone numbers, full addresses, websites, and email information
✅ **Gather ratings and reviews** - Access average ratings and total review counts for quality assessment
✅ **Capture business hours** - Download operating hours for timing your outreach
✅ **Filter by status** - Choose to include or exclude closed businesses
✅ **Sort results** - Order by distance, rating, or relevance for better targeting
✅ **Bulk processing** - Scrape up to 500 listings per run for large-scale data collection
✅ **Structured output** - Get clean, organized data ready for import into any system

### What data can Yellow Pages Scraper extract?

| Field | Description | Example |
|-------|-------------|---------|
| **Business Name** | Official business name | "Smile Miami" |
| **Phone Number** | Primary contact number | "(305) 598-1428" |
| **Full Address** | Complete street address with city, state, ZIP | "9840 SW 77th Ave, Miami, FL, 33156" |
| **Website** | Business website URL | "http://www.smilemiami.com" |
| **Rating** | Average customer rating | 4.5 stars |
| **Total Reviews** | Number of customer reviews | 127 reviews |
| **Categories** | Business categories/services | ["Dentists", "Oral Surgery"] |
| **Business Hours** | Operating hours by day | "Mo-Tu 09:00-18:00" |
| **Open Status** | Current operating status | "Open now" / "Closed now" |
| **Distance** | Distance from search location | "1 mile" |
| **Years in Business** | How long established | "15 years" |
| **Amenities** | Available services/features | ["Wheelchair accessible", "Parking"] |
| **Yellow Pages URL** | Link to full listing | Direct listing link |
| **Listing ID** | Unique identifier | "1239990" |

### How to scrape Yellow Pages business data

Using Yellow Pages Scraper is simple:

1. **Open Yellow Pages Scraper** in Apify Console
2. **Enter your search query** - Type a business category (e.g., "restaurants", "dentist", "plumber")
3. **Specify location** - Add city, state, or ZIP code (e.g., "New York, NY", "10001")
4. **Configure options** (optional):
   - Choose how to sort results (distance, rating, relevance)
   - Set maximum number of businesses to scrape
   - Decide whether to include closed businesses
5. **Click Start** and wait for results
6. **Download your data** in JSON, CSV, or Excel format

**Integrate with Yellow Pages Scraper using webhooks**

Automate your lead generation workflow by setting up webhooks that trigger when scraping completes. Send extracted business data directly to your CRM, email marketing platform, or database without manual data entry. Perfect for building automated sales pipelines.

### How much will it cost to scrape Yellow Pages?

Yellow Pages Scraper uses simple, transparent pricing based on results extracted:

**💰 $1.5 per 1,000 business listings**

No hidden costs, no per-query charges, no compute fees. Pay once and extract as many business listings as you need throughout the month.

**What you can scrape for $5/month:**
- ✅ Unlimited searches across all US locations
- ✅ Up to 500 listings per run (no limit on total runs)
- ✅ All data fields included
- ✅ Full API access
- ✅ Scheduling and monitoring
- ✅ All export formats (JSON, CSV, Excel, XML)

**Perfect for:**
- 🎯 Sales teams building prospect lists
- 📊 Market researchers analyzing industries
- 🏢 Businesses tracking competitors
- 📧 Marketers creating targeted campaigns
- 💼 Agencies managing multiple clients

The flat monthly fee makes budgeting simple - no surprises, no variable costs based on usage.

### Input

Yellow Pages Scraper accepts the following input parameters. Click on the **Input** tab to configure your scraping run with an intuitive interface.

**Required fields:**
- **Search Query** - Business category or keyword (e.g., "dentist", "italian restaurant")
- **Location** - City, state, or ZIP code (e.g., "Miami, FL", "33156")

**Optional fields:**
- **Sort By** - Order results by relevance, distance, rating, or name
- **Maximum Items** - Limit results (1-500 listings)
- **Include Closed Businesses** - Include temporarily or permanently closed businesses
- **Proxy Configuration** - Use residential proxies for reliable scraping (recommended)

![Yellow Pages Scraper Input](https://via.placeholder.com/800x400/4A90E2/FFFFFF?text=Input+Screenshot)

### Output

Yellow Pages Scraper returns structured business data that you can download in various formats including JSON, CSV, Excel, and XML.

**Example output:**

```json
{
  "listingId": "1239990",
  "name": "Smile Miami",
  "url": "https://www.yellowpages.com/miami-fl/mip/smile-miami-1239990",
  "phone": "(305) 598-1428",
  "address": {
    "street": "9840 SW 77th Ave",
    "city": "Miami",
    "state": "FL",
    "zipCode": "33156",
    "country": "US",
    "fullAddress": "9840 SW 77th Ave, Miami, FL, 33156"
  },
  "rating": {
    "average": 4.8,
    "totalReviews": 127
  },
  "hours": [
    "Mo-Tu 09:00-18:00",
    "We-Fr 08:00-17:00"
  ],
  "website": "http://www.smilemiami.com",
  "categories": [
    "Dentists",
    "Oral & Maxillofacial Surgery"
  ],
  "openStatus": {
    "status": "open now",
    "text": "open now"
  },
  "distance": "1 mile"
}
````

The dataset is clean, properly structured, and ready to import into spreadsheets, CRMs, databases, or any business intelligence tool.

### Use cases for Yellow Pages data

#### Sales & Lead Generation

- **B2B prospecting** - Build targeted lists of potential clients by industry and location
- **Territory planning** - Map out businesses in your sales territories
- **Contact enrichment** - Add phone numbers and websites to existing contact databases
- **Cold calling lists** - Generate verified phone numbers for outreach campaigns

#### Market Research

- **Competitive analysis** - Track competitors' locations, services, and customer ratings
- **Market sizing** - Count businesses in specific categories by geography
- **Industry trends** - Monitor new business openings and closures
- **Gap analysis** - Identify underserved markets with few competitors

#### Business Intelligence

- **Location planning** - Research areas for opening new locations
- **Partnership opportunities** - Find complementary businesses for partnerships
- **Franchise research** - Analyze franchise presence across regions
- **Supplier discovery** - Locate vendors and service providers

#### Marketing & Advertising

- **Targeted campaigns** - Build email and direct mail lists by industry
- **Local SEO research** - Analyze competitor online presence
- **Directory management** - Verify and update your own business listings
- **Advertising targeting** - Create custom audiences for paid ads

### Is it legal to scrape Yellow Pages?

Yes, scraping publicly available data from Yellow Pages is legal. Yellow Pages displays business information that companies have chosen to list publicly in a business directory. This data is intended to be found and used by potential customers.

However, you should be aware that:

✅ **What we scrape**: Only public business information (names, addresses, phone numbers, ratings) that businesses have voluntarily listed
❌ **What we don't scrape**: Private user data, personal emails, or any non-public information

**Important compliance notes:**

- Personal data may be protected by GDPR (EU) and similar regulations worldwide
- Use scraped data responsibly and for legitimate business purposes
- Consult legal counsel if you're unsure about your specific use case
- Respect businesses' privacy and do-not-contact preferences

Our scraper is designed for ethical business use. Read more about the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/) on the Apify blog.

### Tips for getting the best results

**Optimize your searches:**

- 🎯 Use specific business categories (e.g., "family dentist" vs. "dentist")
- 📍 Start with ZIP codes for hyper-local results, then expand to cities
- 🔄 Run separate searches for different categories rather than broad terms
- ⭐ Sort by rating to prioritize high-quality businesses

**Maximize data quality:**

- ✅ Include closed businesses if doing historical analysis
- 📊 Scrape during off-peak hours (early morning) for faster results
- 🔁 Schedule regular runs to catch new listings and updates
- 💾 Export to CSV for easy filtering and analysis in Excel

**Save compute units:**

- Start with smaller maxItems (20-50) to test your search
- Use specific locations rather than broad state-wide searches
- Filter results in post-processing rather than running multiple searches

**Integration ideas:**

- Connect to Google Sheets for automatic list updates
- Pipe data into Salesforce or HubSpot via Zapier
- Set up Slack notifications when new businesses are found
- Build custom dashboards with Power BI or Tableau

### Troubleshooting

**No results found?**

- ✅ Check spelling of business category and location
- ✅ Try broader search terms (e.g., "food" instead of "vegan restaurant")
- ✅ Verify the location exists on Yellow Pages (some rural areas have limited listings)
- ✅ Try searching with ZIP code instead of city name

**Getting fewer results than expected?**

- Increase maxItems limit (default is 50, max is 500)
- Remove filters like "include closed businesses"
- Check if sort order is affecting results

**Data quality issues?**

- Some businesses may have incomplete information (this reflects Yellow Pages data)
- Closed businesses might still appear if not marked in Yellow Pages
- Phone numbers or websites may be outdated (depends on business updates)

**Actor running slowly?**

- Normal for large result sets (300+ listings)
- Consider breaking into smaller geographic areas
- Use residential proxies for better performance

**Need help?**

- 💬 Use the **Issues** tab to report bugs or request features
- 📧 Contact the developer for custom solutions or bulk processing
- 🎓 Check [Apify Academy](https://docs.apify.com/academy) for web scraping tutorials
- 👥 Join [Apify Discord](https://discord.com/invite/jyEM2PRvMU) to connect with the community

### Other business directory scrapers

Looking for more business data sources? Check out these related Actors:

- **Google Maps Scraper** - Extract business data from Google Maps with reviews and photos
- **Yelp Scraper** - Scrape restaurant and business data from Yelp with detailed reviews
- **LinkedIn Company Scraper** - Get company information and employee data from LinkedIn
- **BBB Scraper** - Extract Better Business Bureau ratings and complaint data

### API access and integrations

Yellow Pages Scraper provides full API access for seamless integration into your workflows:

#### Use the API

Access the Actor programmatically via Apify's REST API:

```bash
curl -X POST https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "query": "dentist",
    "location": "Miami, FL",
    "maxItems": 100
  }'
```

#### JavaScript/Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });
const input = {
  query: "dentist",
  location: "Miami, FL",
  maxItems: 100
};

const run = await client.actor("YOUR_ACTOR_ID").call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')
run_input = {
    "query": "dentist",
    "location": "Miami, FL",
    "maxItems": 100
}

run = client.actor("YOUR_ACTOR_ID").call(run_input=run_input)
items = client.dataset(run["defaultDatasetId"]).list_items().items
print(items)
```

#### Zapier Integration

Connect Yellow Pages Scraper to 5,000+ apps without code:

1. Create a Zap with Apify as the trigger
2. Choose "Actor Run Finished" as the event
3. Select Yellow Pages Scraper
4. Connect to your CRM, email tool, or database

### Frequently Asked Questions

#### Can I scrape multiple locations at once?

Currently, you need to run separate searches for each location. However, you can use our API or scheduling feature to automate multiple location searches in sequence.

#### How often is Yellow Pages data updated?

Yellow Pages data is updated by businesses themselves. Running the scraper regularly (weekly or monthly) ensures you have the most current information.

#### Can I get email addresses?

Yellow Pages typically doesn't display email addresses. The scraper extracts all publicly visible data, which usually includes phone numbers and websites but not emails.

#### What's the difference between this and Yellow Pages API?

Yellow Pages doesn't offer a public API for data extraction. This scraper provides programmatic access to public Yellow Pages data that would otherwise require manual copying.

#### Can I export to my CRM?

Yes! Export data as CSV and import directly, or use Zapier/Make integrations to automatically sync data to Salesforce, HubSpot, Pipedrive, and other CRMs.

#### Will I get blocked or rate limited?

The Actor uses Apify's proxy infrastructure to avoid detection and rate limiting. For best results, use residential proxies (recommended in proxy settings).

#### Can you build a custom version for my needs?

Absolutely! Contact me through Apify messaging for custom development, including specific data fields, custom filtering, or integration with your internal systems.

#### How do I schedule regular scraping?

Go to the **Schedule** tab in Apify Console to set up automated runs - daily, weekly, monthly, or custom intervals. Perfect for maintaining up-to-date business databases.

***

**Built with ❤️ for sales teams, marketers, and researchers**

Questions? Feedback? Ideas for improvement? Use the **Issues** tab or leave a review! Your input helps make this Actor better for everyone.

**Try Yellow Pages Scraper today** and transform hours of manual research into minutes of automated data collection.

# Actor input Schema

## `query` (type: `string`):

Business category, service, or keyword to search for (e.g., 'dentist', 'plumber', 'restaurants')

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

City, state, or ZIP code to search in (e.g., 'New York, NY', 'Los Angeles, CA', '10001')

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

How to sort the search results

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

Maximum number of business listings to scrape

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

Include businesses that are temporarily or permanently closed

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

Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.

## Actor input object example

```json
{
  "query": "dentist",
  "location": "New York, NY",
  "sortBy": "default",
  "maxItems": 100,
  "includeClosedBusinesses": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `businessListings` (type: `string`):

Dataset containing scraped business listings with contact information, ratings, and categories

# 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 = {
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("ahmed_hrid/yellowpagesscraper").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 = { "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    } }

# Run the Actor and wait for it to finish
run = client.actor("ahmed_hrid/yellowpagesscraper").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 '{
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call ahmed_hrid/yellowpagesscraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YellowPagesScraper",
        "description": "Extract comprehensive business data from YellowPages.com including contact information, ratings, business hours, and location details. Search by business category and location to build targeted business databases for lead generation, market research, and competitive analysis.",
        "version": "0.0",
        "x-build-id": "Cz2AieRbCUiAwaWth"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ahmed_hrid~yellowpagesscraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ahmed_hrid-yellowpagesscraper",
                "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/ahmed_hrid~yellowpagesscraper/runs": {
            "post": {
                "operationId": "runs-sync-ahmed_hrid-yellowpagesscraper",
                "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/ahmed_hrid~yellowpagesscraper/run-sync": {
            "post": {
                "operationId": "run-sync-ahmed_hrid-yellowpagesscraper",
                "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": [
                    "query",
                    "location"
                ],
                "properties": {
                    "query": {
                        "title": "Search Query",
                        "type": "string",
                        "description": "Business category, service, or keyword to search for (e.g., 'dentist', 'plumber', 'restaurants')",
                        "default": "dentist"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City, state, or ZIP code to search in (e.g., 'New York, NY', 'Los Angeles, CA', '10001')",
                        "default": "New York, NY"
                    },
                    "sortBy": {
                        "title": "Sort Results By",
                        "enum": [
                            "default",
                            "average_rating"
                        ],
                        "type": "string",
                        "description": "How to sort the search results",
                        "default": "default"
                    },
                    "maxItems": {
                        "title": "Maximum Items",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of business listings to scrape",
                        "default": 100
                    },
                    "includeClosedBusinesses": {
                        "title": "Include Closed Businesses",
                        "type": "boolean",
                        "description": "Include businesses that are temporarily or permanently closed",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy servers used by the scraper to hide its origin. <strong>Recommended for reliable scraping</strong> to avoid rate limiting and blocking.<br><br>Select 'Apify Proxy (automatic)' for best results.",
                        "default": {}
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
