# YellowPages Australia Scraper - $2.5/1K - Business Leads (`mamies/yellowpages-australia-scraper`) Actor

Scrape Australian business listings from YellowPages.com.au by category and city. Returns name, phone, split street/suburb/state/postcode, website, categories and more — one clean record per business. Pay only per business delivered.

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

## Pricing

from $2.50 / 1,000 business scrapeds

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

## YellowPages Australia Scraper — Business Leads with Full Address & Website 📇

**Turn any Australian business category into a clean lead list.** Pick a category and a city — "dentists in Sydney, NSW", "plumbers in Melbourne, VIC" — and get one structured record per business, with phone, full street address, website, and categories.

**Pay only per business delivered.** No subscriptions, no per-page fees.

---

### 🚀 Why this scraper?

- ✅ **A phone number on every single record** — 100% of businesses delivered across every test run carried a phone
- ✅ **Address split into real columns** — `street`, `suburb`, `state`, and `postcode` as separate fields, not one jammed-together string. Import straight into a CRM, filter by territory, or run a mail merge without cleanup.
- ✅ **All eight states and territories** — NSW, VIC, QLD, WA, SA, TAS, ACT, NT
- ✅ **Website URLs included** — the business's own site, ready to enrich further
- ✅ **Never pay twice for the same business** — every record is de-duplicated across the whole run
- ✅ **Sponsored listings flagged** — marked `is_ad` so you can keep or drop them
- ✅ **No empty rows** — listings with no phone, address *or* website are dropped before you're charged, so you never pay for a lead you can't contact
- ✅ **Emails & social profiles** — optional paid add-on that pulls email addresses, social media profiles, and contact pages from each business's own website
- ✅ **Clean export** — JSON, CSV, Excel, XML, or HTML

