# Google Maps Directions Scraper (`automation-lab/google-maps-directions-scraper`) Actor

Extract public Google Maps route estimates, distances, durations, route labels, warnings, toll flags, and source URLs for origin/destination pairs.

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

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## Google Maps Directions Scraper

Extract public Google Maps route estimates for origin-destination pairs and export clean route-option datasets.

### What does Google Maps Directions Scraper do?

Google Maps Directions Scraper converts public Google Maps directions pages into structured route-option records.

Give the actor one route or a batch of routes.

It returns route labels, distance, duration, warnings, toll indicators, ferry indicators, locale, country bias, source URLs, and scrape timestamps.

Use it when you need repeatable route-estimate collection from public Google Maps pages.

It is not an official Google Directions API replacement.

It does not use private accounts, saved places, or restricted Google data.

### Who is it for?

#### Logistics and delivery teams

Use the actor to compare common lanes, estimate trip duration, and monitor public route alternatives.

#### Local service businesses

Use it to estimate travel time between a depot and customer neighborhoods.

#### Marketplaces and field operations teams

Use it to enrich origin-destination pairs before assigning jobs, territories, or service zones.

#### Travel and mobility analysts

Use it to collect public route estimates for research, benchmarking, and reporting workflows.

#### Data teams

Use it to turn route lookups into JSON, CSV, Excel, API, or warehouse-ready records.

### Why use this route extractor?

Manual Google Maps checks are slow when you have dozens or hundreds of route pairs.

This actor processes route rows consistently and emits typed fields.

You can sort by duration, join by origin and destination, calculate distance bands, and audit the exact Google Maps URL used.

The output is built for spreadsheets and automation, not screenshots.

### What data can you extract?

Each dataset row represents one route option, not one turn-by-turn instruction.

Typical fields include:

- origin
- destination
- travelMode
- routeOptionIndex
- routeLabel
- distanceText
- distanceMeters
- durationText
- durationSeconds
- warnings
- hasTolls
- hasFerries
- locale
- country
- routeUrl
- previewUrl
- scrapedAt

### How much does it cost to scrape Google Maps directions?

The actor uses pay-per-event pricing.

There is a small start event and a per-route-option event.

Your final run cost depends on how many route options are saved.

| Example workload | Typical saved route-option rows | Cost driver |
| --- | ---: | --- |
| 1 origin-destination pair with 3 options | 1-3 rows | start + route-option events |
| 25 city pairs with up to 3 options | up to 75 rows | route-option events |
| 100 delivery lanes with up to 2 options | up to 200 rows | route-option events |

Start with a small validation run.

Then scale after you confirm that route labels and units match your workflow.

### How to use it

1. Open the actor on Apify.

2. Add route rows with `origin` and `destination`.

3. Choose the default travel mode.

4. Set `locale` and `country` to reduce ambiguity.

5. Set `maxRouteOptionsPerPair` to the number of alternatives you need.

6. Run the actor.

7. Download the dataset as JSON, CSV, Excel, XML, or RSS.

8. Connect the dataset to your workflow with the Apify API if needed.

### Input fields

`routes` is the main batch input.

Each route can include:

- `origin` — address, place name, city, landmark, or coordinate pair
- `destination` — address, place name, city, landmark, or coordinate pair
- `mode` — `driving`, `walking`, `transit`, or `bicycling`
- `locale` — language code for labels, such as `en`
- `country` — country bias, such as `us`, `gb`, or `fr`

You can also use the simple `origin` and `destination` fields for one route.

`maxRouteOptionsPerPair` controls how many alternatives are saved for each pair.

`requestDelayMs` adds a delay between route lookups for conservative runs.

### Example input

