# Yellow Pages PK Scraper - Pakistan Business Directory (`crawlerbros/yellow-pages-pk-scraper`) Actor

Scrape YellowPagesPK.com, Pakistan's business listing directory. Browse by business category, search by keyword or city, or fetch full business profiles by URL. Get names, addresses, phone numbers, emails, websites, categories, and more.

- **URL**: https://apify.com/crawlerbros/yellow-pages-pk-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Automation, Other
- **Stats:** 3 total users, 2 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 PK Scraper - Pakistan Business Directory

Scrape **YellowPagesPK.com** — a Pakistan business listing directory. Browse any of the site's 46 business categories, run a free-text keyword search (business name, service, or city), or fetch full business profiles from direct listing URLs. Get names, addresses, cities, phone numbers, emails, websites, categories, and more. No login, no cookies, no API key required.

### What this actor does

- **Three modes:** `byCategory` (browse a category, with real pagination), `search` (free-text keyword search across the whole directory, with real pagination), and `byUrls` (fetch specific listing pages directly)
- **46 categories** covering restaurants, hotels, automotive, real estate, law firms, medical, education, construction, and more — the full, current category list published on the site
- **Optional city filter** — narrow any mode to businesses whose address mentions a given Pakistani city (e.g. `"Lahore"`, `"Karachi"`, `"Islamabad"`)
- **Full business profiles** — description, category, claimed status, owner/author profile, email, phone, website, logo (toggle `fetchDetails`)
- **Empty fields are omitted** — you only ever see fields that were actually found for a business

### Output per business

- `name` — business name
- `description` — business description (when profile fetched)
- `category`, `categorySlug` — the listing's own category, taken from its breadcrumb (when profile fetched)
- `searchCategory` — the category you searched (mode=byCategory)
- `searchQuery` — the keyword you searched (mode=search)
- `address` — full street address as published
- `city` — best-effort city extracted from the listing's own city tag (mode=byCategory) or from the address text
- `phone`, `email`, `website`
- `latitude`, `longitude` — GPS coordinates (only present for the small number of listings that publish them)
- `rating` — star rating out of 5 (only present for listings that have received at least one review — most have none)
- `reviewCount` — number of reviews behind the rating (mode=byCategory; only present when `rating` is present)
- `openStatus` — live open/closed/day-off badge text, when the listing publishes hours (mode=byCategory)
- `claimed` — `true` if the business owner has claimed and verified the listing
- `sponsored` — `true` if the listing is marked "Ad" (a paid/promoted placement) on its category page (mode=byCategory)
- `imageUrl` — listing photo (mode=byCategory; omitted when the listing has no real photo, or the photo file is no longer reachable on the source site -- see Limitations)
- `logoUrl` — business logo (when profile fetched; omitted when the listing has no real logo, or the logo file is no longer reachable on the source site -- see Limitations)
- `authorName`, `authorProfileUrl` — the directory account that submitted the listing (when profile fetched)
- `sourceUrl` — canonical YellowPagesPK.com listing URL
- `recordType: "business"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string (select) | `byCategory` | `byCategory`, `search`, or `byUrls` |
| `category` | string (select) | `restaurant` | One of the 46 published categories (mode=byCategory) |
| `cityFilter` | string | – | Only keep businesses whose address/city mentions this text, e.g. `"Lahore"` (mode=byCategory, mode=search) |
| `searchQuery` | string | `Lahore` | Free-text keyword to search, e.g. `"restaurant lahore"` (mode=search) |
| `listingUrls` | array | – | Direct YellowPagesPK.com listing URLs to fetch (mode=byUrls) |
| `minRating` | integer (select) | `0` | Only include businesses rated at least this many stars (0-5). Businesses with no published rating are excluded once set above 0 |
| `onlyClaimed` | boolean | `false` | Only include businesses whose listing has been claimed/verified by its owner |
| `fetchDetails` | boolean | `true` | Also visit each listing's page for description, email, website, category, claimed status, and owner profile |
| `maxItems` | integer | `30` | Hard cap on returned records (1-500) |

#### Example: browse restaurants

```json
{
  "mode": "byCategory",
  "category": "restaurant",
  "maxItems": 30
}
````

