# Apple Maps Places Scraper (`automation-lab/apple-maps-places-scraper`) Actor

Export Apple Maps place search results with business names, categories, addresses, coordinates, phones, websites, and source URLs.

- **URL**: https://apify.com/automation-lab/apple-maps-places-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN 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

## Apple Maps Places Scraper

Scrape Apple Maps local search results and export clean place data for lead generation, market research, and local SEO workflows.

### What does Apple Maps Places Scraper do?

Apple Maps Places Scraper searches Apple Maps for public places and saves structured rows.

It can collect business names, categories, addresses, coordinates, phone numbers, websites, Apple Maps URLs, and Apple-specific identifiers.

Use it when you need Apple Maps data without manually copying entries from the map interface.

### Who is it for?

#### Local lead generation teams

Find businesses in a city or neighborhood and export contact-ready records.

#### SEO agencies

Audit local presence across Apple Maps alongside other map ecosystems.

#### Data enrichment teams

Add Apple Maps identifiers, coordinates, and public listing URLs to existing business databases.

#### Market researchers

Compare store density, categories, or business availability across locations.

#### Franchise and operations teams

Monitor nearby competitors or branch coverage from Apple Maps search results.

### Why use Apple Maps data?

Apple Maps is a major consumer discovery surface on iOS, macOS, CarPlay, and Siri.

Many teams already use Google Maps data but miss Apple Maps coverage.

Apple Maps can reveal different identifiers, categories, websites, or address formatting.

Using both sources helps validate local business records and reduce blind spots.

### What data can you extract?

| Field | Description |
| --- | --- |
| `name` | Apple Maps place name |
| `category` | Apple Maps point-of-interest category when available |
| `address` | Combined formatted address |
| `addressLines` | Original Apple Maps address lines |
| `street` | Street address |
| `city` | City or locality |
| `state` | State, province, or administrative area |
| `postalCode` | Postal code |
| `country` | Country name |
| `countryCode` | Two-letter country code |
| `latitude` | Place latitude |
| `longitude` | Place longitude |
| `phone` | Public phone number |
| `website` | Public website URL |
| `appleMapsUrl` | Apple Maps place URL |
| `appleMapsId` | Apple Maps result ID |
| `muid` | Apple Maps MUID identifier |
| `areasOfInterest` | Nearby Apple Maps areas of interest |
| `dependentLocalities` | Related neighborhoods or districts |
| `searchQuery` | Query used for the run |
| `location` | Location input used for the run |
| `sourceSearchUrl` | Apple Maps search URL |
| `scrapedAt` | ISO timestamp for the scrape |

### How much does it cost to scrape Apple Maps places?

The actor uses pay-per-event pricing.

You pay a small run-start event and a per-result event for each saved place.

| Charge | Free tier | Bronze | Silver | Gold | Platinum | Diamond |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Run started | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 | $0.005 |
| Apple Maps place saved | $0.000115 | $0.000100 | $0.000078 | $0.000060 | $0.000040 | $0.000028 |

Example cost estimates:

| Run size | Free tier estimate | Bronze estimate | What it is good for |
| --- | ---: | ---: | --- |
| 20 places | about $0.0073 | about $0.0070 | First query validation |
| 100 places | about $0.0165 | about $0.0150 | City/category sample |
| 1,000 places | about $0.1200 | about $0.1050 | Larger local lead list |

If your Apify account includes $5 in monthly free platform credits, one Apple Maps run could collect roughly 43,000 places at the Free tier price before those credits are used, assuming enough matching Apple Maps results are available.

Always start with a low `maxResults` value while validating your query.

Larger runs can collect more unique places by searching nearby map centers.

### How to use the actor

1. Open the actor on Apify.
2. Enter a `searchQuery`, such as `coffee`, `dentist`, or `EV charging`.
3. Enter a `location`, such as `New York, NY`.
4. Optionally provide exact latitude and longitude.
5. Set `maxResults`.
6. Click **Start**.
7. Download the dataset as JSON, CSV, Excel, XML, or HTML.

