# McDonald's Store Locator Scraper (`datacach/mcdonalds-store-locator-scraper`) Actor

Extracts McDonald's US restaurant locations by coordinates, returning store page URLs, addresses, and city/state data.

- **URL**: https://apify.com/datacach/mcdonalds-store-locator-scraper.md
- **Developed by:** [DataCach](https://apify.com/datacach) (community)
- **Categories:** Developer tools, Other, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.60 / 1,000 links

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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

## McDonald's Store Locator Scraper

**Extract McDonald's store locations** in bulk — no CAPTCHA-solving, no manual searching, just clean store page URLs ready to export as **JSON, CSV, or Excel**.

### What is McDonald's Store Locator Scraper?

McDonald's Store Locator Scraper is an [Apify Actor](https://apify.com) that **extracts McDonald's US restaurant locations** by searching around any set of geographic coordinates. Give it one or more `{ latitude, longitude }` points and it returns every restaurant's **store page URL** within a 100-mile radius of each point — sourced directly from McDonald's own systems and deduplicated across all your search points.

It's built for anyone who needs a **bulk, structured list of McDonald's store links** — market researchers, competitor-location analysts, local-SEO tools, or data pipelines that feed a follow-up scraper (see [McDonald's-related Actors](#mcdonalds-related-actors) below for pairing it with a store-detail extractor).

### What can McDonald's Store Locator Scraper do?

- 📍 **Search by coordinates** — pass any number of `{ name, latitude, longitude }` points; each returns every McDonald's within a 100-mile radius
- 🔗 **Collect store page URLs** — the exact link McDonald's uses for each restaurant's location page
- 🧹 **Automatic deduplication** — the same store found near two different coordinates is only saved once
- ⏱️ **Extraction timestamps** — every result is stamped with the UTC datetime it was collected
- ⏸️ **Resumable runs** — if a run is migrated or restarted mid-crawl, already-collected links are never re-saved or double-charged
- ⏭️ **Pagination controls** — `Start index` and `Exclude already-collected links` let you continue a previous run without re-paying for results you already have
- 🚦 **Result limits** — cap the total number of links collected with `Max results`
- 🌐 **Full Apify platform integration** — run on a [schedule](https://docs.apify.com/platform/schedules), trigger via [API](https://docs.apify.com/api/v2) or [webhooks](https://docs.apify.com/platform/integrations/webhooks), connect to [Zapier, Make, and other integrations](https://apify.com/integrations), monitor runs from the Apify Console, and export results in **JSON, CSV, Excel, HTML, or XML**

### What data does McDonald's Store Locator Scraper extract?

| Field | Description | Example |
|---|---|---|
| `url` | McDonald's store page URL | `https://www.mcdonalds.com/us/en-us/location/ny/new-york/160-broadway/10528.html` |
| `coordinate` | The search coordinate this store was found near | `New York, NY` |
| `extraction_datetime` | UTC timestamp when the link was extracted (ISO 8601) | `2026-07-23T23:31:22.514887+00:00` |
| `extraction_date` | Extraction date in `mm-dd-yyyy` format | `07-23-2026` |

### How do I use McDonald's Store Locator Scraper to find McDonald's locations?

1. Click **Try for free** or open the Actor's **Input** tab in Apify Console.
2. Keep the default sample coordinates (New York, Los Angeles, Chicago) to try it instantly, or replace `coordinates` with the points you want to search — city centers, zip-code centroids, or a grid across a region.
3. Optionally set `Max results` to cap how many links are collected.
4. Click **Start** and wait for the run to finish.
5. Open the **Output** tab and download your results as JSON, CSV, Excel, or another supported format.

<!-- TODO: embed a demo GIF or YouTube walkthrough of a run here -->

### Free vs Premium: what's the difference?

McDonald's Store Locator Scraper works out of the box on Apify's free usage tier, with a few limits designed to let you try it before scaling up. Upgrade to a paid Apify plan to remove them:

| Feature | Free plan | Premium (paid plan) |
|---|---|---|
| Coordinates per run | 1 | Unlimited |
| Store links per run | Up to 10 | Unlimited (set your own `Max results`) |
| `Start index` (skip-ahead pagination) | Not available — always starts from result 1 | Full support |
| `Exclude already-collected links` | Up to 1 URL | Unlimited |

In short: the free plan is great for testing the Actor and pulling a handful of links; a paid plan is what you need for full-city, multi-state, or nationwide coverage and for reliably paginating large result sets across multiple runs.

### Input

![Input example](https://raw.githubusercontent.com/BenjaminFloresV/public-datacach-apify-actors-media/main/mcdonalds-store-locator-scraper/input-example.png)

McDonald's Store Locator Scraper accepts a simple JSON input with four optional fields:

- **Search Coordinates** (`coordinates`) — an array of `{ name, latitude, longitude }` points to search around. Defaults to three sample US cities if left empty.
- **Max results** (`maxResults`) — the maximum number of unique store links to collect across all coordinates combined. `0` means unlimited.
- **Start index** (`startIndex`) — skip this many results from the start before saving, useful for continuing a previous run without paying for links you already have. Does not speed up the run — it only changes what gets saved.
- **Exclude Already-Collected Links** (`excludeUrls`) — a list of store URLs you already have; they're never saved again regardless of discovery order.

### Output example

Each dataset item is one store link:

```json
{
    "url": "https://www.mcdonalds.com/us/en-us/location/ny/new-york/160-broadway/10528.html",
    "coordinate": "New York, NY",
    "extraction_datetime": "2026-07-23T23:31:22.514887+00:00",
    "extraction_date": "07-23-2026"
}
````

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel — directly from the Apify Console, or via the [Dataset API](https://docs.apify.com/api/v2#/reference/datasets).

### Use cases

- **Competitor location mapping** — build a list of every McDonald's in a metro area or state for retail site-selection analysis.
- **Local SEO and directory tools** — feed a directory site or map overlay with up-to-date McDonald's store pages.
- **Lead lists for franchise/vendor outreach** — generate a bulk list of store URLs to cross-reference against other datasets.
- **Data pipeline input** — pair the URLs with a store-detail scraper to build a full database of addresses, phone numbers, and hours (see below).
- **Market research** — measure McDonald's restaurant density around specific coordinates, such as competitor locations or demographic centers.

### McDonald's-related Actors

| Actor | What it does |
|---|---|
| [McDonald's Store Details Scraper](https://apify.com/datacach/mcdonalds-store-details-scraper) *(companion Actor)* | Takes the store page links from this Actor and extracts full details — address, phone number, geolocation, and hours |

### FAQ

#### Is it legal to scrape McDonald's store locations?

This Actor only collects **publicly available data** — the same store location information anyone can find on McDonald's own website, no login and no private data involved. Scraping publicly accessible data is generally permissible, but you're responsible for complying with McDonald's [Terms of Service](https://www.mcdonalds.com/us/en-us/terms-and-conditions.html) and any applicable laws in your jurisdiction. Consult a legal professional if you plan to use the data commercially.

#### What happens if the run gets blocked or interrupted?

If McDonald's anti-bot protection blocks a request for a given coordinate, that coordinate is logged and skipped so the run continues with the rest. If the run itself is migrated or restarted by the Apify platform mid-crawl, already-collected links are never re-saved — the Actor resumes exactly where it left off.

#### How do I avoid re-collecting links I already have?

Use **Start index** to skip a fixed number of results from the start (fastest to set up, order-dependent), or **Exclude already-collected links** to list specific URLs that should never be saved again regardless of order (more robust across runs).

#### Can I run this on a schedule or trigger it from my own app?

Yes — like any Apify Actor, you can run it on a [recurring schedule](https://docs.apify.com/platform/schedules), trigger it via the [Apify API](https://docs.apify.com/api/v2), or connect it to [Zapier, Make, and other integrations](https://apify.com/integrations).

### Support

Found a bug or have a feature request? Open an issue on the Actor's **Issues** tab in Apify Console. Need a custom scraping solution or a modified version of this Actor? Reach out — custom development is available.

# Actor input Schema

## `coordinates` (type: `array`):

Points to search around. Each item needs a <code>latitude</code> and <code>longitude</code>, plus an optional <code>name</code> label, e.g. <code>{"name": "New York, NY", "latitude": 40.7128, "longitude": -74.006}</code>. The locator returns every McDonald's within a 100-mile radius of each point, deduplicated across all points. Free plan uses only the first coordinate.

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

Maximum number of unique store links to collect, across all coordinates combined. Set to <code>0</code> to collect every link found. Free plan always stops at 10 links regardless of this value.

## `startIndex` (type: `integer`):

Skip this many store links from the start before saving any — useful for paginating across separate runs (e.g. already have the first 500? Set <b>500</b> to resume from link 501 and avoid paying for links you already have). Links are discovered in the order the McDonald's locator API returns them for each coordinate, which is typically stable but not guaranteed by McDonald's — for a guaranteed-safe alternative use <b>Exclude already-collected links</b> instead. This does <b>not</b> speed up the run: every link up to this point is still crawled, only skipped from saving. Combined with <b>Max results</b>, the saved range is \[Start index, Start index + Max results). Ignored (always treated as 0) on the free plan.

## `excludeUrls` (type: `array`):

Store page URLs you already have. Any link listed here is never saved again, no matter where it falls in the discovery order — unlike <b>Start index</b>, this works even if the locator API's response order shifts between runs. Applied after Start index. Free plan runs accept at most 1 URL here.

## Actor input object example

```json
{
  "coordinates": [
    {
      "name": "New York, NY",
      "latitude": 40.7128,
      "longitude": -74.006
    },
    {
      "name": "Los Angeles, CA",
      "latitude": 34.0522,
      "longitude": -118.2437
    },
    {
      "name": "Chicago, IL",
      "latitude": 41.8781,
      "longitude": -87.6298
    }
  ],
  "maxResults": 20,
  "startIndex": 0,
  "excludeUrls": []
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "coordinates": [
        {
            "name": "New York, NY",
            "latitude": 40.7128,
            "longitude": -74.006
        },
        {
            "name": "Los Angeles, CA",
            "latitude": 34.0522,
            "longitude": -118.2437
        },
        {
            "name": "Chicago, IL",
            "latitude": 41.8781,
            "longitude": -87.6298
        }
    ],
    "maxResults": 20,
    "excludeUrls": []
};

// Run the Actor and wait for it to finish
const run = await client.actor("datacach/mcdonalds-store-locator-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 = {
    "coordinates": [
        {
            "name": "New York, NY",
            "latitude": 40.7128,
            "longitude": -74.006,
        },
        {
            "name": "Los Angeles, CA",
            "latitude": 34.0522,
            "longitude": -118.2437,
        },
        {
            "name": "Chicago, IL",
            "latitude": 41.8781,
            "longitude": -87.6298,
        },
    ],
    "maxResults": 20,
    "excludeUrls": [],
}

# Run the Actor and wait for it to finish
run = client.actor("datacach/mcdonalds-store-locator-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 '{
  "coordinates": [
    {
      "name": "New York, NY",
      "latitude": 40.7128,
      "longitude": -74.006
    },
    {
      "name": "Los Angeles, CA",
      "latitude": 34.0522,
      "longitude": -118.2437
    },
    {
      "name": "Chicago, IL",
      "latitude": 41.8781,
      "longitude": -87.6298
    }
  ],
  "maxResults": 20,
  "excludeUrls": []
}' |
apify call datacach/mcdonalds-store-locator-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "McDonald's Store Locator Scraper",
        "description": "Extracts McDonald's US restaurant locations by coordinates, returning store page URLs, addresses, and city/state data.",
        "version": "0.0",
        "x-build-id": "taLSXZZRL8PlhIJJa"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/datacach~mcdonalds-store-locator-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-datacach-mcdonalds-store-locator-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/datacach~mcdonalds-store-locator-scraper/runs": {
            "post": {
                "operationId": "runs-sync-datacach-mcdonalds-store-locator-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/datacach~mcdonalds-store-locator-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-datacach-mcdonalds-store-locator-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",
                "properties": {
                    "coordinates": {
                        "title": "Search Coordinates",
                        "type": "array",
                        "description": "Points to search around. Each item needs a <code>latitude</code> and <code>longitude</code>, plus an optional <code>name</code> label, e.g. <code>{\"name\": \"New York, NY\", \"latitude\": 40.7128, \"longitude\": -74.006}</code>. The locator returns every McDonald's within a 100-mile radius of each point, deduplicated across all points. Free plan uses only the first coordinate.",
                        "default": [
                            {
                                "name": "New York, NY",
                                "latitude": 40.7128,
                                "longitude": -74.006
                            },
                            {
                                "name": "Los Angeles, CA",
                                "latitude": 34.0522,
                                "longitude": -118.2437
                            },
                            {
                                "name": "Chicago, IL",
                                "latitude": 41.8781,
                                "longitude": -87.6298
                            }
                        ]
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of unique store links to collect, across all coordinates combined. Set to <code>0</code> to collect every link found. Free plan always stops at 10 links regardless of this value.",
                        "default": 0
                    },
                    "startIndex": {
                        "title": "Start index",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Skip this many store links from the start before saving any — useful for paginating across separate runs (e.g. already have the first 500? Set <b>500</b> to resume from link 501 and avoid paying for links you already have). Links are discovered in the order the McDonald's locator API returns them for each coordinate, which is typically stable but not guaranteed by McDonald's — for a guaranteed-safe alternative use <b>Exclude already-collected links</b> instead. This does <b>not</b> speed up the run: every link up to this point is still crawled, only skipped from saving. Combined with <b>Max results</b>, the saved range is [Start index, Start index + Max results). Ignored (always treated as 0) on the free plan.",
                        "default": 0
                    },
                    "excludeUrls": {
                        "title": "Exclude Already-Collected Links",
                        "type": "array",
                        "description": "Store page URLs you already have. Any link listed here is never saved again, no matter where it falls in the discovery order — unlike <b>Start index</b>, this works even if the locator API's response order shifts between runs. Applied after Start index. Free plan runs accept at most 1 URL here.",
                        "default": [],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```