# Overture Maps Places Extractor (`automation-lab/overture-maps-places-extractor`) Actor

🌍 Query public Overture Maps Places by bounding box or radius. Export normalized POIs, contacts, addresses, categories, coordinates, confidence, provenance, and GERS IDs.

- **URL**: https://apify.com/automation-lab/overture-maps-places-extractor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Business, Lead generation
- **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/docs.md):

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

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

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

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

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

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

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

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

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


# README

## Overture Maps Places Extractor

Extract public points of interest from **Overture Maps Places** without a Google Maps API key, browser, proxy, or login.

Choose a bounding box or a point and radius, add optional place filters, and receive a clean dataset of names, categories, addresses, contacts, coordinates, confidence scores, provenance, and stable GERS IDs.

The Actor reads Overture's official global GeoParquet release directly from public S3. DuckDB applies area and attribute predicates before returning a bounded result set, so your workflow does not download the full planet dataset.

- 🌍 Search public global POI data by area.
- 📍 Use a rectangle or point-and-radius workflow.
- 🏷️ Filter by place name, Overture category, country, and confidence.
- 📞 Export phones, emails, websites, and social links when available.
- 🔁 Pin a release for repeatable GIS and enrichment jobs.
- 🧩 Integrate through API, schedules, webhooks, Make, n8n, Zapier, or MCP.

### What does Overture Maps Places Extractor do?

The Actor turns Overture Maps' large Places GeoParquet distribution into a simple Apify input and dataset.

Instead of operating DuckDB yourself, discovering new releases, understanding nested Overture fields, and flattening records for CSV or CRM imports, you provide one small JSON input.

For every matching place, the Actor can return:

- GERS place ID;
- primary and translated names;
- primary, alternate, basic, and taxonomy categories;
- free-form address, locality, postcode, region, and country;
- phone numbers, emails, websites, and socials;
- Overture confidence and operating status;
- latitude and longitude;
- source dataset and source record identifiers;
- Overture release, record version, and public source URL.

The Actor automatically discovers the newest public release unless you supply a pinned release.

### Who is it for?

#### Lead generation teams

Build territory lists of cafes, shops, restaurants, service providers, or other local organizations. Export contact fields to your qualification or enrichment pipeline.

#### GIS and location intelligence analysts

Create bounded POI layers for density comparisons, catchment analysis, market coverage, or map visualization. Stable GERS IDs help deduplicate and join records over time.

#### Retail and location planners

Compare business presence around candidate sites, transport hubs, neighborhoods, and competitor territories.

#### Data engineering teams

Schedule repeatable snapshots of selected regions, pin releases for reproducibility, and send structured output to warehouses or object storage.

#### Researchers and open-data users

Explore a commercial-use-friendly public map dataset without maintaining a Parquet query environment.

### Why use this Overture Maps extractor?

- **Official public data:** queries Overture's published Places release, not a protected consumer website.
- **No credentials:** no API key, paid map account, cookies, or CAPTCHA solving.
- **Bounded queries:** every run requires a geographic area and a strict output limit.
- **Useful normalization:** nested source records become export-friendly place rows.
- **Reproducibility:** use the latest release or pin a known release.
- **Apify-native delivery:** datasets, schedules, webhooks, API clients, integrations, and MCP work out of the box.
- **Source transparency:** output includes release and provenance fields.

Choose this Actor when open Overture data is appropriate. Choose a consumer-map scraper when you specifically need reviews, ratings, opening hours, photos, or ranking signals that Overture does not publish.

### What Overture Maps place data can I extract?