```json
{
  "routes": [
    { "origin": "New York, NY", "destination": "Boston, MA", "mode": "driving" },
    { "origin": "Philadelphia, PA", "destination": "Washington, DC", "mode": "driving" },
    { "origin": "San Francisco, CA", "destination": "San Jose, CA", "mode": "driving" }
  ],
  "locale": "en",
  "country": "us",
  "maxRouteOptionsPerPair": 3,
  "requestDelayMs": 500
}
````

### Output table

The default dataset view is optimized for comparing route options.

Use `routeOptionIndex` to rank alternatives for each pair.

Use `distanceMeters` and `durationSeconds` for calculations.

Use `distanceText` and `durationText` for human-readable reports.

Use `warnings`, `hasTolls`, and `hasFerries` to identify caveats.

### Output example

```json
{
  "origin": "Chicago, IL",
  "destination": "Milwaukee, WI",
  "travelMode": "driving",
  "routeOptionIndex": 1,
  "routeLabel": "I-94 W",
  "distanceText": "91.4 miles",
  "distanceMeters": 147047,
  "durationText": "1 hr 30 min",
  "durationSeconds": 5383,
  "warnings": ["This route has tolls."],
  "hasTolls": true,
  "hasFerries": false,
  "locale": "en",
  "country": "us",
  "routeUrl": "https://www.google.com/maps/dir/?api=1...",
  "previewUrl": "https://www.google.com/maps/preview/directions?...",
  "scrapedAt": "2026-06-27T13:30:36.967Z"
}
```

### Tips for accurate results

Use clear place names.

Prefer full addresses or city-state combinations for ambiguous locations.

Use coordinates for operational locations that must be exact.

Set `country` to bias ambiguous places.

Set `locale` to control readable labels.

Review a sample dataset before automating decisions.

Remember that public route estimates can change with time, traffic, road closures, and Google Maps availability.

### Route-option quality notes

The actor filters out turn-by-turn instruction steps.

Saved rows are intended to represent route alternatives such as `I-94 W`, `I-30 W`, or `I-5 S`.

If Google Maps returns fewer alternatives than requested, the actor saves only the valid alternatives found.

If a route cannot be extracted, the actor logs a warning and continues with the next pair.

### Integrations

Send output to Google Sheets for route comparison tables.

Send output to Airtable for operations databases.

Use Make, Zapier, or n8n to trigger downstream tasks when a run finishes.

Load JSON into a data warehouse for lane analysis.

Connect the dataset to BI dashboards for distance and duration summaries.

Call the actor from a dispatch planning script before assigning jobs.

### API usage

Call `automation-lab/google-maps-directions-scraper` with the Apify API.

Node.js:

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });

const run = await client.actor('automation-lab/google-maps-directions-scraper').call({
  routes: [
    { origin: 'New York, NY', destination: 'Boston, MA', mode: 'driving' }
  ],
  maxRouteOptionsPerPair: 3
});

console.log(run.defaultDatasetId);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_APIFY_TOKEN')

run = client.actor('automation-lab/google-maps-directions-scraper').call(run_input={
    'routes': [
        {'origin': 'New York, NY', 'destination': 'Boston, MA', 'mode': 'driving'}
    ],
    'maxRouteOptionsPerPair': 3,
})

print(run['defaultDatasetId'])
```

cURL:

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~google-maps-directions-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"routes":[{"origin":"New York, NY","destination":"Boston, MA","mode":"driving"}],"maxRouteOptionsPerPair":3}'
```

### MCP usage

Use the Apify MCP server with this actor-specific tool URL:

`https://mcp.apify.com/?tools=automation-lab/google-maps-directions-scraper`

Claude Code setup:

```bash
claude mcp add apify-google-maps-directions --url "https://mcp.apify.com/?tools=automation-lab/google-maps-directions-scraper"
```

Claude Desktop config:

```json
{
  "mcpServers": {
    "apify-google-maps-directions": {
      "url": "https://mcp.apify.com/?tools=automation-lab/google-maps-directions-scraper"
    }
  }
}
```

Example prompts:

- "Extract driving route estimates for these city pairs."
- "Compare Google Maps route durations for this list of delivery lanes."
- "Create a CSV of distance and duration fields for these store-to-city routes."

### Common workflows

#### Delivery lane comparison