**Pairs perfectly with our [Website Contact Scraper](https://apify.com/mamies/website-contact-scraper):** already have a domain list? Feed it straight in there instead.

---

### 📊 Output example

One record per business:

```json
{
  "name": "Smile Concepts",
  "phone": "(02) 9267 7778",
  "full_address": "Level 4 307 Pitt Street, Sydney, NSW 2000",
  "street": "Level 4 307 Pitt Street",
  "suburb": "Sydney",
  "state": "NSW",
  "postcode": "2000",
  "website": "http://www.smileconcepts.com.au",
  "categories": ["Dentists"],
  "star_rating": 4.8,
  "review_count": 73,
  "years_in_business": null,
  "snippet": "From Business: Dentist in Sydney offering services like: Dental Implants; Porcelain Veneers, Orthodontics…",
  "yp_url": "https://www.yellowpages.com.au/sydney-nsw/bpp/smile-concepts-580264105",
  "image": "https://i4.ypcdn.com/blob/6f33cdfc84ece39ce4309aa51480dd407973d88f_180x50_max.jpg",
  "is_ad": true
}
````

With contact enrichment enabled, each record also carries `emails`, all 10 social platform fields, and `contact_page`:

```json
{
  "name": "Dr Jessica O'Neill, Dr Luke Villata & Dr Anand Prabhu",
  "phone": "(02) 9331 5266",
  "website": "http://www.sydneyperio.com.au",
  "emails": ["reception@sydneyperio.com.au"],
  "facebook": "https://www.facebook.com/sydneyperioau",
  "instagram": "https://www.instagram.com/sydneyperioau",
  "linkedin": null,
  "contact_page": "https://sydneyperio.com.au/contact-us/"
}
```

*Trimmed for readability — every record carries all the fields listed below, and contact-enriched records always include all 10 social platform fields (`facebook`, `instagram`, `linkedin`, `twitter`, `youtube`, `tiktok`, `pinterest`, `github`, `telegram`, `whatsapp`); platforms the business doesn't have come back as `null`.*

Every field is returned on every record — a business that doesn't publish something gets `null` (or `[]`) rather than a missing key, so your columns stay stable across runs.

***

### 📊 Data fields extracted

| Field | Description |
|---|---|
| **name** | Business name |
| **phone** | Phone number, as displayed — e.g. `(02) 9267 7778` |
| **full\_address** | Street, suburb, state and postcode joined into one line |
| **street** / **suburb** / **state** / **postcode** | The same address as four separate columns |
| **website** | The business's own site. Directory links that aren't a real website come back as `null` rather than a misleading URL. |
| **categories** | Every category the business is listed under |
| **star\_rating** | Average star rating out of 5 — the exact average, e.g. `4.8` |
| **review\_count** | Number of reviews behind that rating |
| **years\_in\_business** | Years trading, where published |
| **snippet** | A short business blurb |
| **yp\_url** | The listing this record came from |
| **image** | Listing photo. Businesses without a real photo return `null` rather than the site's generic placeholder tile. |
| **is\_ad** | `true` for sponsored placements |
| **emails** | Contact emails found on the business website *(when contact enrichment is enabled)* |
| **facebook** … **whatsapp** | Social profile links — Facebook, Instagram, LinkedIn, Twitter/X, YouTube, TikTok, Pinterest, GitHub, Telegram, WhatsApp *(when contact enrichment is enabled)* |
| **contact\_page** | URL of the website's contact page *(when contact enrichment is enabled)* |

#### What to actually expect, by field

Coverage differs a lot between the **contact** fields and the **profile** fields, and it's worth knowing before you run:

| | Typical coverage |
|---|---|
| Name, phone, categories, listing URL | **100%** |
| Street address, suburb, state, postcode | **91–99%** |
| Website | **30–50%**, strongly category-dependent |
| Star rating, review count, years in business, blurb, photo | **3–50%**, highly variable |

Measured across six category/city combinations plus 200- and 90-record single-category runs, July 2026.

> **On ratings:** unlike the US YellowPages, most Australian listings simply have no reviews on the site — a 200-record Brisbane cafés run returned a rating on 3% of records, while a Melbourne plumbers run returned one on 51%. **Rating and review count are a bonus here, not a reason to buy.** Phone and address are what this actor reliably delivers.

Download the full dataset as JSON, CSV, Excel, XML, or HTML from the Output tab.

***

### ✉️ About emails & socials

Contacts are extracted by visiting each business's own website, so they exist **only for businesses that publish a website** — and on YellowPages Australia that's only about **30–50% of listings**, considerably fewer than on the US site.

Measured across two enriched runs:

| | Melbourne dentists (90) | Melbourne plumbers (50) |
|---|---|---|
| Had a website at all | 29% | 44% |
| **Yielded at least one email** | **19%** | **30%** |
| — of those that had a website | 65% | 68% |
| Yielded at least one social profile | 18% | 26% |

So expect emails on roughly **one record in five to one in three**, depending on how web-present the category is. The consistent part is the conversion: of businesses that *do* have a website, about **two thirds** publish a reachable email. The rest use a contact form only.

Enable **Find email addresses & social profiles** in the input to turn this on — and note it's charged on every result in the run, not just the ones that produce an email.

***

### ⬇️ Input

Four fields — **fill them in and run.** No configuration, no proxy setup, nothing to tune.

| Parameter | Required | Description |
|---|---|---|
| **searchTerm** | Yes | The business category, as you'd type it on the site — `dentists`, `plumbers`, `electricians` |
| **location** | Yes | An Australian city or suburb **and state** — `Sydney, NSW` or `Melbourne, Victoria`. The state is required. |
| **maxResults** | No | How many businesses to return (default `10`). Listings run 30 per page and go dozens of pages deep, so this is what ends the run. |
| **extractEmails** | No | **Paid add-on.** Visit each business website to extract contact emails, social profiles, and the contact page (adds the `emails`, social, and `contact_page` fields). Every result in the run is charged at the higher add-on rate. |

**Why the state is required:** if YellowPages doesn't recognise the city, it quietly returns results for the *whole state* instead of failing. Requiring the state is what stops a typo from silently handing you the wrong area — `Sydney, NSW`, not `Sydney`.

**Tip:** Start with a small **maxResults** to preview the data for a category, then raise it once you're happy with what comes back.

***

### 🎯 Use cases

- **Local lead generation** — build a targeted prospect list for any trade in any Australian city
- **Territory planning** — filter by postcode, suburb, or state to carve up sales regions
- **Market research** — size up how many competitors operate in a given area
- **CRM enrichment** — fill in phone, address, and website for businesses you already track
- **Directory building** — assemble niche listings for a site or newsletter

***

### ❓ FAQ

**How is this billed?**
You pay a flat rate per business delivered. Runs with **Find email addresses & social profiles** switched on are charged at a higher rate — applied to every result in the run, whether or not that particular business turned out to publish an email. Duplicates are removed before billing, so the same business is never charged twice in a run. You can set a maximum spend per run — when it's reached, the run finishes cleanly and you keep everything scraped up to that point.

**How many results can I get?**
Listings for a popular category in a capital city run into the thousands — a Sydney dentists search was still returning full pages at page 40. Set `maxResults` to whatever you need. Smaller towns and narrower categories will naturally have fewer.

**Why are some fields empty on a few records?**
Not every business publishes everything. Name, phone, categories and listing URL come back on 100% of records, and a full split address on 91–99%. Website, rating, review count, years in business, blurb and photo are only present when the business has supplied them — see the coverage table above. Listings that publish *no* phone, address or website at all are dropped entirely rather than delivered as empty rows, so you're never charged for them.

**Why don't all results have emails?**
Emails come from business websites, and only 30–50% of Australian YellowPages listings have one. Of those that do, roughly two-thirds publish a reachable email; the rest use a contact form only.

**Are duplicates removed?**
Yes. Every record is de-duplicated by its listing identity before it reaches you, so you never receive — or pay for — the same business twice. This also removes the sponsored copies the site shows in its sidebar, which are duplicates of listings already in the results. Note that genuinely separate branches of a chain are different businesses and are returned separately.

**Do I need proxies?**
No — proxies are managed automatically.

**Can I automate it?**
Yes — schedule it, chain it with other actors, or connect Make, n8n, Zapier, Google Sheets, and webhooks via Apify integrations.

**What export formats are supported?**
JSON, CSV, Excel, XML, and HTML — from the Output tab or the Apify API.

**Is this legal?**
The actor only reads publicly available business listings — information companies publish about themselves to be found. You are responsible for using the data lawfully (e.g. the Australian Privacy Act and the Spam Act 2003) in your outreach.

***

### 💡 Tips

- Proxies are managed automatically — no proxy setup or configuration needed.
- Start small: preview a category with a low **maxResults**, then scale up.
- Search by **suburb** rather than the capital city to carve up a metro area — `Parramatta, NSW` and `Bondi, NSW` return different businesses than `Sydney, NSW`.
- Contact enrichment costs more per result — use it when you need emails, social profiles, or contact pages, and remember website coverage caps what it can find.
- Already have a list of domains? Feed it straight into our [Website Contact Scraper](https://apify.com/mamies/website-contact-scraper) instead.

> *Unofficial scraper — not affiliated with, endorsed by, or sponsored by YellowPages, Sensis, or Thryv.*

***

# Actor input Schema

## `searchTerm` (type: `string`):

The business category to search for, exactly as you'd type it on YellowPages — 'dentists', 'plumbers', 'electricians'.

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

An Australian city or suburb with its state: 'Sydney, NSW' or 'Melbourne, Victoria'. The state is required — without it YellowPages quietly returns state-wide results for a different area than you meant. All eight states and territories work: NSW, VIC, QLD, WA, SA, TAS, ACT, NT.

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

How many businesses to return. Results run 30 per page and go dozens of pages deep, so this is what ends the run. You're charged per business delivered.

## `extractEmails` (type: `boolean`):

Add-on: when this is on, EVERY result in the run is charged at the higher add-on rate, not just the ones that turn out to have an email. Visits each business's own website to find email addresses, social media profiles, and their contact page; social profiles are included free. Coverage is limited by a fact worth knowing first: only about 30-50% of Australian YellowPages listings publish a website at all, and businesses without one are skipped. Across two test runs, 19-30% of all results yielded an email — roughly 1 in 5 to 1 in 3, depending on how web-present the category is. Runs also take longer with this on. Leave it off for name, phone, address and website at the standard rate.

## Actor input object example

```json
{
  "searchTerm": "dentists",
  "location": "Sydney, NSW",
  "maxResults": 10,
  "extractEmails": false
}
```

# Actor output Schema

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

All scraped business records — name, phone, full address split into street/suburb/state/postcode, website, categories, plus star rating, review count, years in business, review snippet, listing URL and image where the listing publishes them, and emails + social profiles and the contact page when contact enrichment is enabled. Append ?format=csv or ?format=xlsx to the URL for spreadsheet exports.

# 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 = {
    "searchTerm": "dentists",
    "location": "Sydney, NSW"
};

// Run the Actor and wait for it to finish
const run = await client.actor("mamies/yellowpages-australia-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 = {
    "searchTerm": "dentists",
    "location": "Sydney, NSW",
}

# Run the Actor and wait for it to finish
run = client.actor("mamies/yellowpages-australia-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 '{
  "searchTerm": "dentists",
  "location": "Sydney, NSW"
}' |
apify call mamies/yellowpages-australia-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "YellowPages Australia Scraper - $2.5/1K - Business Leads",
        "description": "Scrape Australian business listings from YellowPages.com.au by category and city. Returns name, phone, split street/suburb/state/postcode, website, categories and more — one clean record per business. Pay only per business delivered.",
        "version": "0.1",
        "x-build-id": "uQ30kH1PKHedhHcQj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/mamies~yellowpages-australia-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-mamies-yellowpages-australia-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/mamies~yellowpages-australia-scraper/runs": {
            "post": {
                "operationId": "runs-sync-mamies-yellowpages-australia-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/mamies~yellowpages-australia-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-mamies-yellowpages-australia-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": [
                    "searchTerm",
                    "location"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Search term",
                        "type": "string",
                        "description": "The business category to search for, exactly as you'd type it on YellowPages — 'dentists', 'plumbers', 'electricians'."
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "An Australian city or suburb with its state: 'Sydney, NSW' or 'Melbourne, Victoria'. The state is required — without it YellowPages quietly returns state-wide results for a different area than you meant. All eight states and territories work: NSW, VIC, QLD, WA, SA, TAS, ACT, NT."
                    },
                    "maxResults": {
                        "title": "Maximum results",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "How many businesses to return. Results run 30 per page and go dozens of pages deep, so this is what ends the run. You're charged per business delivered.",
                        "default": 10
                    },
                    "extractEmails": {
                        "title": "Find email addresses & social profiles — paid add-on",
                        "type": "boolean",
                        "description": "Add-on: when this is on, EVERY result in the run is charged at the higher add-on rate, not just the ones that turn out to have an email. Visits each business's own website to find email addresses, social media profiles, and their contact page; social profiles are included free. Coverage is limited by a fact worth knowing first: only about 30-50% of Australian YellowPages listings publish a website at all, and businesses without one are skipped. Across two test runs, 19-30% of all results yielded an email — roughly 1 in 5 to 1 in 3, depending on how web-present the category is. Runs also take longer with this on. Leave it off for name, phone, address and website at the standard rate.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
