# YellowPages Canada Business Scraper (`automation-lab/yellowpages-canada-scraper`) Actor

Extract business listings from YellowPages.ca — Canada's largest business directory. Get phone numbers, addresses, star ratings, categories, and website URLs for any city and business type. Ideal for B2B lead generation and market research.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## YellowPages Canada Business Scraper

Extract business listings from YellowPages.ca — Canada's largest business directory. Get contact details, ratings, addresses, and categories for any city and business type without coding or API access.

### 📋 What does it do?

YellowPages Canada Business Scraper fetches search results from [yellowpages.ca](https://www.yellowpages.ca) and extracts structured business data. For any search query (e.g. "dentist", "roofing contractor") and Canadian location (e.g. "Toronto ON", "Calgary AB"), the actor returns:

- **Business name and direct YellowPages listing URL**
- **Phone number** (extracted directly from the page, no click required)
- **Full address** (street, city, province, postal code)
- **Star rating and review count**
- **Business description**
- **Categories** (e.g. Restaurants, Italian Restaurants)
- **Website URL**
- **Sponsored vs organic** indicator

Pagination is handled automatically — you set a result limit and the actor pages through results until it hits your target count.

### 👥 Who is it for?

**Sales and business development teams** who prospect Canadian leads by industry and geography — search "accountant" in "Vancouver BC" and get a phone-ready list in minutes.

**Marketing and advertising agencies** that need to audit their clients' local directory presence or benchmark competitors across Canadian cities.

**Recruiters and staffing firms** looking for companies hiring in specific sectors — scrape industry keywords by province to build employer contact lists.

**Data analysts and researchers** studying Canadian business density, service coverage, or local market composition by city and category.

**Real estate and franchise professionals** evaluating commercial opportunity by identifying concentrations or gaps in local business categories.

### 🏆 Why use this actor?

- **No API key or YellowPages account required** — runs against the public search interface
- **Phone numbers included** — extracted from `data-phone` attributes without simulating clicks
- **Schema.org structured data** — addresses parsed field-by-field (street, city, province, postal code) for clean CSV exports
- **Canadian-specific** — covers all 10 provinces and 3 territories; supports French and English search queries
- **Pagination handled automatically** — set your limit and let the actor collect results across multiple pages
- **Filter ads** — toggle to exclude sponsored listings and get only organic results
- **Cost-effective** — HTTP + Cheerio architecture (no browser), so runs are fast and cheap

### 📊 Data extraction table

| Field | Description | Example |
|-------|-------------|---------|
| `name` | Business name | `"La Bella Trattoria"` |
| `url` | YellowPages listing URL | `"https://www.yellowpages.ca/bus/..."` |
| `listingId` | YP internal listing ID | `"2088985"` |
| `phone` | Phone number | `"416-800-2993"` |
| `streetAddress` | Street address | `"1975A Queen St E"` |
| `city` | City | `"Toronto"` |
| `province` | Province abbreviation | `"ON"` |
| `postalCode` | Postal code | `"M4L 1J1"` |
| `fullAddress` | Full formatted address | `"1975A Queen St E, Toronto, ON M4L 1J1"` |
| `rating` | Star rating (1–5) | `4.5` |
| `reviewCount` | Number of YP reviews | `23` |
| `description` | Business description | `"Experience authentic Italian cuisine..."` |
| `categories` | Business categories | `["Restaurants", "Italian Restaurants"]` |
| `website` | Business website URL | `"https://labella.ca/"` |
| `isAd` | Whether listing is sponsored | `false` |
| `searchQuery` | Query used for this result | `"restaurant"` |
| `location` | Location used for this result | `"Toronto ON"` |

### 💰 How much does it cost to scrape YellowPages Canada businesses?

Each run charges two types of events:

| Event | Cost (BRONZE tier) |
|-------|-------------------|
| Run start | $0.009 per run |
| Per business extracted | $0.0025 per listing |

**Example costs:**
- 50 businesses: ~$0.135
- 200 businesses: ~$0.509
- 1,000 businesses: ~$2.509

Volume discounts apply automatically as your Apify usage grows. PLATINUM and DIAMOND tiers (high-volume users) pay as little as $0.001 per listing.

**Free plan:** Apify's free plan includes enough compute to scrape approximately 50–100 businesses at no cost.

### 🚀 How to use it

1. **Open the actor** on the Apify platform and click **Try for free**
2. **Enter your search query** — e.g. `plumber`, `dentist`, `restaurant`, `auto body shop`
3. **Enter the location** — Canadian city and province, e.g. `Vancouver BC`, `Calgary AB`, `Montreal QC`
4. **Set your result limit** — how many businesses you need (default: 50)
5. **Click Run** and wait for results (typically 5–30 seconds for 50 results)
6. **Download results** in CSV, JSON, Excel, or XML from the dataset tab

### ⚙️ Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `searchQuery` | string | required | Business type or keyword (e.g. "restaurant", "dentist") |
| `location` | string | required | City and province (e.g. "Toronto ON", "Vancouver BC") |
| `maxResults` | integer | 50 | Maximum number of listings to extract |
| `includeAds` | boolean | true | Include sponsored/ad listings in results |
| `maxRequestRetries` | integer | 3 | Retry attempts for failed requests |
| `proxyConfiguration` | object | none | Optional proxy settings for high-volume scraping |

**Location format:** Use the city name followed by the two-letter province code with a space — `"Toronto ON"`, `"Edmonton AB"`, `"Winnipeg MB"`. Accented characters work too: `"Montréal QC"` or `"Quebec QC"`.

### 📦 Output example

```json
{
  "name": "La Sala Restaurant",
  "url": "https://www.yellowpages.ca/bus/Ontario/Toronto/La-Sala-Restaurant/2088985.html",
  "listingId": "2088985",
  "phone": "416-800-2993",
  "streetAddress": "1975A Queen St E",
  "city": "Toronto",
  "province": "ON",
  "postalCode": "M4L 1J1",
  "fullAddress": "1975A Queen St E, Toronto, ON M4L 1J1",
  "rating": 5,
  "reviewCount": 1,
  "description": "Experience authentic Italian cuisine at La Sala Restaurant. Fresh ingredients, handcrafted dishes, and a warm atmosphere await.",
  "categories": ["Restaurants", "Italian Restaurants"],
  "website": "https://www.lasalaristorante.com/",
  "isAd": true,
  "searchQuery": "restaurant",
  "location": "Toronto ON"
}
````

### 💡 Tips for best results

**Use specific search queries for better data quality.** Searching "plumber" returns plumbing companies; searching "emergency plumber" may return fewer but more targeted results.

**Combine with automation.** Run the actor multiple times with different cities or business types using the Apify Scheduler to build a comprehensive national database.

**Filter ads for research use cases.** Set `includeAds: false` to exclude sponsored listings if you only want organic directory entries.

**Use exact province codes.** YellowPages.ca uses standard two-letter codes: ON, BC, AB, QC, MB, SK, NS, NB, NL, PE, YT, NT, NU.

**For French-language results in Quebec**, use French search terms like `"restaurant"` or `"plombier"` with `"Montreal QC"` or `"Quebec QC"`.

**Scraping large datasets.** For 500+ results, the actor paginates automatically. Set `maxResults` to your target and let it run — expect roughly 20–40 results per page depending on the search.

### 🔗 Integrations

**Google Sheets via Apify webhooks:** After each run, automatically push results to a Google Sheet using the [Google Sheets integration](https://apify.com/apify/google-sheets-import-export). Use for sales teams that need fresh lead lists without logging into Apify.

**CRM lead import (HubSpot / Salesforce):** Export results as CSV and import directly into your CRM. The `phone`, `fullAddress`, `name`, and `website` fields map cleanly to standard CRM contact fields.

**Make (Integromat) and Zapier:** Trigger the actor on a schedule and route results to any app — Airtable, Notion, Slack notifications, or email — using Apify's native Make and Zapier integrations.

**Airtable lead database:** Use Apify's [Airtable export](https://apify.com/lukaskrivka/airtable-import-export) actor to sync results into an Airtable base for your sales or research team.

**Python/Node.js data pipelines:** Pull results from the Apify dataset API and enrich them with additional sources (e.g. LinkedIn company data, Google Maps reviews) for more complete prospect profiles.

### 🤖 API usage

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('automation-lab/yellowpages-canada-scraper').call({
    searchQuery: 'dentist',
    location: 'Vancouver BC',
    maxResults: 100,
});

const dataset = await client.dataset(run.defaultDatasetId).listItems();
console.log(dataset.items);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_API_TOKEN')

run = client.actor('automation-lab/yellowpages-canada-scraper').call(run_input={
    'searchQuery': 'dentist',
    'location': 'Vancouver BC',
    'maxResults': 100,
})

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item['name'], item['phone'], item['fullAddress'])
```

#### cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~yellowpages-canada-scraper/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "searchQuery": "dentist",
    "location": "Vancouver BC",
    "maxResults": 100
  }'