#### Example: hotels in Lahore only

```json
{
  "mode": "byCategory",
  "category": "hotels",
  "cityFilter": "Lahore",
  "maxItems": 30
}
```

#### Example: keyword search across the directory

```json
{
  "mode": "search",
  "searchQuery": "digital marketing lahore",
  "maxItems": 40
}
```

#### Example: fetch specific business profiles

```json
{
  "mode": "byUrls",
  "listingUrls": [
    { "url": "https://yellowpagespk.com/listing/andaaz-restaurant/" }
  ]
}
```

#### Example: only claimed/verified listings

```json
{
  "mode": "byCategory",
  "category": "law-firms",
  "onlyClaimed": true,
  "maxItems": 30
}
```

### Use cases

- **Local lead generation** — build a prospect list of Pakistani businesses by category and city for B2B outreach
- **Directory aggregation** — feed structured Pakistani business data into your own local-search product
- **Market research** — see how many listed businesses exist in a category and which cities they cluster in
- **Competitor mapping** — see who else is listed in a category with contact and website details

### Limitations

- **`mode=byCategory` paginates for real.** YellowPagesPK.com's category pages (`/listing-category/<slug>/`, `/listing-category/<slug>/page/N/`) are genuinely paginated via standard WordPress `/page/N/` URLs (confirmed live: page 1 and page 2 return distinct, non-overlapping business listings). The actor walks pages until it hits `maxItems`, runs out of new listings, or reaches an internal page cap.
- **`mode=search` also paginates for real** and can return substantially more results than `mode=byCategory` for a broad keyword, since it uses the site's native WordPress search (`/?s=...`, `/page/N/?s=...`), which is genuinely paginated.
- **Ratings and reviews are rare.** Most listings on this directory have never received a review, so `rating` is only present on the small minority that have. This is a fact about the underlying data, not a bug — the actor never fabricates a rating.
- **Many older listing photos are broken on the source site itself.** YellowPagesPK.com's HTML still references photo/logo files uploaded before roughly November 2024 that have since been removed from its media server (verified: the site's own listing pages link to these paths, but the files themselves return 404). The actor live-checks every `imageUrl`/`logoUrl` before including it and omits the field rather than shipping a broken link, so a lower `imageUrl`/`logoUrl` coverage rate reflects an upstream data-integrity gap, not a scraper defect.
- **GPS coordinates are rare.** Only a small number of listings have `latitude`/`longitude` set on the site itself; most do not, and the field is simply omitted.
- **`city` is best-effort.** `mode=byCategory` uses the listing's own city tag when the site provides one; otherwise (and always in `mode=search`/`mode=byUrls`), the actor matches the address text against a curated list of ~70 major Pakistani cities/towns. Addresses that don't mention a recognized city will have no `city` field.
- **`cityFilter` only excludes businesses with a known, non-matching city.** Businesses that have no address/city data at all on the site are passed through rather than excluded (the filter can't verify what isn't there), the same way `minRating`-style filters behave on other directory actors in this catalog.
- **Directory data quality is the site's own.** YellowPagesPK.com occasionally contains a small number of off-topic or foreign listings inside a Pakistani category (a fact of the source data, reproduced as-is rather than filtered out, since the actor does not assume what "off-topic" means for every use case).

### FAQ

**What data source does this actor use?**
It reads the publicly available category, search, and listing pages on YellowPagesPK.com, a Pakistan business directory. No account or API key is needed.

**Is this affiliated with YellowPagesPK.com?**
No. This is an independent, third-party actor that reads publicly accessible pages.

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

