# Google Maps Geo-Grid Local Rank Tracker (`fayoussef/geo-grid-local-rank-tracker`) Actor

Track where a business ranks in the Google Maps local pack across a grid of points around it. Per-point rank, average rank, coverage, Share of Local Voice, top competitors and an HTML heatmap. No Google API key.

- **URL**: https://apify.com/fayoussef/geo-grid-local-rank-tracker.md
- **Developed by:** [youssef farhan](https://apify.com/fayoussef) (community)
- **Categories:** SEO tools, Developer tools, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Google Maps Geo-Grid Local Rank Tracker

**Geo-grid local rank tracking for Google Maps, without a Google API key.** This actor checks where a business ranks in the Google Maps local pack from a grid of geographic points spread around it, so you see your true visibility neighborhood by neighborhood instead of from a single spot. It is a pay-per-scan [Local Falcon](https://www.localfalcon.com) alternative for local SEO agencies, multi-location brands, and Google Business Profile consultants.

A single rank check lies: you might sit at #1 next to your storefront and vanish by #12 two miles away. Geo-grid scanning is the fix. Enter a business name, one or more keywords, and a location. The actor searches Google Maps as if a customer were standing at each grid point, records your rank at every point, and returns the ranks, a per-keyword summary (average rank, coverage, Share of Local Voice), the top competitors at each spot, and a color-coded HTML heatmap.

Because it runs on Apify, you get API access, scheduling, webhooks, and integrations (Zapier, Make, Google Sheets, Slack) out of the box, so a weekly rank scan per client becomes a hands-off automation.

### What is geo-grid rank tracking?

Geo-grid rank tracking measures a business's Google Maps ranking from many points across a map grid instead of one location. Each point is a real search origin, so the results reflect what nearby customers actually see. Plotting the rank at every point produces a heatmap that shows exactly where a business is visible and where it drops off, which is the core diagnostic for local SEO and Google Business Profile optimization.

### Why use this Google Maps rank tracker?

- **See your real local visibility.** One number hides the truth. A 7x7 grid shows the streets and neighborhoods where you win and where competitors own the map pack.
- **No Google API key, no per-call Google billing.** It reads Google Maps' public local results directly. You pay Apify per grid point scanned, nothing to Google.
- **Track competitors automatically.** Every scan records who ranks around your target, how often each competitor appears, and their best position, ratings, and review counts.
- **A Local Falcon alternative you can automate.** Schedule a scan per client, pull results by API, and feed heatmaps into white-label reports.
- **Share of Local Voice built in.** Get the same headline metrics agencies report: average rank, coverage percentage, and Share of Local Voice (SoLV).

### How to track Google Maps rankings: tutorial

1. Enter the **Business name** exactly as it appears on its Google profile (for example `Blue Bottle Coffee`).
2. Add one or more **Keywords** your customers search (for example `coffee shop`, `espresso bar`).
3. Set the **Location** (city, area, or full address). It is geocoded automatically, or you can pin exact centre latitude/longitude.
4. Choose a **Grid size** (5 means a 5x5 = 25-point grid) and a **Radius** (how far the grid reaches from the centre).
5. Click **Start**. The actor scans each point, matches your business in the local results, and pushes one row per point to the dataset.
6. Open the **Storage** tab: the dataset holds every grid point; the key-value store holds the `SUMMARY` metrics and a visual `HEATMAP` you can open in a browser.

### Input

| Field | What it does |
|---|---|
| `businessName` | The business to track, as shown on Google Maps |
| `keywords` | Searches to check at every grid point |
| `location` | City, area, or address for the grid centre (auto-geocoded) |
| `gridSize` | Points per side. 5 = 5x5 = 25 points |
| `radius` | Distance from centre to edge of the grid |
| `distanceUnit` | `miles` or `km` |
| `maxRank` | Positions beyond this count as "not found" (max 20) |
| `placeId` | Optional Google place ID for exact matching |
| `centerLat` / `centerLng` | Optional exact grid centre instead of geocoding |
| `language` / `countryCode` | Google `hl` and `gl` region settings |

```json
{
    "businessName": "Blue Bottle Coffee",
    "keywords": ["coffee shop", "espresso bar"],
    "location": "San Francisco, CA",
    "gridSize": 7,
    "radius": 2,
    "distanceUnit": "miles"
}
````

### Output

One dataset row per grid point per keyword. Download as JSON, CSV, Excel, or HTML, or fetch by API:

```json
{
    "businessName": "Blue Bottle Coffee",
    "keyword": "coffee shop",
    "gridRow": 2,
    "gridCol": 3,
    "lat": 37.7796,
    "lng": -122.4144,
    "distanceFromCenter": 0.71,
    "distanceUnit": "miles",
    "rank": 3,
    "found": true,
    "foundRating": 4.5,
    "foundReviews": 812,
    "topCompetitors": ["Ritual Coffee", "Sightglass Coffee", "Saint Frank Coffee"],
    "scannedAt": "2026-07-24T10:00:00+00:00"
}
```

The key-value store also holds:

- `SUMMARY` (JSON): per-keyword average rank, coverage, best/worst rank, Share of Local Voice, and the top competitors across the grid.
- `HEATMAP` (HTML): a color-coded grid per keyword you can open, screenshot, or drop into a client report.

### What is Share of Local Voice (SoLV)?

Share of Local Voice is a 0-100 score of how much of the total available ranking strength across the whole grid a business captures. A business ranking #1 at every point scores near 100; one that appears weakly or only in a corner of the grid scores low. It is a single number for comparing visibility over time or against a competitor.

### How much does it cost to track Google Maps rankings?

You pay per grid point scanned. One keyword on a 5x5 grid is 25 scans; a 7x7 grid is 49. Two keywords on a 7x7 grid is 98 scans. Pick the grid size that matches the area you serve: tighter grids for a single neighborhood, wider grids for a whole metro. Free-plan users are limited to a 3x3 grid and one keyword; subscribe to an [Apify plan](https://apify.com/pricing?fpr=youssef) to unlock the full grid and multiple keywords.

### Can I call this Actor from an AI agent?

Yes. It works with the **Apify MCP server**, so Claude, ChatGPT, or any MCP-enabled agent can run a scan and read the ranks and summary directly. The dataset and key-value store schemas are fully typed for agent consumption.

### FAQ

**Do I need a Google Maps API key?** No. The actor reads Google Maps' public local results, so there is no Google API key and no Google billing.

**Why are residential proxies recommended?** Google blocks datacenter IPs. The default configuration uses Apify residential proxies and works out of the box.

**How is this different from a plain Google Maps scraper?** A scraper lists businesses near one point. This actor measures one business's rank across a whole grid of points and turns it into coverage, Share of Local Voice, and a heatmap: the local SEO diagnostic, not just a business list.

**What grid size should I use?** Odd sizes (3, 5, 7, 9) keep the business at the centre point. Use 5x5 for a neighborhood, 7x7 to 9x9 for a city, with a radius that covers the area you actually serve.

**My business is not found at some points.** That is the signal you want: those are the areas where you are invisible to Google Maps searchers and where local SEO work will pay off.

**Is this legal?** The actor only reads publicly visible Google Maps results, no login and no private data. You are responsible for using the output in compliance with applicable laws and Google's terms.

**Found an issue or need a custom feature?** Open a ticket in the **Issues** tab, or reach out for a custom solution at **youssefarhan24@gmail.com**. Got a site you want scraped? [Suggest it here](https://automationbyexperts.com/apify).

# Actor input Schema

## `businessName` (type: `string`):

The business whose Google Maps rank you want to track, exactly as it appears on its Google profile. The actor finds this name in the local results at each grid point.

⚡ Unlock the full grid and multiple keywords by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).
💼 Need a custom solution? Reach out at youssefarhan24@gmail.com
🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)

## `keywords` (type: `array`):

The searches your customers type, e.g. `coffee shop`, `espresso bar near me`. Each keyword is checked at every grid point. Free plan uses the first keyword only.

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

Centre of the grid, e.g. `San Francisco, CA` or a full street address. It is geocoded automatically. Leave empty only if you set the centre latitude/longitude below.

## `gridSize` (type: `integer`):

How many points per side. 5 means a 5x5 = 25-point grid. Odd numbers keep the business at the centre point. Bigger grids = finer detail = more scans. Free plan is capped at 3x3.

## `radius` (type: `integer`):

Distance from the centre to the edge of the grid, in the unit below. 2-3 miles suits a city neighbourhood; use more for a whole metro.

## `distanceUnit` (type: `string`):

Unit for the grid radius and reported distances.

## `maxRank` (type: `integer`):

Positions beyond this are treated as "not found" at that point. Google's local finder returns up to 20 results per search.

## `placeId` (type: `string`):

For exact matching when the business name is generic or shared. Format like `0x89c25...:0x...`. If set, it is matched instead of the name.

## `centerLat` (type: `number`):

Set this and the longitude to skip geocoding and pin the grid centre precisely.

## `centerLng` (type: `number`):

Longitude of the grid centre. Used together with the latitude above.

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

Google interface language code, e.g. `en`, `fr`, `es`.

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

Two-letter country code for the search region, e.g. `us`, `gb`, `ca`.

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

Residential proxies are strongly recommended: Google Maps blocks datacenter IPs.

## Actor input object example

```json
{
  "businessName": "Blue Bottle Coffee",
  "keywords": [
    "coffee shop"
  ],
  "location": "San Francisco, CA",
  "gridSize": 5,
  "radius": 2,
  "distanceUnit": "miles",
  "maxRank": 20,
  "language": "en",
  "countryCode": "us",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `grid` (type: `string`):

One row per grid point per keyword, with the business rank and top competitors.

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

Per-keyword average rank, coverage, and Share of Local Voice.

## `heatmap` (type: `string`):

Visual HTML heatmap of the grid ranks.

# 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 = {
    "businessName": "Blue Bottle Coffee",
    "keywords": [
        "coffee shop"
    ],
    "location": "San Francisco, CA",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("fayoussef/geo-grid-local-rank-tracker").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 = {
    "businessName": "Blue Bottle Coffee",
    "keywords": ["coffee shop"],
    "location": "San Francisco, CA",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("fayoussef/geo-grid-local-rank-tracker").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 '{
  "businessName": "Blue Bottle Coffee",
  "keywords": [
    "coffee shop"
  ],
  "location": "San Francisco, CA",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call fayoussef/geo-grid-local-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fayoussef/geo-grid-local-rank-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Geo-Grid Local Rank Tracker",
        "description": "Track where a business ranks in the Google Maps local pack across a grid of points around it. Per-point rank, average rank, coverage, Share of Local Voice, top competitors and an HTML heatmap. No Google API key.",
        "version": "0.1",
        "x-build-id": "aBhM3WAhVmkrsP0UI"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fayoussef~geo-grid-local-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fayoussef-geo-grid-local-rank-tracker",
                "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/fayoussef~geo-grid-local-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-fayoussef-geo-grid-local-rank-tracker",
                "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/fayoussef~geo-grid-local-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-fayoussef-geo-grid-local-rank-tracker",
                "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": [
                    "businessName",
                    "keywords"
                ],
                "properties": {
                    "businessName": {
                        "title": "Business name",
                        "type": "string",
                        "description": "The business whose Google Maps rank you want to track, exactly as it appears on its Google profile. The actor finds this name in the local results at each grid point.\n\n⚡ Unlock the full grid and multiple keywords by subscribing to an [Apify plan](https://apify.com/pricing?fpr=youssef).\n💼 Need a custom solution? Reach out at youssefarhan24@gmail.com\n🌐 Got a site in mind? [Suggest it here](https://automationbyexperts.com/apify)"
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "The searches your customers type, e.g. `coffee shop`, `espresso bar near me`. Each keyword is checked at every grid point. Free plan uses the first keyword only.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location (city, address or area)",
                        "type": "string",
                        "description": "Centre of the grid, e.g. `San Francisco, CA` or a full street address. It is geocoded automatically. Leave empty only if you set the centre latitude/longitude below."
                    },
                    "gridSize": {
                        "title": "Grid size (N x N)",
                        "minimum": 1,
                        "maximum": 15,
                        "type": "integer",
                        "description": "How many points per side. 5 means a 5x5 = 25-point grid. Odd numbers keep the business at the centre point. Bigger grids = finer detail = more scans. Free plan is capped at 3x3.",
                        "default": 5
                    },
                    "radius": {
                        "title": "Grid radius",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Distance from the centre to the edge of the grid, in the unit below. 2-3 miles suits a city neighbourhood; use more for a whole metro.",
                        "default": 2
                    },
                    "distanceUnit": {
                        "title": "Distance unit",
                        "enum": [
                            "miles",
                            "km"
                        ],
                        "type": "string",
                        "description": "Unit for the grid radius and reported distances.",
                        "default": "miles"
                    },
                    "maxRank": {
                        "title": "Track ranks up to",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Positions beyond this are treated as \"not found\" at that point. Google's local finder returns up to 20 results per search.",
                        "default": 20
                    },
                    "placeId": {
                        "title": "Google place ID (optional)",
                        "type": "string",
                        "description": "For exact matching when the business name is generic or shared. Format like `0x89c25...:0x...`. If set, it is matched instead of the name."
                    },
                    "centerLat": {
                        "title": "Centre latitude (optional)",
                        "type": "number",
                        "description": "Set this and the longitude to skip geocoding and pin the grid centre precisely."
                    },
                    "centerLng": {
                        "title": "Centre longitude (optional)",
                        "type": "number",
                        "description": "Longitude of the grid centre. Used together with the latitude above."
                    },
                    "language": {
                        "title": "Language (hl)",
                        "type": "string",
                        "description": "Google interface language code, e.g. `en`, `fr`, `es`.",
                        "default": "en"
                    },
                    "countryCode": {
                        "title": "Country (gl)",
                        "type": "string",
                        "description": "Two-letter country code for the search region, e.g. `us`, `gb`, `ca`.",
                        "default": "us"
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Residential proxies are strongly recommended: Google Maps blocks datacenter IPs.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ]
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