Upload city or depot pairs and compare the fastest visible public route options.

#### Territory planning

Estimate travel time from a hub to many service areas.

#### Periodic route monitoring

Schedule the actor and compare duration values over time.

#### Spreadsheet enrichment

Start with CSV route rows and export distance and duration fields back to a spreadsheet.

### Limitations

Google Maps is dynamic and can change page payloads.

The actor extracts public route estimates from public directions flows.

It does not guarantee the same result as the official Google Directions API.

It does not provide route geometry, full navigation instructions, traffic models, or private account data.

Results can vary by time, locale, country bias, and Google Maps availability.

### Legality

Use this actor only for lawful workflows.

Respect Google Maps terms and applicable rules.

Do not use it to overload services, bypass access restrictions, or collect data you are not allowed to process.

Keep batch sizes reasonable and add delays for recurring workflows.

### Troubleshooting

#### A route returns no options

Check spelling and place ambiguity.

Try adding state, country, postal code, or coordinates.

Lower `maxRouteOptionsPerPair` if you only need the primary route.

#### Labels look different from expected

Check `locale` and `country`.

Google Maps may localize road names and route labels.

#### Runs are slower than expected

Increase batch size gradually.

Keep `requestDelayMs` conservative for public-page access.

#### I need official API guarantees

Use the official Google Maps Platform APIs for contractual API behavior.

Use this actor for public-page route-estimate extraction workflows.

### Related scrapers

For place leads, use `https://apify.com/automation-lab/google-maps-leads-scraper` when available.

For reviews, use a dedicated Google Maps reviews actor.

For places data, use a Google Maps places scraper.

Use this actor when the primary entity is a route option between an origin and destination.

### FAQ

#### Is this the official Directions API?

No. It extracts route estimates from public Google Maps directions pages.

#### Does it return turn-by-turn steps?

No. The dataset is designed for route alternatives, not navigation instructions.

#### Can I scrape many rows?

Yes. Start with a small validation run, then scale conservatively.

#### Does it return live traffic?

It returns duration values visible in the public payload when available. Treat them as public estimates, not guaranteed traffic measurements.

#### Can I use coordinates?

Yes. Coordinates can reduce ambiguity for operational locations.

### Data quality checklist

Before using output in production, verify:

- origin and destination strings are unambiguous
- route labels are route alternatives
- distance units match your expectations
- duration values fit the route context
- warning and toll fields are reasonable
- scrape time is suitable for your analysis

### Changelog

Version 0.1 focuses on public route-option extraction for origin-destination rows.

It includes route labels, distances, durations, warnings, toll/ferry flags, locale, country bias, and source URLs.

### Support

If output looks wrong, save the run ID and a small input sample.

Include the origin, destination, mode, locale, country, and the row that looked incorrect.

That information makes route-payload changes easier to diagnose.

# Actor input Schema

## `routes` (type: `array`):

Rows to check. Each row needs an origin and destination; optional row-level mode, locale, and country override the defaults.

## `mode` (type: `string`):

Used when a row does not include its own mode.

## `locale` (type: `string`):

Language code used in Google Maps requests.

## `country` (type: `string`):

Country bias used in Google Maps requests.

## `maxRouteOptionsPerPair` (type: `integer`):

Limits alternate routes saved for each origin/destination pair.

## `requestDelayMs` (type: `integer`):

Conservative delay between Google Maps requests.

## Actor input object example

