# VietnamYello Business Directory Scraper (`solidcode/vietnamyello-scraper`) Actor

\[💰 $0.4 / 1K] Extract Vietnam business listings from VietnamYello — company name, phone, website, full address, GPS coordinates, categories, opening hours, registration & VAT numbers, and employee count. Browse by category and city, or search by keyword. Clean data for lead generation.

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

## Pricing

from $0.40 / 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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## VietnamYello Business Directory Scraper

Pull business listings from VietnamYello, Vietnam's national Yellow Pages directory, at scale — company names, phone and fax numbers, websites, full addresses, GPS coordinates, opening hours, registration and VAT numbers, employee counts, and review summaries across 237 categories and all 33 cities and provinces. Built for B2B sales teams, market researchers, and lead-generation agencies who need a clean, structured dataset of Vietnamese companies without copying profiles off the directory one page at a time.

### Why This Scraper?

- **237 business categories across 33 cities and provinces** — browse restaurants, lawyers, estate agents, doctors, and construction services in Hanoi, Ho Chi Minh City, Da Nang, Hai Phong, and every Vietnamese province, all from one run.
- **Category × city cross-product in a single run** — pair any category with any city (restaurants in Hanoi, lawyers in Da Nang) to narrow to exactly the segment you want, or leave one side blank to sweep a whole category or a whole city.
- **GPS coordinates on every listing** — latitude and longitude on each company for map plotting, territory assignment, and radius filtering, straight from the directory.
- **15+ structured fields per company** — name, phone, fax, website, street address, city, categories, opening hours, and year established folded into one flat row per business.
- **Official registration and VAT numbers** — company registration code and VAT/tax number for KYB checks, compliance, and entity matching, wherever the business publishes them.
- **Resolved website URLs, not link wrappers** — the real external company domain, decoded and ready to enrich or crawl, rather than an opaque directory redirect link.
- **Verified badge and platform tenure** — a `verified` flag plus listing tenure (for example "+14 Years With Us") to prioritise established, long-standing businesses over thin profiles.
- **Free-text keyword search plus paste-URL mode** — search all of Vietnam for niche business types that have no dedicated category page ("seafood export", "software company"), or paste any category, city, search, or company URL directly.
- **Up to 50,000 results per run** — with employee-count band, a products list, and a review summary (star rating + count) enriched onto every detailed row.

### Use Cases

**Lead Generation**
- Build B2B call lists with company name, phone, fax, and website for any category
- Assemble prospect lists for a whole city or province in one pass
- Target established businesses first using the verified flag and platform tenure
- Enrich a shortlist by pasting individual company profile URLs

**Market & Competitive Research**
- Map how many businesses operate in a category across Vietnamese cities
- Compare a category's footprint between Hanoi, Ho Chi Minh City, and Da Nang
- Track new and long-standing companies by year established and listing tenure
- Size a local market before entering it

**B2B Sales & Territory Planning**
- Plot companies on a map with per-listing GPS coordinates
- Assign sales territories by city, province, or radius
- Segment prospects by employee-count band and category
- Prioritise outreach by verified status and years on the directory

**Data Enrichment & Compliance**
- Match companies to registration codes and VAT numbers for KYB workflows
- Fill gaps in an existing CRM with phone, website, and address data
- Standardise messy company records against a single directory source
- Feed structured Vietnamese business data into analytics dashboards

**Local SEO & Directory Aggregation**
- Audit how businesses in a niche present their category, hours, and contact details
- Aggregate opening hours and product lists for local listings
- Benchmark a client's directory profile against competitors in the same city

### Getting Started

#### Browse a Category

The simplest run — one category, 50 businesses:

```json
{
    "categories": ["restaurants"],
    "maxResults": 50
}
````

#### Category × City

Narrow to specific categories within a city — each category is combined with each city:

```json
{
    "categories": ["restaurants", "lawyers"],
    "locations": ["hanoi"],
    "maxResults": 200
}
```

#### Keyword Search

Search the whole directory for a business type that has no dedicated category page:

```json
{
    "searchKeywords": ["seafood export"],
    "includeDetails": true,
    "maxResults": 100
}
```

#### Paste URLs (Advanced)

Paste category, city, or individual company profile URLs straight from your browser:

```json
{
    "startUrls": [
        "https://www.vietnamyello.com/category/estate-agents",
        "https://www.vietnamyello.com/location/danang",
        "https://www.vietnamyello.com/company/367879/"
    ],
    "includeDetails": true,
    "maxResults": 500
}
```

### Input Reference

#### What to Scrape

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `categories` | string\[] | `["restaurants"]` | Business categories, using the slug from a VietnamYello category page (e.g. `restaurants`, `lawyers`, `estate-agents`, `doctors-and-clinics`). Each category is combined with every city below. Leave empty to browse cities only. |
| `locations` | string\[] | `[]` | Vietnamese cities or provinces, using the slug from a location page (e.g. `hanoi`, `ho-chi-minh-city`, `danang`, `haiphong`, `thanh-hoa`). Each city is combined with every category above. Leave empty to cover all of Vietnam. |
| `searchKeywords` | string\[] | `[]` | Free-text terms searched across the whole directory (e.g. `seafood export`, `software company`, `coffee`). Use when a business type has no dedicated category page. Not narrowed by the cities above. |

#### Or Paste URLs

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `startUrls` | string\[] | `[]` | Paste VietnamYello category, city, search, or individual company profile links directly. When provided, the Categories, Cities, and Search Keywords above are ignored. |

#### Options

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDetails` | boolean | `true` | Open each company profile to add the full record — website, fax, opening hours, description, year established, employee count, registration code, VAT number, products, and review summary. Turn off for a faster, lighter run that returns just the core listing fields. |
| `maxResults` | integer | `100` | Total number of businesses to collect across all categories, cities, keywords, and URLs. Set to `0` for as much as possible. A safety ceiling of 50,000 applies to every run. |

### Output

Each result is one flat row per company. Here is a representative row with full details enabled:

```json
{
    "companyName": "Mandarine Restaurant",
    "companyUrl": "https://www.vietnamyello.com/company/367879/mandarine-restaurant",
    "companyId": "367879",
    "phone": "+84 24 3823 9314",
    "fax": "+84 24 3823 9315",
    "website": "https://www.mandarine-restaurant.com",
    "streetAddress": "24 Phan Boi Chau Street, Hoan Kiem District",
    "city": "Hanoi",
    "country": "VN",
    "latitude": 21.024398,
    "longitude": 105.843242,
    "categories": ["Restaurants", "Vietnamese Cuisine"],
    "description": "Fine Vietnamese dining in the heart of Hanoi's Old Quarter...",
    "openingHours": ["Mon-Sun: 11:00 - 22:00"],
    "yearEstablished": "2000",
    "employeeCount": "51-100",
    "registrationCode": "0101234567",
    "vatNumber": "0101234567",
    "contactPerson": "Nguyen Van A",
    "verified": true,
    "listingType": "+14 Years With Us",
    "products": ["Set Menus", "Private Dining"],
    "reviewCount": 3,
    "reviewRating": 4.5,
    "logo": "https://www.vietnamyello.com/uploads/367879-logo.jpg",
    "searchType": "category",
    "searchTerm": "restaurants",
    "searchCity": "hanoi",
    "scrapedAt": "2026-07-16T14:30:00Z"
}
```

#### Core Business Fields

| Field | Type | Description |
|-------|------|-------------|
| `companyName` | string | Business name |
| `companyUrl` | string | VietnamYello profile URL |
| `companyId` | string | Numeric profile identifier |
| `phone` | string | Primary phone number |
| `fax` | string | Fax number (detail) |
| `website` | string | Resolved external company website (detail) |
| `categories` | string\[] | Business categories and tags |
| `description` | string | Business description (detail) |
| `logo` | string | Logo / primary image URL |
| `scrapedAt` | string | ISO timestamp of extraction |

#### Address & Location

| Field | Type | Description |
|-------|------|-------------|
| `streetAddress` | string | Street address |
| `city` | string | City or locality |
| `country` | string | Country code (VN) |
| `latitude` | number | GPS latitude |
| `longitude` | number | GPS longitude |

#### Company Profile

Populated when `includeDetails` is on.

| Field | Type | Description |
|-------|------|-------------|
| `yearEstablished` | string | Year the business was founded |
| `employeeCount` | string | Employee band, e.g. "51-100" |
| `registrationCode` | string | Company registration code |
| `vatNumber` | string | VAT / tax registration number |
| `contactPerson` | string | Named contact, when listed |
| `openingHours` | string\[] | Opening-hours lines |
| `products` | string\[] | Products and services listed on the profile |

#### Reviews, Status & Provenance

