# Location Intelligence — 76M Global POIs (Overture Maps) (`foxlabs/location-intelligence`) Actor

Search ~76M points of interest worldwide from Overture Maps by area (point+radius or bounding box). Name, category, brand, phone, email, website, socials, full address & exact coordinates. Official open data, commercial reuse permitted. No API key.

- **URL**: https://apify.com/foxlabs/location-intelligence.md
- **Developed by:** [Berkan Kaplan](https://apify.com/foxlabs) (community)
- **Categories:** Lead generation, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.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.

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

<p align="center"><a href="https://apify.com/foxlabs/location-intelligence"><img src="https://data.foxlabs.com.tr/img/location-intelligence-banner.svg" alt="Location Intelligence — 76M Global POIs (Overture Maps)" width="100%" /></a></p>

## Location Intelligence — 76M Global POIs (Overture Maps)

Need **local-business & place data anywhere on Earth** — not a fragile HTML scrape that breaks next week? This Actor turns **Overture Maps** (~76 million points of interest worldwide) into clean, structured records: **name, category, brand, phone, email, website, social profiles, full address and exact coordinates** — for any area you point it at.

Built directly on **Overture Maps**, the open map-data foundation backed by **Meta, Microsoft, Amazon and TomTom**. Data is released under **CDLA-Permissive 2.0**, which **permits commercial reuse and redistribution** with no share-alike obligation. **No API key, no login, no HTML scraping** — the Actor queries Overture's public cloud Parquet directly and reads only the map tiles your search needs (never the whole 76M-row dataset).

- 🌍 **~76M places worldwide** — every business and POI, one global open dataset
- 📇 **Contact-rich** — `phone`, `email`, `website` and `socials[]`, with `hasContact` + `contactMethods[]` flags for instant lead lists
- 🗺️ **Exact geo** — `latitude` / `longitude` + full address; search by **point + radius** or **bounding box**, anywhere
- ✅ **Open & resellable** — CDLA-Permissive 2.0, no API key, no fragile scraping — it doesn't break when a website changes

### Quick start (API)

Get up to 100 restaurants with contact info within 2 km of central Mexico City, in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/foxlabs~location-intelligence/run-sync-get-dataset-items?token=YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{ "location": { "latitude": 19.4326, "longitude": -99.1332, "radiusKm": 2 }, "category": "restaurant", "onlyWithContact": true, "maxResults": 100 }'
````

Prefer no code? Open the **Input** tab, drop a point or a bounding box, set your filters, and click **Start** — then download the results.

### What you get

One clean, flat JSON record per place:

| Field | Type | Description |
|---|---|---|
| `id` | string | Overture **GERS** id — stable global place id |
| `name` | string | Place / business name |
| `category` | string | Primary Overture category (e.g. `restaurant`) |
| `alternateCategories` | array | Additional categories for the place |
| `brand` | string | Brand name, where the place belongs to one |
| `confidence` | number | Overture source-confidence score (0–1) |
| `phone` | string | Public phone |
| `email` | string | Public email |
| `website` | string | Website URL |
| `socials` | array | Social profile URLs |
| `hasContact` | bool | `true` if any contact method is present |
| `contactMethods` | array | Which contacts exist: `phone` / `email` / `website` / `social` |
| `address` | string | Freeform street address |
| `city` | string | Locality / city |
| `region` | string | Region / state |
| `postcode` | string | Postal code |
| `country` | string | ISO-2 country code |
| `latitude` / `longitude` | number | Exact coordinates (the place's point location) |
| `source` / `license` | string | Provenance: Overture release + CDLA-Permissive 2.0 |
| `scrapedAt` | string | ISO timestamp of the run |

#### Sample output

```json
{
  "id": "08f2f5b0e8a3c1a2039e7d4c6b1f0a2d",
  "name": "Café de la Reforma",
  "category": "cafe",
  "alternateCategories": ["restaurant", "coffee_shop"],
  "brand": null,
  "confidence": 0.94,
  "phone": "+52 55 5512 3456",
  "email": null,
  "website": "https://cafedelareforma.mx",
  "socials": ["https://facebook.com/cafedelareforma"],
  "hasContact": true,
  "contactMethods": ["phone", "website", "social"],
  "address": "Paseo de la Reforma 222",
  "city": "Ciudad de México",
  "region": "CDMX",
  "postcode": "06600",
  "country": "MX",
  "latitude": 19.4267,
  "longitude": -99.1642,
  "source": "Overture Maps — places theme (release 2026-06-17.0)",
  "license": "CDLA-Permissive 2.0 (© Overture Maps Foundation)",
  "scrapedAt": "2026-07-05T10:22:41.000Z"
}
```

*Illustrative record showing the exact field shape. Missing values are returned as `null` (or `[]`), never guessed.*

### Example inputs (copy & paste)

```jsonc
// 1) Lead list: restaurants near a point that publish contact info
{ "location": { "latitude": 19.4326, "longitude": -99.1332, "radiusKm": 3 }, "category": "restaurant", "onlyWithContact": true, "maxResults": 1000 }

// 2) Brand footprint: every Starbucks inside a bounding box
{ "boundingBox": { "minLatitude": 19.30, "minLongitude": -99.25, "maxLatitude": 19.55, "maxLongitude": -99.05 }, "nameQuery": "Starbucks" }

// 3) Every place in a neighbourhood, restricted to one country
{ "location": { "latitude": 40.7580, "longitude": -73.9855, "radiusKm": 1 }, "country": "US", "maxResults": 5000 }

// 4) Market sizing: every pharmacy within 5 km of a point
{ "location": { "latitude": 19.4326, "longitude": -99.1332, "radiusKm": 5 }, "category": "pharmacy", "maxResults": 3000 }

// 5) Brand footprint within a country — Oxxo stores across a wide radius in Mexico
{ "location": { "latitude": 19.4326, "longitude": -99.1332, "radiusKm": 25 }, "nameQuery": "Oxxo", "country": "MX", "maxResults": 5000 }

// 6) Bounding-box lead list: hotels in a city box that publish contact info
{ "boundingBox": { "minLatitude": 40.70, "minLongitude": -74.02, "maxLatitude": 40.80, "maxLongitude": -73.93 }, "category": "hotel", "onlyWithContact": true, "maxResults": 2000 }

// 7) Reproducible export — pin a specific Overture release (cafés in central Paris)
{ "location": { "latitude": 48.8566, "longitude": 2.3522, "radiusKm": 2 }, "category": "cafe", "release": "2026-06-17.0" }
```

### Input & filters

- **Where to search (required).** Either a **point + radius** — `location: { latitude, longitude, radiusKm }` (radius 0.1–50 km, default 2) — or an explicit **bounding box** `{ minLatitude, minLongitude, maxLatitude, maxLongitude }`. One of the two is required; everything else is optional.
- **Category** — case-insensitive substring match on the place's primary category (`"restaurant"`, `"hotel"`, `"pharmacy"`, `"gym"` …).
- **Name contains** (`nameQuery`, or `name`) — case-insensitive substring on the place name; great for mapping a brand's footprint (`"Starbucks"`, `"Oxxo"`).
- **Country** — restrict to a 2-letter ISO code (`"MX"`, `"US"`, `"DE"`).
- **Only places with contact info** (`onlyWithContact`) — keep only places that have a phone, email, website or social profile.
- **Max results** — 1–50,000 per run. A dense urban area can hold thousands.
- **Overture release** (advanced) — pin a specific release (e.g. `"2026-06-17.0"`); leave blank for the built-in current release.

### Use cases

- **B2B lead generation.** You sell to local businesses in a city. Set a `location` + `category: "restaurant"` + `onlyWithContact: true` → a CRM-ready list of places with a **phone / website / email** and exact address, filtered to just the ones you can actually reach — no manual list-building.
- **Competitor & brand footprint mapping.** Pass `nameQuery: "Starbucks"` over a bounding box → every branch in the area with coordinates, ready to geo-plot and compare against your own locations.
- **Market sizing & site selection.** Sweep a neighbourhood (or several) and count the density and mix of categories — how many cafés, gyms or pharmacies per area — to size a market or choose where to open next.
- **Store locators & map layers.** Build a "places near me" layer for an app or website from `latitude` / `longitude` + `address`, refreshed on a schedule.
- **Local dataset enrichment.** Have a rough list of areas or brands? Feed them in area by area to append category, brand, contact and precise geo — missing fields return `null`, never a guess.
- **Geospatial / GIS analysis.** Export exact coordinates into your GIS for catchment, coverage or accessibility analysis across any region worldwide.

### Performance & throughput

The Actor uses **DuckDB spatial predicate push-down** on Overture's public Parquet, so each run reads **only the map tiles (row-groups) your area overlaps** — never the full 76M rows. A tight neighbourhood or city-district search touches a small fraction of the data and returns quickly; **expanding the radius or bounding box reads more tiles and takes longer**, and very large areas trigger a warning. `maxResults` caps the rows returned. There are **no external API keys, proxies or rate limits** — the data comes from Overture's anonymous public cloud storage — so throughput is bounded mainly by your search area and Apify plan.

### Integrations

**JavaScript** (`apify-client`):

```js
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });
const run = await client.actor('foxlabs/location-intelligence').call({
  location: { latitude: 19.4326, longitude: -99.1332, radiusKm: 2 },
  category: 'restaurant', onlyWithContact: true, maxResults: 500,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**Python** (`apify-client`):

```python
from apify_client import ApifyClient
client = ApifyClient("YOUR_APIFY_TOKEN")
run = client.actor("foxlabs/location-intelligence").call(run_input={
    "location": {"latitude": 19.4326, "longitude": -99.1332, "radiusKm": 2},
    "category": "restaurant", "onlyWithContact": True, "maxResults": 500,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["name"], item.get("phone"))
```

Also works with **Make / n8n / Zapier** (Apify app → run this Actor, map the input), scheduled runs, webhooks, and the **Apify MCP server** for AI agents.

### Data quality (measured, not promised)

Live-measured on a **150-place sample in central Mexico City**:

| Field | Fill rate |
|---|---|
| Name · Category · Coordinates | **~100%** |
| City / Region / Country | ~99% |
| Address | ~94% |
| Postcode | ~91% |
| **Phone** | **~82%** |
| **Website** | **~66%** |
| **Email** | **~44%** |

Contact coverage is unusually high because Overture **conflates multiple sources** per place. Coverage varies by region and category. Contact fields come **only** from Overture's sources — never fabricated; missing values are `null`. Turn on **Only places with contact info** for lead-ready lists.

### Pricing

**Pay per result** — you're billed per place returned. Turning on **Only places with contact info** narrows the set to lead-ready records so you don't pay for places you can't reach. There's an Apify **free tier** to evaluate the full feature set before you scale. No proxies or third-party costs.

### FAQ

**Can I use this data commercially / resell it?** Yes — Overture Maps is licensed **CDLA-Permissive 2.0**, which permits commercial reuse and redistribution *with attribution*. Each record carries the required `© Overture Maps Foundation` attribution.

**Do I need an API key or account with Overture?** No. No key, no login — the Actor reads Overture's public cloud data directly.

**How do I search a whole city or country?** Search is **area-based**: give a point + radius or a bounding box. For large regions, break them into areas and run each — this is deliberate, so a run only reads the tiles it needs instead of the entire dataset.

**How fresh is the data?** Overture publishes a new release roughly **monthly**; the Actor targets the current release automatically. Pin an older one with the `release` field if you need to.

**What export formats are available?** JSON, CSV, Excel, or via the Apify API / integrations.

**Is the contact info verified?** No — it's **source-conflated** from Overture's upstream sources, not independently verified. A place may carry an out-of-date number. The `confidence` field reflects Overture's own source agreement (0–1).

**How many places can I get in one run?** Up to **50,000** via `maxResults`.

**Can I map a specific brand?** Yes — put the brand in `nameQuery` (e.g. `"Starbucks"`) and search over a bounding box or radius.

**What area size can I search?** A radius up to **50 km**, or any bounding box. Very large boxes read more map tiles and run slower — narrow the area or add a `category` filter for speed.

**Which countries are covered?** It's global (~76M places worldwide). Filter to one country with the ISO-2 `country` field.

### Troubleshooting

- **0 results** → your area is too small or your filters too narrow. Widen the `radiusKm` / bounding box, clear `category` or `onlyWithContact`, and check your `latitude` / `longitude` aren't swapped.
- **"Provide a location or bounding box" error** → you must supply an area to search — either `location` (latitude/longitude/radiusKm) or `boundingBox` (min/max latitude & longitude). It's the one required input.
- **Run is slow / reads a lot of data** → your search area is large. Narrow the radius or bounding box, or add a `category` filter — the spatial push-down reads more tiles the bigger the area.
- **A place has no phone/email** → not every place publishes contact info; that's the source data, not a miss (the value is `null`, never fabricated). Use **Only places with contact info** to keep just the ones that do.

### Notes, limits & legal (honest)

- **Search is area-based.** Overture is spatially indexed, so queries run per **geographic area** (point + radius or bounding box). Country-wide or global sweeps without an area are intentionally not offered — they'd read the entire dataset. Break big regions into areas.
- **Contact is source-conflated, not verified** — coverage is high (measured **~82% phone** on the sample above) but a place may carry an out-of-date number. `confidence` reflects Overture's own source agreement.
- **Coordinates** are the place's point location; addresses are provided where a source supplied them (~94% on the sample).
- **Attribution required.** Each record carries the CDLA-Permissive attribution `© Overture Maps Foundation`; keep it when you redistribute.
- **Freshness.** Data refreshes roughly monthly; the Actor targets the current Overture release automatically (override with `release`).
- **Not affiliated** with the Overture Maps Foundation; this Actor redistributes their public open data.

### Support

Questions, a field you'd like added, or a custom build? Open the **Issues** tab on this Actor, or email **info@foxlabs.com.tr**. We reply fast.

*If this Actor saves you time, a ⭐ review really helps.*

### Changelog

#### 0.2 — 2026-07-05

- Reworked docs: API quick-start, sample output, integrations, FAQ & troubleshooting.

#### 0.1

- Initial release. Area search (point+radius or bounding box) over Overture Maps' ~76M places with category/name/country filters; name, category, brand, contact (phone/email/website/socials), address, geo and confidence; DuckDB spatial push-down on public Parquet, no API key.

***

Part of the **[foXLabs data platform](https://data.foxlabs.com.tr/)** — official public-data company, contact, ownership, jobs, charity, location & AI-search intelligence scrapers. Browse the full suite at **[data.foxlabs.com.tr](https://data.foxlabs.com.tr/)**.

# Actor input Schema

## `location` (type: `object`):

Search around a point: { "latitude": 19.4326, "longitude": -99.1332, "radiusKm": 2 }. The simplest way to pull every place in an area.

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

Alternative to point+radius: an explicit box { "minLatitude", "minLongitude", "maxLatitude", "maxLongitude" }.

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

Filter by place category, e.g. "restaurant", "hotel", "pharmacy", "gym". Case-insensitive match on the place's primary Overture category.

## `nameQuery` (type: `string`):

Only places whose name contains this text, e.g. "Starbucks", "Oxxo". Great for mapping a brand's footprint.

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

Restrict to a country by 2-letter ISO code, e.g. "MX", "US", "DE".

## `onlyWithContact` (type: `boolean`):

Return only places that have a phone, email, website or social profile — ideal for lead lists.

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

Maximum number of places to return (1–50000). A dense urban area can hold thousands.

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

Advanced: pin a specific Overture Maps release (e.g. "2026-06-17.0"). Leave blank to use the built-in current release.

## Actor input object example

```json
{
  "location": {
    "latitude": 19.4326,
    "longitude": -99.1332,
    "radiusKm": 2
  },
  "category": "restaurant",
  "onlyWithContact": false,
  "maxResults": 500
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "location": {
        "latitude": 19.4326,
        "longitude": -99.1332,
        "radiusKm": 2
    },
    "category": "restaurant",
    "maxResults": 500
};

// Run the Actor and wait for it to finish
const run = await client.actor("foxlabs/location-intelligence").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 = {
    "location": {
        "latitude": 19.4326,
        "longitude": -99.1332,
        "radiusKm": 2,
    },
    "category": "restaurant",
    "maxResults": 500,
}

# Run the Actor and wait for it to finish
run = client.actor("foxlabs/location-intelligence").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 '{
  "location": {
    "latitude": 19.4326,
    "longitude": -99.1332,
    "radiusKm": 2
  },
  "category": "restaurant",
  "maxResults": 500
}' |
apify call foxlabs/location-intelligence --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Location Intelligence — 76M Global POIs (Overture Maps)",
        "description": "Search ~76M points of interest worldwide from Overture Maps by area (point+radius or bounding box). Name, category, brand, phone, email, website, socials, full address & exact coordinates. Official open data, commercial reuse permitted. No API key.",
        "version": "0.1",
        "x-build-id": "a3gFGPhXVMiTcDChF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/foxlabs~location-intelligence/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-foxlabs-location-intelligence",
                "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/foxlabs~location-intelligence/runs": {
            "post": {
                "operationId": "runs-sync-foxlabs-location-intelligence",
                "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/foxlabs~location-intelligence/run-sync": {
            "post": {
                "operationId": "run-sync-foxlabs-location-intelligence",
                "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": {
                    "location": {
                        "title": "Location (point + radius)",
                        "type": "object",
                        "description": "Search around a point: { \"latitude\": 19.4326, \"longitude\": -99.1332, \"radiusKm\": 2 }. The simplest way to pull every place in an area."
                    },
                    "boundingBox": {
                        "title": "Bounding box (advanced)",
                        "type": "object",
                        "description": "Alternative to point+radius: an explicit box { \"minLatitude\", \"minLongitude\", \"maxLatitude\", \"maxLongitude\" }."
                    },
                    "category": {
                        "title": "Category",
                        "type": "string",
                        "description": "Filter by place category, e.g. \"restaurant\", \"hotel\", \"pharmacy\", \"gym\". Case-insensitive match on the place's primary Overture category."
                    },
                    "nameQuery": {
                        "title": "Name contains",
                        "type": "string",
                        "description": "Only places whose name contains this text, e.g. \"Starbucks\", \"Oxxo\". Great for mapping a brand's footprint."
                    },
                    "country": {
                        "title": "Country (ISO-2)",
                        "type": "string",
                        "description": "Restrict to a country by 2-letter ISO code, e.g. \"MX\", \"US\", \"DE\"."
                    },
                    "onlyWithContact": {
                        "title": "Only places with contact info",
                        "type": "boolean",
                        "description": "Return only places that have a phone, email, website or social profile — ideal for lead lists.",
                        "default": false
                    },
                    "maxResults": {
                        "title": "Max results",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "Maximum number of places to return (1–50000). A dense urban area can hold thousands.",
                        "default": 500
                    },
                    "release": {
                        "title": "Overture release (optional)",
                        "type": "string",
                        "description": "Advanced: pin a specific Overture Maps release (e.g. \"2026-06-17.0\"). Leave blank to use the built-in current 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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```