# Yellow Pages Kenya Scraper - Kenya Business Directory (`crawlerbros/yellow-pages-kenya-scraper`) Actor

Scrape Yellow Pages Kenya (yellowpageskenya.com), Kenya's business directory. Browse by category, run a free-text search, or fetch full business profiles by URL. Get names, addresses, phone numbers, categories, regions, coordinates, and websites.

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

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

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

## Yellow Pages Kenya Scraper - Kenya Business Directory

Scrape **Yellow Pages Kenya** (yellowpageskenya.com) — Kenya's business directory. Browse any of 120 curated business categories, run a free-text search across the whole site, or fetch full business profiles by URL. Get names, addresses, phone numbers, categories, regions, GPS coordinates, and websites. No login, no cookies, no API key required.

### What this actor does

- **Three modes:** `byCategory` (curated category dropdown), `search` (free-text keyword search), and `detail` (direct business profile URLs)
- **120 curated categories** verified to return real results, or type any custom category slug
- **All 47 Kenyan counties** available as a client-side region filter (Nairobi, Mombasa, Kisumu, Nakuru, and every other county)
- **Sort by** relevance, rating, or name (A-Z)
- **Filter by** county/region or minimum star rating (1-5)
- **Rich business profiles** — description, opening hours, payment methods accepted, precise address, and GPS coordinates
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `category` — business category
- `region`, `locality` — Kenyan county/region and specific area
- `address` — full street address
- `latitude`, `longitude` — GPS coordinates (when available)
- `phone`, `mobilePhone`, `fax` — landline, mobile, and fax contact numbers (when published)
- `branchName` — specific branch/outlet name for multi-location businesses (when published)
- `email`, `website` — contact email and website (when published)
- `logoUrl` — business logo image
- `rating`, `ratingCount` — average star rating (1-5) and number of ratings (only present once a business has at least one)
- `listingPackage` — the business's paid directory package tier as published by yellowpageskenya.com, e.g. `"Gold"`, `"Silver"`, `"Bronze"`, `"Basic"` (only present for businesses on a paid package)
- `description` — company description (when profile fetched)
- `openingHours` — business hours as published (when profile fetched)
- `paymentMethods[]` — accepted payment methods, e.g. `["CASH", "MPESA"]` (when profile fetched)
- `street`, `country` — structured address parts (when profile fetched)
- `searchCategory` / `searchQuery`, `searchRegion` — the search parameters used
- `sourceUrl` — canonical yellowpageskenya.com profile URL for the business
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `byCategory` | `byCategory`, `search`, or `detail` (fetch by URL) |
| `category` | string (select) | `restaurants` | Pick a curated category, or `custom` to use `customCategory` (mode=byCategory) |
| `customCategory` | string | – | Free-text category, overrides `category` (mode=byCategory) — works best for simple, single-word category names |
| `searchQuery` | string | `restaurants` | Free-text keyword search across business names and categories (mode=search) |
| `region` | string (select) | – | Kenyan county to filter to, applied client-side |
| `sortBy` | string (select) | `relevance` | `relevance` / `rating` (highest first) / `name` (A-Z) — applied client-side across the fetched batch |
| `minRating` | integer | `0` (no minimum) | Only return businesses rated at least 1-5 stars |
| `fetchDetails` | boolean | `false` | Also visit each business's profile page for description, opening hours, payment methods, and precise address (slower) |
| `businessUrls` | array | – | yellowpageskenya.com business-details URLs to fetch directly (mode=detail) |
| `maxItems` | int | `20` | Hard cap on returned records (1-500) |

#### Example: browse supermarkets