**Why is `fetchDetails` on by default?**
Category and search listing pages alone only carry a subset of fields (name, address, phone, sometimes a photo). Turning on `fetchDetails` (the default) visits each listing's own page for the full picture — description, category, email, website, claimed status, and owner profile — at the cost of one extra request per result.

**Can I search by both category and city at once?**
Yes — set `category` and `cityFilter` together in `mode=byCategory` to browse a category limited to a specific city.

**Does this actor need a proxy or login?**
No — YellowPagesPK.com's category, search, and listing pages are served without any anti-bot challenge beyond standard browser headers, so this actor runs entirely on Apify's free plan with no proxy and no credentials required. The actor will automatically fall back to Apify's free AUTO proxy group only if it ever gets rate-limited.

# Actor input Schema

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

What to fetch: browse a business category, run a free-text keyword search across the whole directory, or fetch full business profiles from direct YellowPagesPK.com listing URLs.

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

Business category to browse. This is the full, current list of categories published on YellowPagesPK.com (mode=byCategory).

## `cityFilter` (type: `string`):

Only keep businesses whose address mentions this city, e.g. 'Lahore', 'Karachi', 'Islamabad'. Matched case-insensitively against the business address. Leave empty for no city filter (used in mode=byCategory and mode=search).

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

Free-text keyword to search for across YellowPagesPK.com, e.g. a business name, service, or city (mode=search). Matches the site's own search, so combining a service with a city (e.g. 'restaurant lahore') narrows results well.

## `listingUrls` (type: `array`):

Direct YellowPagesPK.com listing URLs to fetch, e.g. https://yellowpagespk.com/listing/andaaz-restaurant/. Use the 'sourceUrl' field from byCategory/search results.

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

Only include businesses with an average customer rating at or above this value (0-5 stars). 0 = no filter. Businesses with no published rating are excluded once this is set above 0. Ratings are only available on the listing/search card, not looked up separately.

## `onlyClaimed` (type: `boolean`):

Only include businesses whose listing has been claimed and verified by its owner on YellowPagesPK.com. Off by default (returns both claimed and unclaimed listings).

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

For each result, also visit its listing page to collect description, email, website, category, claimed status, and owner profile (one extra request per result). When off, only the fields visible on the listing/search page are returned (mode=byCategory, mode=search).

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

Hard cap on the number of business records to return.

## Actor input object example

```json
{
  "mode": "byCategory",
  "category": "restaurant",
  "searchQuery": "Lahore",
  "listingUrls": [],
  "minRating": 0,
  "onlyClaimed": false,
  "fetchDetails": true,
  "maxItems": 30
}
```

# Actor output Schema

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