| Field | Description |
|---|---|
| `gersId` | Stable Overture GERS identifier |
| `name` | Primary place name |
| `nameTranslations` | Available language-to-name translations |
| `category` | Primary Overture category |
| `alternateCategories` | Alternate Overture categories |
| `basicCategory` | Broad basic category |
| `taxonomyHierarchy` | Category hierarchy |
| `address` | Free-form address |
| `locality` | City or locality |
| `postcode` | Postal code |
| `region` | State, province, or region |
| `country` | Two-letter country code |
| `phones` | Published phone numbers |
| `emails` | Published email addresses |
| `websites` | Published websites |
| `socials` | Published social profile URLs |
| `confidence` | Overture confidence from 0 to 1 |
| `operatingStatus` | Available operating-status value |
| `latitude`, `longitude` | Coordinates derived from the point bbox center |
| `sourceDatasets` | Contributing source datasets |
| `sourceRecordIds` | Contributing source record IDs |
| `version` | Overture entity version |
| `release` | Queried Overture release |
| `sourceUrl` | Public S3 Places prefix |
| `extractedAt` | UTC extraction timestamp |

Sparse source fields are emitted as empty arrays or omitted, rather than invented.

### How to extract Overture Maps places

1. Open the Actor input page.
2. Keep the prefilled central-Berlin bounding box for a quick first run, or enter your own box.
3. Alternatively, remove `boundingBox` and provide `latitude`, `longitude`, and `radiusKm` together.
4. Add a category such as `cafe`, `restaurant`, `shoe_store`, or `police_department` if needed.
5. Optionally add a name substring, country code, or minimum confidence.
6. Set a conservative `maxItems` while validating your area.
7. Start the Actor and inspect the **Overture places** dataset view.
8. Export JSON, CSV, Excel, XML, or another Apify-supported format.
9. Scale the limit or schedule the input after confirming the results.

A first bounded query normally completes well within the default timeout. Remote Parquet footer and row-group reads make startup slower than a small JSON API, so avoid splitting one area into many tiny runs unnecessarily.

### Input parameters

| Input | Type | Required | Notes |
|---|---|---:|---|
| `boundingBox` | object | One area mode | `west`, `south`, `east`, `north`; maximum 25 square degrees |
| `latitude` | number | Point-radius mode | -90 to 90 |
| `longitude` | number | Point-radius mode | -180 to 180 |
| `radiusKm` | number | Point-radius mode | Greater than 0, maximum 100 km |
| `name` | string | No | Case-insensitive primary-name substring |
| `category` | string | No | Exact primary or alternate Overture category |
| `country` | string | No | Two-letter ISO code such as `DE` or `US` |
| `minConfidence` | number | No | 0 to 1 |
| `maxItems` | integer | No | 1 to 10,000; default 10 |
| `release` | string | No | Example: `2026-06-17.0`; newest is automatic |

Exactly one geographic mode is required. Mixing a bounding box with point-radius fields fails clearly instead of silently choosing one.

### Bounding box input example