```json
{
  "mode": "byCategory",
  "category": "supermarkets",
  "maxItems": 20
}
````

#### Example: highest-rated hotels in Nairobi, with full profiles

```json
{
  "mode": "byCategory",
  "category": "hotels",
  "region": "Nairobi",
  "sortBy": "rating",
  "fetchDetails": true,
  "maxItems": 30
}
```

#### Example: free-text search

```json
{
  "mode": "search",
  "searchQuery": "hardware Nakuru",
  "maxItems": 50
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "detail",
  "businessUrls": [
    { "url": "https://www.yellowpageskenya.com/business-category/supermarkets/business-details/2852097-eastmatt-ltd" }
  ]
}
```

### Use cases

- **Local lead generation** — build a prospect list of Kenyan businesses by category and county for B2B outreach
- **Market research** — measure business density for a category across Kenyan regions
- **Directory aggregation** — feed structured Kenyan business data into your own local-search product
- **Competitor mapping** — see who else operates in a category and county, with contact info
- **Franchise & site-selection analysis** — evaluate business coverage across Kenya's 47 counties

### Limitations

- **Category browsing only covers 120 curated categories.** yellowpageskenya.com's own category list has 1600+ entries, but most contain `&` or commas whose exact internal URL slug can't be reliably derived from the display name (verified via testing: the site's category API requires an exact slug match and returns zero results, not an error, on a mismatch). The 120 categories offered here were individually verified to return real businesses. For anything outside this list, use `search` mode instead — free-text search does not require an exact slug and matches business names and categories site-wide.
- **`search` and `byCategory` results are capped at roughly 300 records per query.** This is the underlying site's own limit, not a bug in this actor — both the search-results page and the category API consistently return a maximum of ~300 businesses regardless of the requested `maxItems`. For larger volumes, split into multiple category- or region-scoped runs.
- **`region` filtering is applied client-side.** yellowpageskenya.com does not expose a server-side location filter on category or search pages, so this actor fetches the full category/search result set and filters by the business's own `region`/`locality` fields afterward.
- **`sortBy`, and `minRating` are applied client-side** across the batch of records this run actually fetched, not the entire category.
- **GPS coordinates of `(0, 0)`** (the site's own placeholder for un-geocoded businesses) are treated as missing and omitted rather than shown as a real location.

### FAQ

**What data source does this actor use?**
It reads yellowpageskenya.com's own public JSON API for category browsing, and its server-rendered search and business-details pages (data extracted directly from the page's initial HTML response — no browser rendering is used). No account or API key is needed.

**Is this affiliated with Yellow Pages Kenya?**
No. This is an independent, third-party actor that reads publicly accessible data.

**Why do some businesses have no rating, email, or website?**
yellowpageskenya.com only shows contact/website details a business itself provided, and a star rating only once a business has received one. Fields with no data are simply omitted from the record rather than shown as empty or null.

**Can I search a category that's not in the dropdown?**
Yes — use `search` mode with the category name as your `searchQuery`, e.g. `"searchQuery": "advertising marketing agencies"`. Free-text search works for any category, unlike `byCategory` mode which needs an exact internal slug match.

**Does this actor need a proxy or login?**
No — yellowpageskenya.com's category API and pages are served without any anti-bot challenge that blocks Apify's free datacenter proxy, so this actor runs entirely on Apify's free plan with no proxy and no credentials.

**Why is `fetchDetails` off by default?**
Fetching each business's full profile page requires one extra request per result, which is slower. Turn it on when you need description, opening hours, payment methods, or precise structured address.

# Actor input Schema

## `mode` (type: `string`):

What to fetch: browse a category, run a free-text search, or fetch business profiles from direct yellowpageskenya.com URLs.

## `category` (type: `string`):

Business category to browse. Pick a common category, or choose 'Custom category' and type your own below -- note only categories in this curated list are guaranteed to resolve via direct category browsing; for anything else use Search mode instead (mode=byCategory).

## `customCategory` (type: `string`):

Free-text category not in the curated list above (mode=byCategory). Takes priority over 'Category' when set. Only works for simple, single-word-style category names (e.g. 'plumbers'); for category names containing '&' or commas, use Search mode instead.

## `searchQuery` (type: `string`):

Free-text keyword to search for -- matches business names and categories site-wide (mode=search), e.g. 'restaurants', 'hardware', 'Nairobi hotels'.

## `region` (type: `string`):

Only return businesses in this Kenyan county/region (matched against the business's own region and locality fields). Applied client-side across the fetched batch.

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

How to order results after fetching. yellowpageskenya.com returns results in its own relevance/featured order, so 'rating' and 'name' are applied client-side across the fetched batch.

## `minRating` (type: `integer`):

Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Most listings have no rating yet; businesses with no rating are excluded once this is set above 0.

## `fetchDetails` (type: `boolean`):

For each result, also visit its business-details page to collect description, opening hours, payment methods accepted, and precise address. Slower -- one extra request per result.

## `businessUrls` (type: `array`):

Direct yellowpageskenya.com business-details URLs to fetch, e.g. https://www.yellowpageskenya.com/business-category/supermarkets/business-details/2852097-eastmatt-ltd. Use the 'sourceUrl' field from search/category results.

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "restaurants",
  "searchQuery": "restaurants",
  "region": "",
  "sortBy": "relevance",
  "minRating": 0,
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 20
}
```