### Input options

#### `searchQuery`

The main Apple Maps keyword.

Examples:

- `coffee`
- `restaurants`
- `dentists`
- `gas stations`
- `EV charging`
- `hotels`

#### `location`

A city, neighborhood, or address used to center the search.

Examples:

- `New York, NY`
- `Austin, Texas`
- `Berlin, Germany`
- `Shibuya, Tokyo`

#### `latitude` and `longitude`

Use coordinates when you need an exact center point.

Coordinates override location geocoding.

#### `maxResults`

Controls how many unique rows are saved.

Apple Maps often returns about ten results per center point.

For larger limits, the actor queries nearby centers and deduplicates results.

#### `countryCode`

Two-letter country code used for localization and country limiting.

Examples: `US`, `GB`, `DE`, `FR`, `JP`.

#### `language`

Locale used for Apple Maps labels.

Examples: `en-US`, `en-GB`, `fr-FR`, `de-DE`, `ja-JP`.

### Example input

```json
{
  "searchQuery": "coffee",
  "location": "New York, NY",
  "latitude": 40.7128,
  "longitude": -74.006,
  "maxResults": 20,
  "countryCode": "US",
  "language": "en-US"
}
````

### Example output

```json
{
  "searchQuery": "coffee",
  "location": "New York, NY",
  "muid": "14322083455067953488",
  "name": "Variety Coffee",
  "category": "Cafe",
  "address": "140 Nassau St, New York, NY 10038, United States",
  "city": "New York",
  "state": "NY",
  "countryCode": "US",
  "latitude": 40.7112881,
  "longitude": -74.0062918,
  "phone": "+12122670207",
  "website": "https://varietycoffeeroasters.com",
  "appleMapsUrl": "https://maps.apple.com/place?q=Variety%20Coffee...",
  "scrapedAt": "2026-05-21T00:00:00.000Z"
}
```

### Tips for better Apple Maps scraping

Use specific categories for cleaner results.

Use exact coordinates for dense urban areas.

Start with `maxResults: 20` to inspect quality.

Increase `maxResults` after confirming the query and location.

Use country and language settings that match your target market.

Use Apple Maps URLs as stable source references in downstream systems.

### Integrations

#### CRM enrichment

Export CSV and import Apple Maps phone, website, and address fields into your CRM.

#### Local SEO audits

Compare Apple Maps names and addresses with your client database.

#### Market maps

Use latitude and longitude in BI tools to visualize place density.

#### Lead routing

Combine city, category, website, and phone fields for prospect assignment.

#### Data quality checks

Use Apple Maps IDs and URLs to validate duplicates in business datasets.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/apple-maps-places-scraper').call({
  searchQuery: 'coffee',
  location: 'New York, NY',
  maxResults: 20,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient('APIFY_TOKEN')
run = client.actor('automation-lab/apple-maps-places-scraper').call(run_input={
    'searchQuery': 'coffee',
    'location': 'New York, NY',
    'maxResults': 20,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~apple-maps-places-scraper/runs?token=APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"searchQuery":"coffee","location":"New York, NY","maxResults":20}'
```

### MCP usage

Use the Apify MCP server with this actor in Claude Code, Claude Desktop, or compatible MCP clients.

MCP URL:

```text
https://mcp.apify.com/?tools=automation-lab/apple-maps-places-scraper
```

Claude Code setup:

```bash
claude mcp add apify-apple-maps --transport http 'https://mcp.apify.com/?tools=automation-lab/apple-maps-places-scraper'
```

Claude Desktop JSON config:

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

Example prompts:

- Run Apple Maps Places Scraper for coffee shops in Brooklyn and summarize websites.
- Find 30 dentists near Austin and return a CSV-ready table.
- Compare Apple Maps categories for EV charging locations in Berlin.

### Reliability notes