| Field | Type | Description |
|-------|------|-------------|
| `reviewCount` | number | Number of reviews on the profile |
| `reviewRating` | number | Average star rating |
| `verified` | boolean | Verified-listing flag |
| `listingType` | string | Listing tier / platform tenure, e.g. "+14 Years With Us" |
| `searchType` | string | How this row was found: `category`, `location`, `keyword`, or `url` |
| `searchTerm` | string | The category or keyword that produced this row |
| `searchCity` | string | The city slug that produced this row, when applicable |

### Tips for Best Results

- **Start small.** Set `maxResults` to 25-50 on your first run to confirm the data matches your needs, then scale up.
- **Combine a category with a city to narrow, leave one blank to widen.** Pairing `categories` and `locations` targets one exact segment (restaurants in Hanoi); an empty `locations` sweeps the whole category across Vietnam, and an empty `categories` grabs every business in a city.
- **Copy slugs from the address bar.** The category slug is the part after `/category/` and the city slug is the part after `/location/` in any VietnamYello URL — always lowercase and hyphenated (e.g. `ho-chi-minh-city`).
- **Use keyword search for niche business types.** When a trade has no dedicated category page, `searchKeywords` searches the entire directory across all of Vietnam.
- **Toggle details for speed vs. depth.** Turn `includeDetails` off for a fast listing-only sweep of names, phones, GPS, and categories; turn it on when you need website, registration code, VAT number, employees, and hours.
- **Filter to established businesses.** The `verified` flag and `listingType` tenure ("+N Years With Us") are the best signals for prioritising long-standing companies before you spend a run enriching profiles.
- **Treat reviews as a bonus.** Review density on this directory is low, so use `reviewCount` and `reviewRating` as a supporting signal rather than a primary filter.

### Pricing

**From $0.40 per 1,000 results** — a single flat rate that includes full company detail and keyword search at no premium. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.

| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.048 | $0.045 | $0.043 | $0.040 |
| 1,000 | $0.48 | $0.45 | $0.43 | $0.40 |
| 10,000 | $4.80 | $4.50 | $4.30 | $4.00 |
| 100,000 | $48.00 | $45.00 | $43.00 | $40.00 |

A "result" is any company row in the output dataset. There are no compute or time-based charges — you pay per result, plus a small fixed per-run start fee.

### Integrations

Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:

- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom APIs on run completion
- **Apify API** — Full programmatic access

### Legal & Ethical Use

This actor is designed for legitimate business research, market analysis, and lead generation. Users are responsible for complying with applicable laws and VietnamYello's Terms of Service. Do not use extracted data for spam, harassment, or any unlawful purpose, and handle any personal contact details in line with applicable data-protection regulations.

# Actor input Schema

## `categories` (type: `array`):

Business categories to collect, taken from a VietnamYello category page URL (e.g. 'restaurants', 'lawyers', 'estate-agents', 'doctors-and-clinics', 'construction-services'). Use the slug that appears after /category/ in the address bar. Each category is combined with every city below, so you can cover many categories in one run. Leave empty to browse cities only.

## `locations` (type: `array`):

Vietnamese cities or provinces to browse, using the slug from a VietnamYello location page (e.g. 'hanoi', 'ho-chi-minh-city', 'danang', 'haiphong', 'bien-hoa', 'dong-nai', 'thanh-hoa'). Each city is combined with every category above. Leave empty to search across all of Vietnam.

## `searchKeywords` (type: `array`):

Free-text terms to search across the whole directory (e.g. 'seafood export', 'software company', 'coffee'). Use this when a business type has no dedicated category page. Keyword searches cover all of Vietnam and are not narrowed by the cities above.

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