# Actor output Schema

## `businesses` (type: `string`):

Dataset containing all scraped yellowpageskenya.com business listings.

# 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 = {
    "mode": "byCategory",
    "category": "restaurants",
    "searchQuery": "restaurants",
    "region": "",
    "sortBy": "relevance",
    "minRating": 0,
    "fetchDetails": false,
    "businessUrls": [],
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/yellow-pages-kenya-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 = {
    "mode": "byCategory",
    "category": "restaurants",
    "searchQuery": "restaurants",
    "region": "",
    "sortBy": "relevance",
    "minRating": 0,
    "fetchDetails": False,
    "businessUrls": [],
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/yellow-pages-kenya-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 '{
  "mode": "byCategory",
  "category": "restaurants",
  "searchQuery": "restaurants",
  "region": "",
  "sortBy": "relevance",
  "minRating": 0,
  "fetchDetails": false,
  "businessUrls": [],
  "maxItems": 20
}' |
apify call crawlerbros/yellow-pages-kenya-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yellow Pages Kenya Scraper - Kenya Business Directory",
        "description": "Scrape Yellow Pages Kenya (yellowpageskenya.com), Kenya's business directory. Browse by category, run a free-text search, or fetch full business profiles by URL. Get names, addresses, phone numbers, categories, regions, coordinates, and websites.",
        "version": "1.0",
        "x-build-id": "HCnwpBN86cLCPOCcq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~yellow-pages-kenya-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-yellow-pages-kenya-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/crawlerbros~yellow-pages-kenya-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-yellow-pages-kenya-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/crawlerbros~yellow-pages-kenya-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-yellow-pages-kenya-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": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "byCategory",
                            "search",
                            "detail"
                        ],
                        "type": "string",
                        "description": "What to fetch: browse a category, run a free-text search, or fetch business profiles from direct yellowpageskenya.com URLs.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "custom",
                            "hospitals",
                            "hotels",
                            "investments",
                            "official",
                            "business",
                            "transporters",
                            "boutiques",
                            "pharmacies",
                            "chemists-dispensing",
                            "printers",
                            "clinics",
                            "clothing-retail",
                            "colleges",
                            "restaurants",
                            "consultants",
                            "accountants",
                            "engineers",
                            "stationery",
                            "hardware-retail",
                            "auctioneers",
                            "bookshops",
                            "architects",
                            "co-operatives",
                            "supermarkets",
                            "photographers",
                            "communications",
                            "lodges",
                            "associations",
                            "garages",
                            "auditors",
                            "apartments",
                            "bars",
                            "supplies",
                            "resorts",
                            "opticians",
                            "chemicals",
                            "valuers",
                            "publishers",
                            "grocers",
                            "water",
                            "fabricators",
                            "entertainers",
                            "cafeterias",
                            "jewellers",
                            "manufacturers",
                            "butcheries",
                            "farms",
                            "caterers",
                            "clubs",
                            "branding",
                            "florists",
                            "tents",
                            "designers",
                            "uniforms",
                            "surveyors",
                            "accommodation",
                            "universities",
                            "banks",
                            "movers",
                            "parastatals",
                            "health-care",
                            "videography",
                            "taxicabs",
                            "floriculture",
                            "exporters",
                            "horticulture",
                            "hostels",
                            "safaris",
                            "signs",
                            "typesetting",
                            "herbalists",
                            "aluminium",
                            "tiles",
                            "kindergartens",
                            "landscaping",
                            "generators",
                            "cottages",
                            "importers",
                            "gymnasiums",
                            "meat",
                            "dry-cleaners",
                            "fruits",
                            "detergents",
                            "beddings",
                            "housewares-retail",
                            "machinery",
                            "investigators",
                            "alarms",
                            "polythene",
                            "curios",
                            "sports",
                            "pumps",
                            "foundations",
                            "batteries",
                            "motors",
                            "gems",
                            "poultry",
                            "handicrafts",
                            "fertilizers",
                            "warehouses",
                            "lubricants",
                            "cameras",
                            "physiotherapists",
                            "vegetables",
                            "mattresses",
                            "laundries",
                            "furnishings",
                            "spices",
                            "fabrics",
                            "casinos",
                            "inns",
                            "engineering",
                            "sawmills",
                            "renovators",
                            "e-commerce",
                            "adhesives",
                            "boilers",
                            "locksmiths",
                            "parks",
                            "cables"
                        ],
                        "type": "string",
                        "description": "Business category to browse. Pick a common category, or choose 'Custom category' and type your own below -- note only categories in this curated list are guaranteed to resolve via direct category browsing; for anything else use Search mode instead (mode=byCategory).",
                        "default": "restaurants"
                    },
                    "customCategory": {
                        "title": "Custom category (overrides selection above)",
                        "type": "string",
                        "description": "Free-text category not in the curated list above (mode=byCategory). Takes priority over 'Category' when set. Only works for simple, single-word-style category names (e.g. 'plumbers'); for category names containing '&' or commas, use Search mode instead."
                    },
                    "searchQuery": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text keyword to search for -- matches business names and categories site-wide (mode=search), e.g. 'restaurants', 'hardware', 'Nairobi hotels'.",
                        "default": "restaurants"
                    },
                    "region": {
                        "title": "County / region",
                        "enum": [
                            "",
                            "Mombasa",
                            "Kwale",
                            "Kilifi",
                            "Tana River",
                            "Lamu",
                            "Taita-Taveta",
                            "Garissa",
                            "Wajir",
                            "Mandera",
                            "Marsabit",
                            "Isiolo",
                            "Meru",
                            "Tharaka-Nithi",
                            "Embu",
                            "Kitui",
                            "Machakos",
                            "Makueni",
                            "Nyandarua",
                            "Nyeri",
                            "Kirinyaga",
                            "Murang'a",
                            "Kiambu",
                            "Turkana",
                            "West Pokot",
                            "Samburu",
                            "Trans Nzoia",
                            "Uasin Gishu",
                            "Elgeyo-Marakwet",
                            "Nandi",
                            "Baringo",
                            "Laikipia",
                            "Nakuru",
                            "Narok",
                            "Kajiado",
                            "Kericho",
                            "Bomet",
                            "Kakamega",
                            "Vihiga",
                            "Bungoma",
                            "Busia",
                            "Siaya",
                            "Kisumu",
                            "Homa Bay",
                            "Migori",
                            "Kisii",
                            "Nyamira",
                            "Nairobi"
                        ],
                        "type": "string",
                        "description": "Only return businesses in this Kenyan county/region (matched against the business's own region and locality fields). Applied client-side across the fetched batch.",
                        "default": ""
                    },
                    "sortBy": {
                        "title": "Sort order",
                        "enum": [
                            "relevance",
                            "rating",
                            "name"
                        ],
                        "type": "string",
                        "description": "How to order results after fetching. yellowpageskenya.com returns results in its own relevance/featured order, so 'rating' and 'name' are applied client-side across the fetched batch.",
                        "default": "relevance"
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only return businesses rated at least this many stars, e.g. 4 for 4.0+. 0 means no minimum. Most listings have no rating yet; businesses with no rating are excluded once this is set above 0.",
                        "default": 0
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each result, also visit its business-details page to collect description, opening hours, payment methods accepted, and precise address. Slower -- one extra request per result.",
                        "default": false
                    },
                    "businessUrls": {
                        "title": "Business profile URLs (mode=detail)",
                        "type": "array",
                        "description": "Direct yellowpageskenya.com business-details URLs to fetch, e.g. https://www.yellowpageskenya.com/business-category/supermarkets/business-details/2852097-eastmatt-ltd. Use the 'sourceUrl' field from search/category results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "yellowpageskenya.com business-details URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