```json
{
  "boundingBox": {
    "west": 13.39,
    "south": 52.50,
    "east": 13.42,
    "north": 52.53
  },
  "category": "cafe",
  "country": "DE",
  "minConfidence": 0.7,
  "maxItems": 100
}
````

Longitude is west/east. Latitude is south/north. The box must not cross the antimeridian in one run.

### Point and radius input example

```json
{
  "latitude": 40.758,
  "longitude": -73.9855,
  "radiusKm": 2,
  "name": "coffee",
  "maxItems": 50
}
```

The Actor first uses a rectangular envelope for Parquet pruning, then applies a Haversine distance predicate so corner records outside the requested circle are excluded.

### Output example

```json
{
  "gersId": "360accab-e531-4437-8527-164f85833ad6",
  "name": "Polizei Abschnitt 53",
  "category": "police_department",
  "alternateCategories": [],
  "taxonomyHierarchy": ["public_service"],
  "address": "Friedrichstraße 219",
  "locality": "Berlin",
  "postcode": "10969",
  "country": "DE",
  "phones": ["030 4664553700"],
  "emails": [],
  "websites": ["https://www.berlin.de/polizei/"],
  "socials": [],
  "confidence": 0.77,
  "latitude": 52.505039,
  "longitude": 13.390381,
  "sourceDatasets": ["meta"],
  "sourceRecordIds": ["example-record"],
  "version": 1,
  "release": "2026-06-17.0",
  "sourceUrl": "https://overturemaps-us-west-2.s3.us-west-2.amazonaws.com/release/2026-06-17.0/theme=places/type=place/",
  "extractedAt": "2026-07-18T00:00:00.000Z"
}
```

The exact fields depend on Overture's source coverage for each place.

### How much does it cost to extract Overture Maps places?

The Actor uses pay-per-event pricing:

- a small one-time **search started** event covers release discovery and opening remote Parquet data;
- a **place saved** event is charged for each dataset row;
- subscription tiers receive decreasing per-place prices.

| Apify tier | Price per saved place |
|---|---:|
| Free | $0.000059468 |
| Bronze | $0.000051711 |
| Silver | $0.000040335 |
| Gold | $0.000031027 |
| Platinum | $0.000020684 |
| Diamond | $0.000014479 |

The one-time run-start price is $0.005. The Apify Console pricing tab is authoritative. Before a larger run, estimate the maximum charge from your `maxItems` and current subscription-tier price.

A tight area and category can return fewer rows than `maxItems`; you are charged only for places actually saved, plus the start event.

### Tips for better place extraction

- 🎯 Start with a small bounding box and `maxItems: 10`.
- 🧭 Confirm longitude/latitude order before running a rectangle.
- 🏷️ Use Overture taxonomy values with underscores, such as `shoe_store`.
- 🌎 Add a country code when a box overlaps a border.
- ✅ Raise `minConfidence` for conservative enrichment workflows.
- 🔁 Pin `release` when comparing changes between scheduled runs.
- 🧩 Deduplicate downstream by `gersId`, not by name.
- 📦 Prefer one moderate run over dozens of tiny adjacent runs when practical.
- 🔍 Remove restrictive filters if a valid area returns no rows.

### Scheduled monitoring and snapshots

Create an Apify task with a pinned region and category, then schedule it weekly or monthly.

For change detection:

1. store the current dataset in your warehouse;
2. use `gersId` as the stable join key;
3. compare `version`, contact fields, category, and operating status;
4. use the output `release` to label each snapshot;
5. trigger a webhook when the run succeeds.

A pinned release produces reproducible results. Leave `release` empty when each schedule should automatically use Overture's newest available publication.

### Integrations

#### Google Sheets and Excel

Export the dataset as CSV or XLSX for territory review. Keep `gersId`, coordinates, and release columns so analysts can trace and deduplicate rows.

#### Airtable and CRM pipelines

Send new GERS IDs through Make, n8n, or Zapier. Map name, address, phone, email, website, and category into prospect records, then apply your own qualification rules.

#### GIS and warehouses

Load JSON or CSV into BigQuery, Snowflake, Postgres/PostGIS, QGIS, or ArcGIS. Create geometry from `longitude` and `latitude` and preserve source provenance.

#### Webhooks and Actor chains

Attach a run-succeeded webhook, or call a second Actor to enrich websites, validate emails, geocode addresses, or compare snapshots.

### Use the Apify API

Use the Actor ID `automation-lab/overture-maps-places-extractor`.

#### JavaScript

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/overture-maps-places-extractor').call({
  boundingBox: { west: 13.39, south: 52.50, east: 13.42, north: 52.53 },
  category: 'cafe',
  maxItems: 100,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

#### Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/overture-maps-places-extractor').call(run_input={
    'latitude': 40.758,
    'longitude': -73.9855,
    'radiusKm': 2,
    'maxItems': 50,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

#### cURL

```bash
curl "https://api.apify.com/v2/acts/automation-lab~overture-maps-places-extractor/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H 'Content-Type: application/json' \
  -d '{"boundingBox":{"west":13.39,"south":52.50,"east":13.42,"north":52.53},"maxItems":10}'