```

### 🧠 Use with Claude and MCP

You can control this actor directly from Claude using the Apify MCP server.

#### Claude Code / CLI

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/yellowpages-canada-scraper"
```

#### Claude Desktop / Cursor / VS Code

Add to your MCP config file (`~/.config/claude/claude_desktop_config.json` on macOS):

```json
{
  "mcpServers": {
    "apify": {
      "command": "npx",
      "args": ["-y", "@apify/mcp-server"],
      "env": {
        "APIFY_TOKEN": "YOUR_TOKEN",
        "APIFY_MCP_ACTOR_IDS": "automation-lab/yellowpages-canada-scraper"
      }
    }
  }
}
```

#### Example Claude prompts

- *"Find all dentists in Calgary AB and export their phone numbers to a table"*
- *"Scrape 200 restaurants in Vancouver BC and show me which ones have ratings above 4 stars"*
- *"Get a list of plumbers in Toronto ON with their website URLs"*
- *"How many Italian restaurants are listed in Montreal QC on YellowPages Canada?"*

### ⚖️ Is it legal to scrape YellowPages Canada?

This actor scrapes publicly available business directory data from YellowPages.ca — the same information anyone can view in a browser. The data consists of business names, contact details, and categories that businesses have voluntarily listed in a public directory.

Web scraping of public information is generally lawful in Canada and most jurisdictions. Scraping public data for research, analysis, or lead generation is a widely accepted practice. We recommend reviewing YellowPages.ca's terms of service for your specific use case, and ensuring your use of the data complies with Canadian privacy legislation (PIPEDA) if you process personal data.