Dataset containing all scraped YellowPagesPK.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": "restaurant",
    "searchQuery": "Lahore",
    "listingUrls": [],
    "minRating": 0,
    "onlyClaimed": false,
    "fetchDetails": true,
    "maxItems": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/yellow-pages-pk-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": "restaurant",
    "searchQuery": "Lahore",
    "listingUrls": [],
    "minRating": 0,
    "onlyClaimed": False,
    "fetchDetails": True,
    "maxItems": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/yellow-pages-pk-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": "restaurant",
  "searchQuery": "Lahore",
  "listingUrls": [],
  "minRating": 0,
  "onlyClaimed": false,
  "fetchDetails": true,
  "maxItems": 30
}' |
apify call crawlerbros/yellow-pages-pk-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Yellow Pages PK Scraper - Pakistan Business Directory",
        "description": "Scrape YellowPagesPK.com, Pakistan's business listing directory. Browse by business category, search by keyword or city, or fetch full business profiles by URL. Get names, addresses, phone numbers, emails, websites, categories, and more.",
        "version": "1.0",
        "x-build-id": "qNG2BmfrtQ9jFyDEd"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~yellow-pages-pk-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-yellow-pages-pk-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-pk-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-yellow-pages-pk-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-pk-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-yellow-pages-pk-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",
                            "byUrls"
                        ],
                        "type": "string",
                        "description": "What to fetch: browse a business category, run a free-text keyword search across the whole directory, or fetch full business profiles from direct YellowPagesPK.com listing URLs.",
                        "default": "byCategory"
                    },
                    "category": {
                        "title": "Business category (mode=byCategory)",
                        "enum": [
                            "account-tax-consultant",
                            "arts-entertainment",
                            "automotive",
                            "beauty-salon",
                            "beauty-spa",
                            "best-event-management",
                            "charity-donation",
                            "computer-and-mobiles",
                            "construction",
                            "constructions-repairing",
                            "courier-service",
                            "customs-broker-clearance-agent",
                            "digital-media",
                            "education-institute",
                            "electronics-and-electrical-equipment",
                            "fashion-styles",
                            "furniture",
                            "general-order-supplier",
                            "goods-transportation",
                            "health-medical",
                            "home-furniture",
                            "home-garden",
                            "hotels",
                            "insurance",
                            "job-recruitment-agency",
                            "law-firms",
                            "legal-advisor",
                            "legal-service",
                            "loan-and-mortgage",
                            "manufacturer",
                            "movers-packers",
                            "property-real-estate-agent",
                            "real-estate",
                            "rent-a-car",
                            "restaurant",
                            "security-service",
                            "services",
                            "shopping",
                            "software-houses",
                            "specialist-medical-doctors",
                            "study-abroad",
                            "study-abroad-consultants",
                            "travel-agencies",
                            "vehicle-denter-painter",
                            "web-development",
                            "welder"
                        ],
                        "type": "string",
                        "description": "Business category to browse. This is the full, current list of categories published on YellowPagesPK.com (mode=byCategory).",
                        "default": "restaurant"
                    },
                    "cityFilter": {
                        "title": "City filter (optional)",
                        "type": "string",
                        "description": "Only keep businesses whose address mentions this city, e.g. 'Lahore', 'Karachi', 'Islamabad'. Matched case-insensitively against the business address. Leave empty for no city filter (used in mode=byCategory and mode=search)."
                    },
                    "searchQuery": {
                        "title": "Search query (mode=search)",
                        "type": "string",
                        "description": "Free-text keyword to search for across YellowPagesPK.com, e.g. a business name, service, or city (mode=search). Matches the site's own search, so combining a service with a city (e.g. 'restaurant lahore') narrows results well."
                    },
                    "listingUrls": {
                        "title": "Business listing URLs (mode=byUrls)",
                        "type": "array",
                        "description": "Direct YellowPagesPK.com listing URLs to fetch, e.g. https://yellowpagespk.com/listing/andaaz-restaurant/. Use the 'sourceUrl' field from byCategory/search results.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "URL",
                                    "type": "string",
                                    "description": "YellowPagesPK.com listing URL."
                                }
                            }
                        },
                        "default": []
                    },
                    "minRating": {
                        "title": "Minimum rating",
                        "minimum": 0,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Only include businesses with an average customer rating at or above this value (0-5 stars). 0 = no filter. Businesses with no published rating are excluded once this is set above 0. Ratings are only available on the listing/search card, not looked up separately.",
                        "default": 0
                    },
                    "onlyClaimed": {
                        "title": "Only claimed/verified businesses",
                        "type": "boolean",
                        "description": "Only include businesses whose listing has been claimed and verified by its owner on YellowPagesPK.com. Off by default (returns both claimed and unclaimed listings).",
                        "default": false
                    },
                    "fetchDetails": {
                        "title": "Fetch full business profiles",
                        "type": "boolean",
                        "description": "For each result, also visit its listing page to collect description, email, website, category, claimed status, and owner profile (one extra request per result). When off, only the fields visible on the listing/search page are returned (mode=byCategory, mode=search).",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Hard cap on the number of business records to return.",
                        "default": 30
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
