# Photon Geocoder Scraper (`parseforge/photon-geocoder-scraper`) Actor

Resolve any place name or address into precise coordinates with Photon by komoot on OpenStreetMap, and reverse lookup coordinates into the nearest place. Returns latitude, longitude, street, postcode, city, country, and a map link. Handy for logistics, lead enrichment, and mapping apps.

- **URL**: https://apify.com/parseforge/photon-geocoder-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Developer tools, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🌍 Photon Geocoder Scraper

> 🚀 **Turn place names into coordinates and coordinates into addresses in one run.** Powered by Photon by komoot on top of OpenStreetMap, with no API key required.

> 🕒 **Last updated:** 2026-06-04 · **📊 25 fields** per record · Global coverage · Forward and reverse geocoding

Photon Geocoder Scraper takes any text query such as "Brandenburg Gate, Berlin" and returns ranked matching locations with latitude, longitude, full address parts, OSM identifiers, and a ready map link. It also works in reverse, turning a latitude and longitude pair into the nearest named place or address.

Coverage is worldwide because Photon indexes the global OpenStreetMap dataset. You can geocode landmarks, streets, house numbers, cities, regions, and countries, and read back structured fields like postcode, district, county, state, country, and country code whenever the underlying OSM object provides them.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Data engineers and analysts | Enrich address lists with coordinates |
| Logistics and delivery teams | Validate and standardize delivery points |
| Travel and mapping builders | Power search boxes and place autocomplete |
| Marketers and sales ops | Geocode leads for territory planning |
| Researchers and journalists | Map locations from open data |

### 📋 What the Photon Geocoder Scraper does

- Forward geocoding: text query to one or more matching locations with coordinates.
- Reverse geocoding: a latitude and longitude pair to the nearest place or address.
- Returns clean structured address parts: name, street, house number, postcode, locality, district, city, county, state, country, and country code.
- Adds a composed `displayName`, an OpenStreetMap `mapUrl`, the bounding box `extent`, and the raw OSM identifiers `osmId` and `osmType`.
- Auto-detects mode from your input, so you never pick a mode manually.
- Language preference for result names where translations exist.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Key | Type | Description |
|---|---|---|---|
| Search Query | `query` | string | Place name or address for forward geocoding. |
| Result Language | `language` | string | Preferred name language. One of en, de, fr, it, es. |
| Latitude | `latitude` | string | Latitude for reverse geocoding. |
| Longitude | `longitude` | string | Longitude for reverse geocoding. |
| Max Items | `maxItems` | integer | Maximum locations returned. Free plan caps at 10. |

Forward geocoding example:

```json
{
    "query": "Brandenburg Gate, Berlin",
    "language": "en",
    "maxItems": 10
}
````

Reverse geocoding example:

```json
{
    "latitude": "52.5162699",
    "longitude": "13.3777034",
    "language": "en",
    "maxItems": 5
}
```

> ⚠️ **Good to Know:** Provide a Search Query for forward mode, or both Latitude and Longitude for reverse mode. If a query and coordinates are both present, forward geocoding takes priority. Address parts such as house number, postcode, or state appear only when the matched OpenStreetMap object actually carries them, so a city result will not include a house number while a building result will.

### 📊 Output

Each record includes the following fields.

| Field | Key | Description |
|---|---|---|
| 🧭 Query Mode | `queryMode` | "forward" or "reverse". |
| 🔎 Query | `query` | The query or coordinate pair you sent. |
| 📍 Display Name | `displayName` | Readable composed address line. |
| 🏷 Name | `name` | Primary place or feature name. |
| 🧭 Latitude | `latitude` | Latitude of the location. |
| 🧭 Longitude | `longitude` | Longitude of the location. |
| 🗂 Category | `category` | OSM key, for example place or tourism. |
| 🗂 Category Detail | `categoryDetail` | OSM value, for example city or attraction. |
| 🏷 Type | `type` | Photon result type, for example house or city. |
| 🏠 House Number | `houseNumber` | Street number when available. |
| 🛣 Street | `street` | Street name when available. |
| ✉️ Postcode | `postcode` | Postal code when available. |
| 🏘 Locality | `locality` | Locality or neighborhood when available. |
| 🗺 District | `district` | District when available. |
| 🏙 City | `city` | City when available. |
| 🗺 County | `county` | County when available. |
| 🗺 State | `state` | State or region when available. |
| 🌍 Country | `country` | Country name when available. |
| 🌐 Country Code | `countryCode` | Two letter country code when available. |
| 🆔 OSM ID | `osmId` | OpenStreetMap object identifier. |
| 🔠 OSM Type | `osmType` | OpenStreetMap object type, N, W, or R. |
| 📐 Extent | `extent` | Bounding box as four coordinates when available. |
| 🔗 Map URL | `mapUrl` | OpenStreetMap link centered on the location. |
| 🕒 Scraped At | `scrapedAt` | Timestamp of the run. |
| ❌ Error | `error` | Null on success, a message on failure. |

Real sample records from a live run:

```json
{
    "queryMode": "forward",
    "query": "Pariser Platz 1, Berlin",
    "displayName": "Brandenburg Gate Pariser Platz 1, 10117, Berlin, Mitte, Germany",
    "name": "Brandenburg Gate",
    "latitude": 52.5162699,
    "longitude": 13.3777034,
    "category": "tourism",
    "categoryDetail": "attraction",
    "type": "house",
    "houseNumber": "1",
    "street": "Pariser Platz",
    "postcode": "10117",
    "locality": "Friedrich-Wilhelm-Stadt",
    "district": "Mitte",
    "city": "Berlin",
    "county": null,
    "state": null,
    "country": "Germany",
    "countryCode": "DE",
    "osmId": 518071791,
    "osmType": "W",
    "extent": [13.3775798, 52.5164328, 13.3778251, 52.516117],
    "mapUrl": "https://www.openstreetmap.org/?mlat=52.5162699&mlon=13.3777034#map=17/52.5162699/13.3777034",
    "scrapedAt": "2026-06-04T19:34:49.669Z",
    "error": null
}
```

```json
{
    "queryMode": "forward",
    "query": "Berlin",
    "displayName": "Berlin, Germany",
    "name": "Berlin",
    "latitude": 52.5173885,
    "longitude": 13.3951309,
    "category": "place",
    "categoryDetail": "city",
    "type": "city",
    "houseNumber": null,
    "street": null,
    "postcode": null,
    "locality": null,
    "district": null,
    "city": null,
    "county": null,
    "state": null,
    "country": "Germany",
    "countryCode": "DE",
    "osmId": 62422,
    "osmType": "R",
    "extent": [13.088345, 52.6755087, 13.7611609, 52.3382448],
    "mapUrl": "https://www.openstreetmap.org/?mlat=52.5173885&mlon=13.3951309#map=17/52.5173885/13.3951309",
    "scrapedAt": "2026-06-04T19:34:21.967Z",
    "error": null
}
```

```json
{
    "queryMode": "forward",
    "query": "Berlin",
    "displayName": "Berlin, 03570, New Hampshire, United States",
    "name": "Berlin",
    "latitude": 44.4696602,
    "longitude": -71.1810703,
    "category": "place",
    "categoryDetail": "city",
    "type": "city",
    "houseNumber": null,
    "street": null,
    "postcode": "03570",
    "locality": null,
    "district": null,
    "city": null,
    "county": "Coos",
    "state": "New Hampshire",
    "country": "United States",
    "countryCode": "US",
    "osmId": 170184,
    "osmType": "R",
    "extent": [-71.397858, 44.528436, -71.123642, 44.445057],
    "mapUrl": "https://www.openstreetmap.org/?mlat=44.4696602&mlon=-71.1810703#map=17/44.4696602/-71.1810703",
    "scrapedAt": "2026-06-04T19:34:22.050Z",
    "error": null
}
```

### ✨ Why choose this Actor

- No API key and no account on the source side. Photon is open and keyless.
- Two modes in one tool. Forward and reverse are auto-detected from your input.
- Global reach from the OpenStreetMap dataset, from landmarks to whole countries.
- Clean and predictable records with a composed display name and a map link.
- Honest fields. Address parts appear only when the matched object carries them, never padded with fake values.

### 📈 How it compares to alternatives

| Approach | Coverage | Key required | Reverse mode | Structured address parts |
|---|---|---|---|---|
| Photon Geocoder Scraper | Global OSM | No | Yes | Yes |
| Paid geocoding APIs | Global | Usually yes | Yes | Yes, with quotas and billing |
| Manual map lookups | Manual | No | Manual | Copy by hand |
| Single endpoint scripts | Varies | Varies | Often forward only | Often raw, unmapped |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Photon Geocoder Scraper in Apify Console.
3. Enter a Search Query for forward geocoding, or a Latitude and Longitude pair for reverse geocoding.
4. Set Max Items and an optional result language, then click Start.
5. Watch the run finish and browse or connect the results to your own systems.

### 💼 Business use cases

**Logistics and delivery**

| Need | How this helps |
|---|---|
| Standardize delivery points | Convert customer addresses to precise coordinates. |
| Validate new stops | Confirm a place exists and read back its parts. |

**Sales and marketing operations**

| Need | How this helps |
|---|---|
| Territory planning | Geocode leads to assign regions by state or county. |
| List enrichment | Add coordinates and country codes to contact lists. |

**Product and engineering**

| Need | How this helps |
|---|---|
| Search and autocomplete | Back a place search box with ranked matches. |
| Map features | Pin results using the included map link and extent. |

**Research and analytics**

| Need | How this helps |
|---|---|
| Spatial datasets | Build location tables from open address text. |
| Reverse lookups | Label scattered coordinate samples with place names. |

### 🔌 Automating Photon Geocoder Scraper

Connect runs to the tools you already use:

- **Make** and **Zapier** to trigger geocoding from new rows or form entries.
- **Slack** to post a summary when a batch finishes.
- **Airbyte** to sync results into a warehouse.
- **GitHub Actions** to schedule recurring enrichment jobs.
- **Google Drive** to archive result snapshots for your team.

### 🌟 Beyond business use cases

- **Research:** map study sites and survey points from text descriptions.
- **Personal:** plan trips by resolving landmark names into map pins.
- **Non-profit:** geocode service locations for community resource maps.
- **Experimentation:** prototype geocoding features without paid quotas.

### 🤖 Ask an AI assistant

Paste a result into your assistant of choice and ask for the next step:

- [ChatGPT](https://chat.openai.com)
- [Claude](https://claude.ai)
- [Perplexity](https://www.perplexity.ai)
- [Microsoft Copilot](https://copilot.microsoft.com)

Example prompt: "Here is a geocoding result with latitude, longitude, and address parts. Group these places by country and country code and summarize the coverage."

### ❓ Frequently Asked Questions

**Do I need an API key for Photon?**
No. Photon by komoot is keyless and open, so you only need your Apify account.

**What is the difference between forward and reverse geocoding?**
Forward turns a place name or address into coordinates. Reverse turns a coordinate pair into the nearest named place or address.

**How do I choose the mode?**
You do not. The mode is auto-detected. A Search Query runs forward, a Latitude and Longitude pair runs reverse.

**What happens if I send both a query and coordinates?**
Forward geocoding takes priority and the coordinates are ignored for that run.

**Why are some address fields empty?**
Address parts like house number, postcode, or state appear only when the matched OpenStreetMap object actually carries them. A country or city result will not include a house number.

**How many results can I get per query?**
Up to your Max Items value. Free plans are capped at 10 results per run.

**Which languages are supported for names?**
English, German, French, Italian, and Spanish where the underlying data provides translated names.

**Is the data accurate and current?**
Results come from OpenStreetMap through Photon, so accuracy reflects community OSM data, which is broad and frequently updated.

**Can I geocode many addresses at once?**
Each run resolves a single query. Use an automation platform to loop over a list and trigger one run per address.

**What is the map link for?**
The `mapUrl` opens OpenStreetMap centered on the location, which is handy for quick visual checks.

**What does the extent field mean?**
It is the bounding box of the feature as four coordinates, useful for zooming a map to fit the place.

**Is this affiliated with komoot or OpenStreetMap?**
No. This is an independent tool that queries the public Photon service. See the disclaimer below.

### 🔌 Integrate with any app

Results are available through the Apify API and webhooks, so you can pull records into spreadsheets, databases, dashboards, or any service that speaks HTTP.

### 🔗 Recommended Actors

- [Nominatim OSM Scraper](https://apify.com/parseforge/nominatim-osm-scraper) for an alternative OpenStreetMap geocoding source.
- [US Census Geocoder Scraper](https://apify.com/parseforge/uscensus-geocoder-scraper) for United States address matching.
- [GeoNames Places Scraper](https://apify.com/parseforge/geonames-places-scraper) for place name and administrative data.
- [Overpass OSM POI Scraper](https://apify.com/parseforge/overpass-osm-poi-scraper) for points of interest from OpenStreetMap.
- [Address Normalizer](https://apify.com/parseforge/address-normalizer) to clean and standardize raw address text.

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with komoot, Photon, or OpenStreetMap. Only publicly available data is collected.

# Actor input Schema

## `query` (type: `string`):

Free text place, address, or point of interest to look up, for example "Brandenburg Gate, Berlin" or "Berlin". Leave empty if you want reverse geocoding instead.

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

Preferred language for place names where available.

## `latitude` (type: `string`):

Latitude of the point to reverse geocode, for example "52.5162699". Provide both Latitude and Longitude to use reverse mode.

## `longitude` (type: `string`):

Longitude of the point to reverse geocode, for example "13.3777034".

## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000

## Actor input object example

```json
{
  "query": "Brandenburg Gate, Berlin",
  "language": "en",
  "maxItems": 10
}
```

# Actor output Schema

## `results` (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 = {
    "query": "Brandenburg Gate, Berlin",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/photon-geocoder-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 = {
    "query": "Brandenburg Gate, Berlin",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/photon-geocoder-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 '{
  "query": "Brandenburg Gate, Berlin",
  "maxItems": 10
}' |
apify call parseforge/photon-geocoder-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Photon Geocoder Scraper",
        "description": "Resolve any place name or address into precise coordinates with Photon by komoot on OpenStreetMap, and reverse lookup coordinates into the nearest place. Returns latitude, longitude, street, postcode, city, country, and a map link. Handy for logistics, lead enrichment, and mapping apps.",
        "version": "0.1",
        "x-build-id": "7eORe7aO5DimWfpF5"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~photon-geocoder-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-photon-geocoder-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/parseforge~photon-geocoder-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-photon-geocoder-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/parseforge~photon-geocoder-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-photon-geocoder-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": {
                    "query": {
                        "title": "Search Query (Forward Geocoding)",
                        "type": "string",
                        "description": "Free text place, address, or point of interest to look up, for example \"Brandenburg Gate, Berlin\" or \"Berlin\". Leave empty if you want reverse geocoding instead."
                    },
                    "language": {
                        "title": "Result Language",
                        "enum": [
                            "en",
                            "de",
                            "fr",
                            "it",
                            "es"
                        ],
                        "type": "string",
                        "description": "Preferred language for place names where available.",
                        "default": "en"
                    },
                    "latitude": {
                        "title": "Latitude (Reverse Geocoding)",
                        "type": "string",
                        "description": "Latitude of the point to reverse geocode, for example \"52.5162699\". Provide both Latitude and Longitude to use reverse mode."
                    },
                    "longitude": {
                        "title": "Longitude (Reverse Geocoding)",
                        "type": "string",
                        "description": "Longitude of the point to reverse geocode, for example \"13.3777034\"."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000"
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```