The actor uses public Apple MapKit web endpoints discovered from Apple Maps pages.

No login is required.

The actor does not use residential proxies by default.

If Apple changes MapKit response fields, some optional columns may be empty until updated.

### Limitations

Apple Maps search may return fewer unique places than requested for narrow queries.

Ratings and reviews are not consistently present in the public search response used by this MVP.

Some results may be addresses or landmarks if advanced options include them.

Phone and website fields depend on what Apple Maps publicly returns.

### Legality

This actor extracts publicly available Apple Maps search data.

Use the data responsibly and comply with applicable laws, platform terms, and privacy rules.

Do not use scraped contact data for spam or unlawful outreach.

Respect opt-out requests in your downstream workflows.

### FAQ

#### Is this an official Apple product?

No. This is an independent Apify actor that extracts public Apple Maps web search results.

#### Does it require an Apple account?

No. The actor uses public Apple Maps web endpoints and does not require login.

### Troubleshooting

#### Why did I get fewer results than requested?

Apple Maps may not have enough matching places near the selected center, or the query may be too narrow.

Try a broader keyword or nearby coordinates.

#### Why are phone or website fields empty?

Apple Maps does not always publish those fields for every place.

The actor saves the fields when they are present in the public response.

#### Why did the location center differ from my text input?

When coordinates are not provided, the actor geocodes the location with Apple Maps and uses the first matching result.

For precision, provide latitude and longitude.

### Related scrapers

Explore related actors from automation-lab:

- https://apify.com/automation-lab/google-maps-scraper
- https://apify.com/automation-lab/google-search-results-scraper
- https://apify.com/automation-lab/business-leads-scraper
- https://apify.com/automation-lab/website-contact-scraper

### Changelog

#### 0.1

Initial Apple Maps Places Scraper build.

Includes Apple MapKit HTTP search, location geocoding, coordinate search, deduplication, and structured dataset output.

### Support

If a query stops working or output quality changes, open an Apify issue with the run URL and input.

Include the search query, location, and expected result count.

### Data freshness

Each run fetches live Apple Maps search data.

The actor does not cache place rows between runs.

Use `scrapedAt` to track when each record was collected.

### Output formats

Apify datasets can be downloaded as JSON, CSV, Excel, XML, RSS, and HTML.

CSV is useful for CRMs.

JSON is useful for pipelines and enrichment jobs.

Excel is useful for manual review.

### Performance

HTTP requests are lightweight and usually finish quickly for small inputs.

Dense locations and high limits may take longer because the actor queries multiple nearby centers.

Keep prefill limits low for first runs.

### Best practices

Use one clear category per run.

Run separate searches for different business types.

Keep country and language aligned.

Review sample rows before scaling.

Store Apple Maps URLs for traceability.

Deduplicate downstream using `muid` when available.

### Field mapping ideas

Map `name` to company name.

Map `website` to domain.

Map `phone` to business phone.

Map `latitude` and `longitude` to geospatial columns.

Map `appleMapsUrl` to source URL.

Map `muid` to external ID.

# Actor input Schema

## `searchQuery` (type: `string`):

Business type, brand, or place keyword to search on Apple Maps (for example: coffee, dentists, EV charging).

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

City, neighborhood, or address used to center the Apple Maps search when coordinates are not provided.

## `latitude` (type: `number`):

Optional latitude for exact search centering. If set, also provide longitude.

## `longitude` (type: `number`):

Optional longitude for exact search centering. If set, also provide latitude.

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

Maximum number of unique Apple Maps places to save. Higher values query nearby map centers to collect more unique places.

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

Two-letter country code used by Apple Maps localization and result limiting.

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

Apple Maps language/locale code for returned labels, such as en-US, fr-FR, or de-DE.

## `includeAddresses` (type: `boolean`):

Allow Apple Maps address results in addition to points of interest. Keep enabled for broad local searches.

## `includePhysicalFeatures` (type: `boolean`):

