# Google Maps New Lead Monitor | 💵$5/1K (`webdata_labs/google-maps-new-lead-monitor`) Actor

\[💵 $5.00 / 1K] Monitor any Google Maps niche and receive only Place IDs your saved Task has not returned before. Honest new-to-monitor evidence, optional no-website filters, and a reusable baseline.

- **URL**: https://apify.com/webdata\_labs/google-maps-new-lead-monitor.md
- **Developed by:** [WebData Labs](https://apify.com/webdata_labs) (community)
- **Categories:** Lead generation, Automation, SEO tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 newly discovered leads

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Maps New Lead Monitor

**Monitor any local niche and receive only Google Maps businesses your saved Task has not returned before - not an unsupported claim that every listing is a newly opened business.**

This Actor turns a repeat Google Maps search into a stateful lead feed. The first run creates a baseline. Later runs from the same saved Task return only unseen Place IDs, with public contact data, website-presence classification, and explicit signal evidence.

### ✅ What you get / ❌ What this isn't

✅ You get:

- Task-scoped deduplication by stable Google Maps CID
- `initial_snapshot` on the first run and `new_to_monitor` on later runs
- Name, category, address, phone, website, rating, Maps URL, and source query
- Optional filters for no website, social-only presence, or any business
- Optional import of an older dataset or a list of Place IDs to exclude

❌ This is not:

- A claim that every result recently opened
- A cached national directory
- Email enrichment or automated outreach
- A private-data scraper

### 🔎 Why use this Google Maps lead monitor

Ordinary Maps scrapers sell the same rows again on every run. This Actor remembers what each saved Task has already delivered, so a weekly workflow can focus on the delta. The `signalEvidence` field states exactly why a row appeared.

The monitor works for web agencies, POS and payment vendors, signage companies, accountants, insurers, telecom installers, commercial cleaners, and other businesses that sell to local companies.

### 📊 What data you get

| Field | Type | Description |
|---|---|---|
| `placeId` | string | Stable Maps CID used for deduplication |
| `signalType` | string | `initial_snapshot`, `new_to_monitor`, or `current_result` |
| `signalEvidence` | string | Plain-language reason the row was emitted |
| `name`, `category` | string | Business identity |
| `address`, `phone` | string | Public contact details |
| `websiteUrl` | string | Website listed on Google Maps |
| `presence` | string | `none`, `social_only`, `has_website`, or `broken_website` |
| `rating`, `reviewsCount` | number | Rating data when exposed by the source |
| `observedAt`, `firstSeenAt` | ISO date | Monitoring timestamps |
| `googleMapsUrl` | URL | Source listing |
| `searchQuery` | string | Query that found the business |

### 👥 Who it's for

- Web and SEO agencies monitoring businesses with weak web presence
- POS, payments, telecom, security, signage, and local-service vendors
- Sales operations teams that need a repeatable local-prospect feed
- Developers calling an Apify dataset through REST, Make, Zapier, or webhooks

### ⚙️ How to monitor new Google Maps leads

1. Enter one category and location per search, such as `roofers in Austin, TX`.
2. Keep **Only return businesses not seen before** enabled.
3. Save the Actor as a Task.
4. Run once to establish the baseline.
5. Schedule the same Task weekly or daily.
6. Export the dataset or connect it to Google Sheets, a CRM, Make, Zapier, or a webhook.

The saved Task is important: every Task keeps separate history, so a roofing monitor never contaminates an electrician monitor.

### 📥 Input

```json
{
  "searchQueries": [
    "roofers in Austin, TX",
    "roofers in San Antonio, TX"
  ],
  "onlyNew": true,
  "presenceFilter": "weak_presence",
  "monitorDepthPerQuery": 100,
  "maxNewRowsPerQuery": 50,
  "countryCode": "us",
  "language": "en"
}
````

- `onlyNew` defaults to `true`. The first run is clearly labeled as a baseline.
- `presenceFilter` can be `any`, `weak_presence`, or `no_website_only`.
- `baselineDatasetId` is optional and only needed when importing an older lead list.
- `excludePlaceIds` is optional and accepts IDs or Maps URLs.
- `monitorDepthPerQuery` controls how many top Maps positions are remembered and compared each run.
- `maxNewRowsPerQuery` caps output without weakening the baseline. Set it to `0` for unlimited output.

### 📤 Output

```json
{
  "placeId": "1234567890123456789",
  "name": "Example Roofing Co.",
  "category": "Roofing contractor",
  "phone": "(512) 555-0100",
  "presence": "none",
  "signalType": "new_to_monitor",
  "signalEvidence": "This Place ID was not returned by this saved Task in any earlier successful run.",
  "observedAt": "2026-07-23T12:00:00.000Z",
  "googleMapsUrl": "https://maps.google.com/?cid=1234567890123456789",
  "searchQuery": "roofers in Austin, TX",
  "source": "Google Maps web search"
}
```

The **New leads** dataset view puts the signal, business, phone, website presence, address, observation time, score, and Maps URL first.

### 💵 How much does it cost?

Pricing has two value-aligned events:

- **Area scan:** $0.002 for each search query successfully scanned on the Free and Bronze tiers
- **New lead row:** $0.005 per dataset row on Free and Bronze, $0.004 on Silver, and $0.003 on Gold and higher plans

Example: scanning two city queries and receiving 40 rows costs about **$0.204** on Free or Bronze. A repeat run with no new rows costs only **$0.004** for the two area scans, because Maps and proxy work still happened.

### 🔁 Run it on the Apify platform

Schedule a saved Task, call it through the Apify API, connect the dataset to Google Sheets with Make or Zapier, or send run-finished webhooks into your CRM.

### ⚠️ Limits and caveats

- `new_to_monitor` means new to this saved Task's history. It does not prove the business itself just opened.
- The first run establishes a baseline and is labeled `initial_snapshot`.
- Google Maps coverage and fields vary by country, category, query, and source response.
- Review count and opening status may be unavailable in the current structured endpoint.
- Deleting the Task or its named history store resets automatic history.
- Use public business data responsibly and follow applicable outreach, privacy, and platform rules.

### 🧩 Related Actors

- [Google Maps No-Website Leads Scraper](https://apify.com/webdata_labs/google-maps-no-website-leads-scraper)
- [Google Maps Low Rating Leads](https://apify.com/webdata_labs/google-maps-reputation-leads-scraper)
- [Website Contact Extractor](https://apify.com/webdata_labs/website-contact-extractor)

### Example tasks

- [Weekly new roofers by city](https://apify.com/webdata_labs/google-maps-new-lead-monitor/examples/weekly-new-roofers-by-city)
- [Weekly new electricians by city](https://apify.com/webdata_labs/google-maps-new-lead-monitor/examples/weekly-new-electricians-by-city)
- [New restaurant leads for POS vendors](https://apify.com/webdata_labs/google-maps-new-lead-monitor/examples/new-restaurants-for-pos-vendors)

### ❓ FAQ

#### Does this find newly opened businesses?

It finds businesses newly observed by a specific saved Task. It deliberately does not label a row `recently_opened` unless the source exposes auditable evidence, which the current structured Maps endpoint does not reliably provide.

#### Is `onlyNew` hard to configure?

No. It is enabled by default. Save the Actor as a Task and run it repeatedly. The baseline dataset and exclusion list are advanced options, not required setup.

#### Can I run a normal one-time Google Maps export?

Yes. Turn `onlyNew` off and the Actor labels rows `current_result`.

#### Can this send data to Google Sheets?

Yes. Connect the resulting dataset through an Apify integration, Make, Zapier, or a webhook. The Actor keeps scraping and monitoring separate from credentials for your destination.

### 🛠️ Support

When reporting an issue, include the run URL, non-secret input, expected behavior, and one affected search query.

# Actor input Schema

## `searchQueries` (type: `array`):

Add one Google Maps search per line, for example "roofers in Austin, TX". Use the same saved Task each week so the monitor can remember what it already returned.

## `monitorDepthPerQuery` (type: `integer`):

How many top Google Maps positions to remember and compare on every run. A deeper monitor catches more changes but uses more proxy traffic. Maximum 500.

## `maxNewRowsPerQuery` (type: `integer`):

Cap the number of dataset rows emitted per search. The Actor still remembers every matching place inside the monitored depth, preventing old businesses from leaking into later runs as false new leads. Set 0 for no output limit.

## `onlyNew` (type: `boolean`):

Recommended for saved or scheduled Tasks. The first run returns a baseline. Later runs from the same Task automatically return only unseen Google Maps Place IDs. Turn this off for a normal current-results export.

## `presenceFilter` (type: `string`):

Return every new business, only businesses with no proper website, or strictly those with no website listed.

## `baselineDatasetId` (type: `string`):

Advanced and optional. Paste an Apify dataset ID or dataset URL from an older run. Its Place IDs are excluded. Leave blank when starting a new saved Task.

## `excludePlaceIds` (type: `array`):

Advanced and optional. Paste numeric Google Maps CIDs, Place IDs, or Maps URLs that should never be returned.

## `countryCode` (type: `string`):

Two-letter Google localization code, for example us, gb, de, pl, pt, or es.

## `language` (type: `string`):

Google interface language, for example en, de, pl, pt, or es.

## `checkWebsiteStatus` (type: `boolean`):

Optionally test listed websites and classify unreachable sites as broken\_website. This adds network requests and runtime.

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

Keep the residential proxy default unless you understand Google Maps proxy behavior.

## `debugDumpRaw` (type: `boolean`):

Developer option. Save raw response pages to the run key-value store.

## Actor input object example

```json
{
  "searchQueries": [
    "roofers in Austin, TX"
  ],
  "monitorDepthPerQuery": 20,
  "maxNewRowsPerQuery": 10,
  "onlyNew": true,
  "presenceFilter": "any",
  "excludePlaceIds": [],
  "countryCode": "us",
  "language": "en",
  "checkWebsiteStatus": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "debugDumpRaw": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

Rows emitted for the current baseline or newly discovered Place IDs.

## `summary` (type: `string`):

Counts, monitoring mode, history scope, and observation timestamp.

# 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 = {
    "searchQueries": [
        "roofers in Austin, TX"
    ],
    "monitorDepthPerQuery": 20,
    "maxNewRowsPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("webdata_labs/google-maps-new-lead-monitor").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 = {
    "searchQueries": ["roofers in Austin, TX"],
    "monitorDepthPerQuery": 20,
    "maxNewRowsPerQuery": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("webdata_labs/google-maps-new-lead-monitor").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 '{
  "searchQueries": [
    "roofers in Austin, TX"
  ],
  "monitorDepthPerQuery": 20,
  "maxNewRowsPerQuery": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call webdata_labs/google-maps-new-lead-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=webdata_labs/google-maps-new-lead-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps New Lead Monitor | 💵$5/1K",
        "description": "[💵 $5.00 / 1K] Monitor any Google Maps niche and receive only Place IDs your saved Task has not returned before. Honest new-to-monitor evidence, optional no-website filters, and a reusable baseline.",
        "version": "0.1",
        "x-build-id": "FqhOIz1bgw0FGQL9x"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/webdata_labs~google-maps-new-lead-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-webdata_labs-google-maps-new-lead-monitor",
                "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/webdata_labs~google-maps-new-lead-monitor/runs": {
            "post": {
                "operationId": "runs-sync-webdata_labs-google-maps-new-lead-monitor",
                "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/webdata_labs~google-maps-new-lead-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-webdata_labs-google-maps-new-lead-monitor",
                "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": [
                    "searchQueries"
                ],
                "properties": {
                    "searchQueries": {
                        "title": "Businesses and locations to monitor",
                        "type": "array",
                        "description": "Add one Google Maps search per line, for example \"roofers in Austin, TX\". Use the same saved Task each week so the monitor can remember what it already returned.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "monitorDepthPerQuery": {
                        "title": "Places monitored per search",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "How many top Google Maps positions to remember and compare on every run. A deeper monitor catches more changes but uses more proxy traffic. Maximum 500.",
                        "default": 100
                    },
                    "maxNewRowsPerQuery": {
                        "title": "Maximum new rows returned per search",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Cap the number of dataset rows emitted per search. The Actor still remembers every matching place inside the monitored depth, preventing old businesses from leaking into later runs as false new leads. Set 0 for no output limit.",
                        "default": 50
                    },
                    "onlyNew": {
                        "title": "Only return businesses not seen before",
                        "type": "boolean",
                        "description": "Recommended for saved or scheduled Tasks. The first run returns a baseline. Later runs from the same Task automatically return only unseen Google Maps Place IDs. Turn this off for a normal current-results export.",
                        "default": true
                    },
                    "presenceFilter": {
                        "title": "Website presence filter",
                        "enum": [
                            "any",
                            "weak_presence",
                            "no_website_only"
                        ],
                        "type": "string",
                        "description": "Return every new business, only businesses with no proper website, or strictly those with no website listed.",
                        "default": "any"
                    },
                    "baselineDatasetId": {
                        "title": "Existing dataset to treat as already seen",
                        "type": "string",
                        "description": "Advanced and optional. Paste an Apify dataset ID or dataset URL from an older run. Its Place IDs are excluded. Leave blank when starting a new saved Task."
                    },
                    "excludePlaceIds": {
                        "title": "Place IDs to exclude",
                        "type": "array",
                        "description": "Advanced and optional. Paste numeric Google Maps CIDs, Place IDs, or Maps URLs that should never be returned.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter Google localization code, for example us, gb, de, pl, pt, or es.",
                        "default": "us"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Google interface language, for example en, de, pl, pt, or es.",
                        "default": "en"
                    },
                    "checkWebsiteStatus": {
                        "title": "Check whether listed websites are reachable",
                        "type": "boolean",
                        "description": "Optionally test listed websites and classify unreachable sites as broken_website. This adds network requests and runtime.",
                        "default": false
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Keep the residential proxy default unless you understand Google Maps proxy behavior.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    },
                    "debugDumpRaw": {
                        "title": "Debug: save raw Maps responses",
                        "type": "boolean",
                        "description": "Developer option. Save raw response pages to the run key-value store.",
                        "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