```json
{
  "routes": [
    {
      "origin": "New York, NY",
      "destination": "Boston, MA",
      "mode": "driving"
    },
    {
      "origin": "San Francisco, CA",
      "destination": "San Jose, CA",
      "mode": "driving"
    }
  ],
  "mode": "driving",
  "locale": "en",
  "country": "us",
  "maxRouteOptionsPerPair": 3,
  "requestDelayMs": 750
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "routes": [
        {
            "origin": "New York, NY",
            "destination": "Boston, MA",
            "mode": "driving"
        },
        {
            "origin": "San Francisco, CA",
            "destination": "San Jose, CA",
            "mode": "driving"
        }
    ],
    "mode": "driving",
    "locale": "en",
    "country": "us",
    "maxRouteOptionsPerPair": 3,
    "requestDelayMs": 750
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/google-maps-directions-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 = {
    "routes": [
        {
            "origin": "New York, NY",
            "destination": "Boston, MA",
            "mode": "driving",
        },
        {
            "origin": "San Francisco, CA",
            "destination": "San Jose, CA",
            "mode": "driving",
        },
    ],
    "mode": "driving",
    "locale": "en",
    "country": "us",
    "maxRouteOptionsPerPair": 3,
    "requestDelayMs": 750,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/google-maps-directions-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 '{
  "routes": [
    {
      "origin": "New York, NY",
      "destination": "Boston, MA",
      "mode": "driving"
    },
    {
      "origin": "San Francisco, CA",
      "destination": "San Jose, CA",
      "mode": "driving"
    }
  ],
  "mode": "driving",
  "locale": "en",
  "country": "us",
  "maxRouteOptionsPerPair": 3,
  "requestDelayMs": 750
}' |
apify call automation-lab/google-maps-directions-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Directions Scraper",
        "description": "Extract public Google Maps route estimates, distances, durations, route labels, warnings, toll flags, and source URLs for origin/destination pairs.",
        "version": "0.1",
        "x-build-id": "btPCdavsyG7DcmpAY"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~google-maps-directions-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-google-maps-directions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/automation-lab~google-maps-directions-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-google-maps-directions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/automation-lab~google-maps-directions-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-google-maps-directions-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "routes"
                ],
                "properties": {
                    "routes": {
                        "title": "Origin/destination rows",
                        "type": "array",
                        "description": "Rows to check. Each row needs an origin and destination; optional row-level mode, locale, and country override the defaults.",
                        "items": {
                            "type": "object",
                            "required": [
                                "origin",
                                "destination"
                            ],
                            "properties": {
                                "origin": {
                                    "type": "string",
                                    "title": "Origin",
                                    "description": "Starting address, city, place name, or coordinates.",
                                    "editor": "textfield"
                                },
                                "destination": {
                                    "type": "string",
                                    "title": "Destination",
                                    "description": "Ending address, city, place name, or coordinates.",
                                    "editor": "textfield"
                                },
                                "mode": {
                                    "type": "string",
                                    "title": "Travel mode",
                                    "description": "Travel mode for this specific route row.",
                                    "editor": "select",
                                    "enum": [
                                        "driving",
                                        "walking",
                                        "transit",
                                        "bicycling"
                                    ]
                                },
                                "locale": {
                                    "type": "string",
                                    "title": "Locale",
                                    "description": "Language code for Google Maps labels, e.g. en, de, es.",
                                    "editor": "textfield"
                                },
                                "country": {
                                    "type": "string",
                                    "title": "Country",
                                    "description": "Google Maps country bias, e.g. us, gb, de.",
                                    "editor": "textfield"
                                }
                            }
                        }
                    },
                    "mode": {
                        "title": "Default travel mode",
                        "enum": [
                            "driving",
                            "walking",
                            "transit",
                            "bicycling"
                        ],
                        "type": "string",
                        "description": "Used when a row does not include its own mode.",
                        "default": "driving"
                    },
                    "locale": {
                        "title": "Default locale",
                        "type": "string",
                        "description": "Language code used in Google Maps requests.",
                        "default": "en"
                    },
                    "country": {
                        "title": "Default country",
                        "type": "string",
                        "description": "Country bias used in Google Maps requests.",
                        "default": "us"
                    },
                    "maxRouteOptionsPerPair": {
                        "title": "Maximum route options per pair",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Limits alternate routes saved for each origin/destination pair.",
                        "default": 3
                    },
                    "requestDelayMs": {
                        "title": "Delay between pairs (ms)",
                        "minimum": 0,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Conservative delay between Google Maps requests.",
                        "default": 750
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```