Paste VietnamYello links directly from your browser — category pages (e.g. https://www.vietnamyello.com/category/restaurants), city pages (e.g. https://www.vietnamyello.com/location/hanoi), search result pages, or individual company profiles (e.g. https://www.vietnamyello.com/company/367879/...). When provided, the Categories, Cities, and Search Keywords above are ignored.

## `includeDetails` (type: `boolean`):

When enabled, the actor opens each company profile to add the complete record — website, fax, full opening hours, business description, year established, employee count, registration code, VAT number, products, and review summary. Turn this off for a faster, lighter run that returns just the core fields visible on the results list (name, profile URL, phone, GPS coordinates, categories, and partial address).

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

Hard cap on the total number of business listings collected across all categories, cities, keywords, and URLs. Default 100 — increase for bigger runs. A built-in safety ceiling of 50,000 results applies to every run: any higher value (including 0, which means 'collect as much as possible') is capped at 50,000. Each listing is billed at the per-result rate.

## Actor input object example

```json
{
  "categories": [
    "restaurants"
  ],
  "locations": [],
  "searchKeywords": [],
  "startUrls": [],
  "includeDetails": true,
  "maxResults": 100
}
```

# Actor output Schema

## `overview` (type: `string`):

Compact table of scraped businesses — company name, categories, phone, city, website, and profile link.

## `details` (type: `string`):

Full per-business rows including website, componentized address, GPS coordinates, opening hours, year established, employee count, registration and VAT numbers, review summary, and products (populated when 'Include full business details' is on).

# 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 = {
    "categories": [
        "restaurants"
    ],
    "locations": [],
    "searchKeywords": [],
    "startUrls": [],
    "includeDetails": true,
    "maxResults": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/vietnamyello-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 = {
    "categories": ["restaurants"],
    "locations": [],
    "searchKeywords": [],
    "startUrls": [],
    "includeDetails": True,
    "maxResults": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("solidcode/vietnamyello-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 '{
  "categories": [
    "restaurants"
  ],
  "locations": [],
  "searchKeywords": [],
  "startUrls": [],
  "includeDetails": true,
  "maxResults": 100
}' |
apify call solidcode/vietnamyello-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "VietnamYello Business Directory Scraper",
        "description": "[💰 $0.4 / 1K] Extract Vietnam business listings from VietnamYello — company name, phone, website, full address, GPS coordinates, categories, opening hours, registration & VAT numbers, and employee count. Browse by category and city, or search by keyword. Clean data for lead generation.",
        "version": "1.0",
        "x-build-id": "goJ8SMjXKcIcefPAv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/solidcode~vietnamyello-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-solidcode-vietnamyello-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/solidcode~vietnamyello-scraper/runs": {
            "post": {
                "operationId": "runs-sync-solidcode-vietnamyello-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/solidcode~vietnamyello-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-solidcode-vietnamyello-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": {
                    "categories": {
                        "title": "Categories",
                        "type": "array",
                        "description": "Business categories to collect, taken from a VietnamYello category page URL (e.g. 'restaurants', 'lawyers', 'estate-agents', 'doctors-and-clinics', 'construction-services'). Use the slug that appears after /category/ in the address bar. Each category is combined with every city below, so you can cover many categories in one run. Leave empty to browse cities only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Cities",
                        "type": "array",
                        "description": "Vietnamese cities or provinces to browse, using the slug from a VietnamYello location page (e.g. 'hanoi', 'ho-chi-minh-city', 'danang', 'haiphong', 'bien-hoa', 'dong-nai', 'thanh-hoa'). Each city is combined with every category above. Leave empty to search across all of Vietnam.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchKeywords": {
                        "title": "Search Keywords",
                        "type": "array",
                        "description": "Free-text terms to search across the whole directory (e.g. 'seafood export', 'software company', 'coffee'). Use this when a business type has no dedicated category page. Keyword searches cover all of Vietnam and are not narrowed by the cities above.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "startUrls": {
                        "title": "VietnamYello URLs",
                        "type": "array",
                        "description": "Paste VietnamYello links directly from your browser — category pages (e.g. https://www.vietnamyello.com/category/restaurants), city pages (e.g. https://www.vietnamyello.com/location/hanoi), search result pages, or individual company profiles (e.g. https://www.vietnamyello.com/company/367879/...). When provided, the Categories, Cities, and Search Keywords above are ignored.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeDetails": {
                        "title": "Include full business details",
                        "type": "boolean",
                        "description": "When enabled, the actor opens each company profile to add the complete record — website, fax, full opening hours, business description, year established, employee count, registration code, VAT number, products, and review summary. Turn this off for a faster, lighter run that returns just the core fields visible on the results list (name, profile URL, phone, GPS coordinates, categories, and partial address).",
                        "default": true
                    },
                    "maxResults": {
                        "title": "Maximum Results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Hard cap on the total number of business listings collected across all categories, cities, keywords, and URLs. Default 100 — increase for bigger runs. A built-in safety ceiling of 50,000 results applies to every run: any higher value (including 0, which means 'collect as much as possible') is capped at 50,000. Each listing is billed at the per-result rate.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