This actor does not bypass authentication, access private data, or violate any access controls.

### ❓ FAQ

**What locations does it support?**
All Canadian cities and regions. Use the city name and two-letter province code: `"Toronto ON"`, `"Vancouver BC"`, `"Calgary AB"`, `"Montreal QC"`, `"Ottawa ON"`, etc. Remote or smaller communities may return fewer results.

**How many results per page does YellowPages.ca show?**
Typically 20–40 organic listings per search page. The actor paginates automatically until your `maxResults` limit is reached.

**Can I scrape multiple cities in one run?**
Not directly — the actor takes one `searchQuery` and one `location` per run. For multiple cities, start multiple runs via the API or use the Apify Scheduler with different inputs.

**Why am I getting fewer results than expected?**
YellowPages.ca may have fewer listings for your category in that city. Try a broader search term (e.g. "food" instead of "Thai restaurant") or check yellowpages.ca manually to confirm total result count.

**I'm getting empty results or errors — what should I try?**
First, verify your search works on yellowpages.ca in a browser using the same query and location. If the site is accessible but the actor fails, try increasing `maxRequestRetries` to 5 or enabling datacenter proxies via `proxyConfiguration`.

**Does it scrape business detail pages?**
No — this actor scrapes the search results page only, which contains phone numbers, addresses, ratings, and categories without needing to visit each business's detail page. This keeps costs low.

**Can I get email addresses?**
YellowPages.ca does not publicly display email addresses on the search results page. Business websites (extracted in the `website` field) may have contact forms or email addresses.

**Is the data always current?**
The actor fetches live data from yellowpages.ca at run time. However, individual business listings are only as up-to-date as YellowPages.ca's own index.

### 🔗 Related scrapers

- [YellowPages US Scraper](https://apify.com/automation-lab/yellowpages-scraper) — Same format, US-based yellowpages.com
- [PagesJaunes France Business Scraper](https://apify.com/automation-lab/pagesjaunes-france-business-scraper) — French business directory (pagesjaunes.fr)

# Actor input Schema

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

Business type or keyword to search for on YellowPages.ca (e.g. "restaurant", "plumber", "dentist").

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

Canadian city and province to search in (e.g. "Toronto ON", "Vancouver BC", "Montreal QC").

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

Maximum number of business listings to extract.

## `includeAds` (type: `boolean`):

When enabled, sponsored/ad listings are included in results alongside organic listings.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed HTTP requests.

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

Optional proxy settings. YellowPages.ca typically works without proxies. Use datacenter proxies for high-volume scraping.

## Actor input object example

```json
{
  "searchQuery": "restaurant",
  "location": "Toronto ON",
  "maxResults": 20,
  "includeAds": true,
  "maxRequestRetries": 3
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "searchQuery": "restaurant",
    "location": "Toronto ON",
    "maxResults": 20,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/yellowpages-canada-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 = {
    "searchQuery": "restaurant",
    "location": "Toronto ON",
    "maxResults": 20,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/yellowpages-canada-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 '{
  "searchQuery": "restaurant",
  "location": "Toronto ON",
  "maxResults": 20,
  "maxRequestRetries": 3
}' |
apify call automation-lab/yellowpages-canada-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YellowPages Canada Business Scraper",
        "description": "Extract business listings from YellowPages.ca — Canada's largest business directory. Get phone numbers, addresses, star ratings, categories, and website URLs for any city and business type. Ideal for B2B lead generation and market research.",
        "version": "0.1",
        "x-build-id": "ViCPRZuJcQh0boQjx"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~yellowpages-canada-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-yellowpages-canada-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/automation-lab~yellowpages-canada-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-yellowpages-canada-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/automation-lab~yellowpages-canada-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-yellowpages-canada-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": [
                    "searchQuery",
                    "location"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "🔍 Search query",
                        "type": "string",
                        "description": "Business type or keyword to search for on YellowPages.ca (e.g. \"restaurant\", \"plumber\", \"dentist\")."
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "Canadian city and province to search in (e.g. \"Toronto ON\", \"Vancouver BC\", \"Montreal QC\")."
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of business listings to extract.",
                        "default": 50
                    },
                    "includeAds": {
                        "title": "Include sponsored listings",
                        "type": "boolean",
                        "description": "When enabled, sponsored/ad listings are included in results alongside organic listings.",
                        "default": true
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed HTTP requests.",
                        "default": 3
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Optional proxy settings. YellowPages.ca typically works without proxies. Use datacenter proxies for high-volume scraping."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```