```

Poll the returned run or use the synchronous API endpoint when your client can wait for completion.

### Use with Apify MCP

MCP lets AI assistants discover and run this Actor as a tool.

#### Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/overture-maps-places-extractor"
```

Example prompts:

- “Find up to 50 cafes from Overture Maps in this Berlin bounding box.”
- “Extract high-confidence restaurants within 3 km of these coordinates.”
- “Run the Overture place extractor and summarize categories by locality.”

#### Claude Desktop, Cursor, and VS Code

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

Configure your Apify authentication according to the MCP client and Apify MCP documentation.

### Data quality and limitations

Overture combines open and partner-contributed source data. Coverage and freshness vary by country, category, and field.

- Some places have no phone, email, website, or social link.
- Categories may not match consumer-map taxonomies exactly.
- The Actor does not provide reviews, ratings, photos, popular times, or search rank.
- Coordinates are derived from the center of Overture's point bounding box.
- Name filtering applies to the primary name.
- A strict category filter matches Overture primary or alternate category values.
- A maximum result limit is not a pagination promise; it is a safety ceiling.
- Overture can add, remove, or evolve source fields between releases.

Always sample the dataset before using it for outreach, compliance, or high-impact decisions.

### Is extracting Overture Maps data legal?

Overture Maps publishes its data for broad reuse under its documented data licenses. Individual source records can carry source and license provenance, and users remain responsible for following the applicable Overture terms, source attribution requirements, privacy law, and rules governing their downstream use.

Do not use contact data for spam, harassment, discrimination, surveillance, or unlawful profiling. Review Overture's current license documentation before redistribution.

This README is technical information, not legal advice.

### FAQ

#### Does this Actor require an Overture API key?

No. It reads Overture's public S3 GeoParquet release anonymously.

#### Does it use a browser or proxy?

No. DuckDB performs remote range reads against public S3 objects.

#### Can I search the whole world?

No. Every run requires a bounded area. This protects runtime, network use, and predictable costs.

#### Why did my valid search return zero places?

The area may have no matching source records, or your name, category, country, or confidence filter may be too restrictive. Retry locally with filters removed and a small result limit.

#### Why did my run reject the geographic input?

Provide either `boundingBox` or all three point-radius fields. Do not supply both. Ensure west is less than east and south is less than north.

#### How do I find valid categories?

Run a small area without `category`, inspect `category` and `alternateCategories`, then reuse the exact underscore-form value.

#### Can I reproduce a previous dataset?

Supply the previous output's `release` value. Availability follows Overture's public release retention policy.

#### Are GERS IDs stable?

They are designed as stable identifiers for joining Overture entities. Use the output `gersId` as the stable identifier, and preserve `version` and `release` as well when tracking change.

### Related scrapers

Use other automation-lab Actors when Overture's open-data scope is not enough:

- [Google Maps Scraper](https://apify.com/automation-lab/google-maps-scraper) for consumer-map business discovery and richer map-specific signals.
- [OpenStreetMap Scraper](https://apify.com/automation-lab/openstreetmap-scraper) for OpenStreetMap entities and tags.
- [Website Contact Scraper](https://apify.com/automation-lab/website-contact-scraper) to enrich returned websites with contact details.

Check each linked Actor's current input and availability before building a production chain.

### Support

If a run fails, include the run URL, sanitized input, expected area, and whether the release was automatic or pinned.

Useful troubleshooting details include:

- the exact bounding box or center and radius;
- category and country filters;
- selected `maxItems`;
- pinned release, if any;
- whether the failure repeats with the prefilled Berlin example.

For data corrections to the underlying map, consult Overture Maps and the provenance fields rather than editing Actor output manually.

# Actor input Schema

## `boundingBox` (type: `object`):

Search rectangle with west, south, east, and north coordinates. Use this or the point-radius fields, not both.

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

Latitude of the radius-search center, from -90 to 90.

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

Longitude of the radius-search center, from -180 to 180.

## `radiusKm` (type: `number`):

Search radius in kilometers. Maximum 100 km.

## `name` (type: `string`):

Keep places whose primary name contains this text, case-insensitively.

## `category` (type: `string`):

Exact primary or alternate Overture category, such as cafe, shoe\_store, or police\_department.

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

Two-letter ISO country code, for example DE or US.

## `minConfidence` (type: `number`):

Keep records at or above this Overture confidence score.

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

Stop after this many matching places have been saved.

## `release` (type: `string`):

Optional pinned release such as 2026-06-17.0. Leave empty to discover the newest public release.

## Actor input object example

```json
{
  "boundingBox": {
    "west": 13.39,
    "south": 52.5,
    "east": 13.42,
    "north": 52.53
  },
  "minConfidence": 0,
  "maxItems": 10
}
```

# Actor output Schema

## `places` (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 = {
    "boundingBox": {
        "west": 13.39,
        "south": 52.5,
        "east": 13.42,
        "north": 52.53
    },
    "minConfidence": 0,
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/overture-maps-places-extractor").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 = {
    "boundingBox": {
        "west": 13.39,
        "south": 52.5,
        "east": 13.42,
        "north": 52.53,
    },
    "minConfidence": 0,
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/overture-maps-places-extractor").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 '{
  "boundingBox": {
    "west": 13.39,
    "south": 52.5,
    "east": 13.42,
    "north": 52.53
  },
  "minConfidence": 0,
  "maxItems": 10
}' |
apify call automation-lab/overture-maps-places-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Overture Maps Places Extractor",
        "description": "🌍 Query public Overture Maps Places by bounding box or radius. Export normalized POIs, contacts, addresses, categories, coordinates, confidence, provenance, and GERS IDs.",
        "version": "0.1",
        "x-build-id": "dsmI5YJvgT4cFdhGg"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~overture-maps-places-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-overture-maps-places-extractor",
                "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~overture-maps-places-extractor/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-overture-maps-places-extractor",
                "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~overture-maps-places-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-overture-maps-places-extractor",
                "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": {
                    "boundingBox": {
                        "title": "🗺️ Bounding box",
                        "type": "object",
                        "description": "Search rectangle with west, south, east, and north coordinates. Use this or the point-radius fields, not both."
                    },
                    "latitude": {
                        "title": "Center latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Latitude of the radius-search center, from -90 to 90."
                    },
                    "longitude": {
                        "title": "Center longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Longitude of the radius-search center, from -180 to 180."
                    },
                    "radiusKm": {
                        "title": "Radius (km)",
                        "minimum": 0.01,
                        "maximum": 100,
                        "type": "number",
                        "description": "Search radius in kilometers. Maximum 100 km."
                    },
                    "name": {
                        "title": "Place name contains",
                        "type": "string",
                        "description": "Keep places whose primary name contains this text, case-insensitively."
                    },
                    "category": {
                        "title": "Overture category",
                        "type": "string",
                        "description": "Exact primary or alternate Overture category, such as cafe, shoe_store, or police_department."
                    },
                    "country": {
                        "title": "Country code",
                        "pattern": "^[A-Za-z]{2}$",
                        "type": "string",
                        "description": "Two-letter ISO country code, for example DE or US."
                    },
                    "minConfidence": {
                        "title": "Minimum confidence",
                        "minimum": 0,
                        "maximum": 1,
                        "type": "number",
                        "description": "Keep records at or above this Overture confidence score.",
                        "default": 0
                    },
                    "maxItems": {
                        "title": "Maximum places",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Stop after this many matching places have been saved.",
                        "default": 10
                    },
                    "release": {
                        "title": "Overture release (advanced)",
                        "pattern": "^\\d{4}-\\d{2}-\\d{2}\\.\\d+$",
                        "type": "string",
                        "description": "Optional pinned release such as 2026-06-17.0. Leave empty to discover the newest public release."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```