Include parks, landmarks, and other physical features when Apple Maps returns them for the query.

## `maxRequestRetries` (type: `integer`):

Number of retry attempts for failed Apple Maps API requests.

## Actor input object example

```json
{
  "searchQuery": "coffee",
  "location": "New York, NY",
  "latitude": 40.7128,
  "longitude": -74.006,
  "maxResults": 20,
  "countryCode": "US",
  "language": "en-US",
  "includeAddresses": true,
  "includePhysicalFeatures": false,
  "maxRequestRetries": 3
}
```

# 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 = {
    "searchQuery": "coffee",
    "location": "New York, NY",
    "latitude": 40.7128,
    "longitude": -74.006,
    "maxResults": 20,
    "countryCode": "US",
    "language": "en-US",
    "includeAddresses": true,
    "includePhysicalFeatures": false,
    "maxRequestRetries": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/apple-maps-places-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 = {
    "searchQuery": "coffee",
    "location": "New York, NY",
    "latitude": 40.7128,
    "longitude": -74.006,
    "maxResults": 20,
    "countryCode": "US",
    "language": "en-US",
    "includeAddresses": True,
    "includePhysicalFeatures": False,
    "maxRequestRetries": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/apple-maps-places-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 '{
  "searchQuery": "coffee",
  "location": "New York, NY",
  "latitude": 40.7128,
  "longitude": -74.006,
  "maxResults": 20,
  "countryCode": "US",
  "language": "en-US",
  "includeAddresses": true,
  "includePhysicalFeatures": false,
  "maxRequestRetries": 3
}' |
apify call automation-lab/apple-maps-places-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Apple Maps Places Scraper",
        "description": "Export Apple Maps place search results with business names, categories, addresses, coordinates, phones, websites, and source URLs.",
        "version": "0.1",
        "x-build-id": "FGTvO5jOAuh7SRpdq"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~apple-maps-places-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-apple-maps-places-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~apple-maps-places-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-apple-maps-places-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~apple-maps-places-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-apple-maps-places-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": [
                    "searchQuery"
                ],
                "properties": {
                    "searchQuery": {
                        "title": "🔎 Search query",
                        "type": "string",
                        "description": "Business type, brand, or place keyword to search on Apple Maps (for example: coffee, dentists, EV charging)."
                    },
                    "location": {
                        "title": "📍 Location",
                        "type": "string",
                        "description": "City, neighborhood, or address used to center the Apple Maps search when coordinates are not provided."
                    },
                    "latitude": {
                        "title": "Latitude",
                        "type": "number",
                        "description": "Optional latitude for exact search centering. If set, also provide longitude."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "type": "number",
                        "description": "Optional longitude for exact search centering. If set, also provide latitude."
                    },
                    "maxResults": {
                        "title": "Max places",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of unique Apple Maps places to save. Higher values query nearby map centers to collect more unique places.",
                        "default": 50
                    },
                    "countryCode": {
                        "title": "Country code",
                        "type": "string",
                        "description": "Two-letter country code used by Apple Maps localization and result limiting.",
                        "default": "US"
                    },
                    "language": {
                        "title": "Language",
                        "type": "string",
                        "description": "Apple Maps language/locale code for returned labels, such as en-US, fr-FR, or de-DE.",
                        "default": "en-US"
                    },
                    "includeAddresses": {
                        "title": "Include address matches",
                        "type": "boolean",
                        "description": "Allow Apple Maps address results in addition to points of interest. Keep enabled for broad local searches.",
                        "default": true
                    },
                    "includePhysicalFeatures": {
                        "title": "Include physical features",
                        "type": "boolean",
                        "description": "Include parks, landmarks, and other physical features when Apple Maps returns them for the query.",
                        "default": false
                    },
                    "maxRequestRetries": {
                        "title": "Max request retries",
                        "minimum": 0,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Number of retry attempts for failed Apple Maps API requests.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
