# OpenStreetMap POI Extractor (`automation-lab/openstreetmap-poi-extractor`) Actor

Extract POIs from OpenStreetMap via Overpass API. Search by location + radius or bounding box. Filter by 20+ categories (restaurants, hotels, hospitals, parks, shops). Outputs name, coords, address, phone, website, opening hours. No API key needed.

- **URL**: https://apify.com/automation-lab/openstreetmap-poi-extractor.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** E-commerce
- **Stats:** 3 total users, 2 monthly users, 75.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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

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

## What's an Apify Actor?

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

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

## OpenStreetMap POI Extractor

Extract **points-of-interest (POIs)** from [OpenStreetMap](https://www.openstreetmap.org/) using the free Overpass API — no API key needed. Search restaurants, hotels, hospitals, shops, parks, and 20+ other categories by location name + radius or precise bounding box. Get name, coordinates, address, phone, website, opening hours, and all OSM tags for every place.

### What does OpenStreetMap POI Extractor do?

OpenStreetMap POI Extractor queries the [Overpass API](https://wiki.openstreetmap.org/wiki/Overpass_API) — a free, read-only API for the OpenStreetMap dataset — to find and extract points-of-interest in any area worldwide. Just enter a location name (e.g., "Vienna, Austria") and a search radius, pick a category, and the actor returns structured data for every matching place.

You can search for restaurants, hotels, hospitals, parks, museums, shops, banks, gyms, and more. Advanced users can write custom [Overpass QL](https://wiki.openstreetmap.org/wiki/Overpass_API/Language_Guide) queries for any OSM tag combination. All output fields are structured and flat — ready for CSV/JSON export, Google Sheets import, or database ingestion.

### Who is OpenStreetMap POI Extractor for?

**📊 Researchers and data analysts** who need geospatial datasets without spending money on premium APIs. Build datasets of restaurants, green spaces, healthcare facilities, or educational institutions for any city or region worldwide. Export to CSV and analyze in Excel, Python, or R.

**🏙️ Urban planners and academics** studying city infrastructure, accessibility, or service distribution. Extract wheelchair-accessible venues, healthcare coverage, school density, or park availability across administrative boundaries.

**📱 App developers and GIS professionals** who need POI seed data for maps, routing apps, or location services. OpenStreetMap's global coverage and community-maintained tags make it an excellent alternative to commercial POI databases.

**💼 Market researchers and business analysts** identifying competitor locations, mapping service gaps, or analyzing local market saturation. Find all coffee shops, hotels, or pharmacies in a target area without expensive data purchases.

**🤖 Automation teams** building pipelines that periodically refresh local business data for dashboards, reports, or alerting systems.

### Why use OpenStreetMap POI Extractor?

- ✅ **No API key required** — Overpass API is 100% free and public
- ✅ **Global coverage** — OSM data exists for every country and city
- ✅ **20+ preset categories** — restaurants, hotels, hospitals, parks, shops, banks, and more
- ✅ **Custom queries** — write any Overpass QL query for advanced use cases
- ✅ **Geocoding included** — enter a city name, no need to look up coordinates
- ✅ **Structured output** — name, coordinates, full address, phone, website, opening hours
- ✅ **No login, no browser, no proxy** — pure HTTP actor, fast and lightweight
- ✅ **Apify platform benefits** — schedule runs, export CSV/JSON/Excel, connect to 5,000+ apps

### What data can you extract?

| Field | Description | Example |
|-------|-------------|---------|
| `osmId` | OpenStreetMap element ID | `76514684` |
| `osmType` | Element type (node/way/relation) | `"node"` |
| `name` | Place name | `"Pizza Bizi"` |
| `category` | Search category used | `"restaurants"` |
| `lat` | Latitude | `48.2096466` |
| `lon` | Longitude | `16.3736843` |
| `address.street` | Street name | `"Rotenturmstraße"` |
| `address.houseNumber` | House number | `"4"` |
| `address.city` | City/town | `"Wien"` |
| `address.postcode` | Postal code | `"1010"` |
| `address.country` | Country code | `"AT"` |
| `phone` | Phone number | `"+43 1 5133705"` |
| `website` | Website URL | `"https://www.pizzabizi.at/"` |
| `openingHours` | OSM opening hours string | `"Mo-Su 11:00-24:00"` |
| `wheelchair` | Wheelchair accessibility | `"yes"` / `"no"` / `"limited"` |
| `extras` | All other OSM tags (optional) | `{"cuisine": "italian"}` |

### How much does it cost to extract POIs from OpenStreetMap?

OpenStreetMap POI Extractor uses **pay-per-event (PPE) pricing** — you only pay for what you extract.

| Event | FREE tier | BRONZE | SILVER | GOLD |
|-------|-----------|--------|--------|------|
| Run start | $0.005 | $0.005 | $0.0043 | $0.00375 |
| Per POI extracted | $0.0008 | $0.00072 | $0.00064 | $0.00052 |

**Real-world cost examples:**
- 50 restaurants in a city center (~2 km radius): ~$0.045
- 500 hotels in a country capital: ~$0.365
- 1,000 shops in a major shopping district: ~$0.725

**Free plan estimate:** Apify's free $5/month credit gets you approximately **6,000 POIs** on the FREE tier — plenty for research projects and testing.

### How to extract POIs from OpenStreetMap

1. Go to [OpenStreetMap POI Extractor on Apify Store](https://apify.com/automation-lab/openstreetmap-poi-extractor)
2. Click **Try for free** to open the actor
3. Enter a **location name** (e.g., "Berlin, Germany") in the Location field
4. Set a **search radius** in kilometers (e.g., 5 km for a city center)
5. Select a **category** from the dropdown (restaurants, hotels, hospitals, etc.)
6. Optionally set **Max POIs** to limit results for testing
7. Click **Start** to begin extraction
8. Download results as **JSON, CSV, or Excel** from the dataset

**Example inputs for different use cases:**

```json
// Find all restaurants in central Paris (2 km radius)
{
    "location": "Paris, France",
    "radiusKm": 2,
    "category": "restaurants",
    "maxItems": 200
}
````

```json
// Extract hotels in a precise area using bounding box
{
    "boundingBox": "48.18,16.33,48.24,16.42",
    "category": "hotels"
}
```

```json
// Custom Overpass query for bicycle parking in Vienna
{
    "category": "custom",
    "customQuery": "[out:json][timeout:60];\n(\n  node[\"amenity\"=\"bicycle_parking\"](48.18,16.33,48.24,16.42);\n);\nout center;"
}
```

### Input parameters

| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `location` | string | — | City or address to search around. Geocoded automatically via Nominatim. |
| `radiusKm` | integer | `2` | Search radius in km around location. Min 0, max 100. |
| `boundingBox` | string | — | Precise area as `"south,west,north,east"` coordinates. Alternative to location+radius. |
| `category` | string | `"restaurants"` | Category preset. See full list below. |
| `customQuery` | string | — | Full Overpass QL query. Used when category is `"custom"`. |
| `maxItems` | integer | `0` | Max POIs to extract. `0` = unlimited. |
| `includeAllTags` | boolean | `false` | Include all raw OSM tags in `extras` field. |
| `overpassEndpoint` | string | — | Custom Overpass API server. Defaults to `overpass-api.de`. |

**Available categories:** `restaurants`, `cafes`, `bars`, `fast_food`, `hotels`, `shops`, `supermarkets`, `hospitals`, `pharmacies`, `schools`, `universities`, `parks`, `museums`, `attractions`, `banks`, `parking`, `fuel`, `post_offices`, `police`, `fire_stations`, `gyms`, `cinemas`, `all_amenities`, `custom`

### Output examples

**Single restaurant record:**

```json
{
    "osmId": 76514684,
    "osmType": "node",
    "name": "Pizza Bizi",
    "category": "restaurants",
    "lat": 48.2096466,
    "lon": 16.3736843,
    "address": {
        "street": "Rotenturmstraße",
        "houseNumber": "4",
        "city": "Wien",
        "postcode": "1010",
        "country": "AT",
        "countryCode": "AT",
        "state": null
    },
    "phone": "+43 1 5133705",
    "website": "https://www.pizzabizi.at/",
    "openingHours": "Mo-Su,PH 11:00-24:00",
    "wheelchair": "no",
    "extras": {}
}
```

**Hospital record with extras enabled:**

```json
{
    "osmId": 499319990,
    "osmType": "node",
    "name": "NHS Soho Walk-In Centre",
    "category": "hospitals",
    "lat": 51.5145964,
    "lon": -0.132073,
    "address": { "street": null, "city": null, ... },
    "phone": null,
    "website": null,
    "openingHours": null,
    "wheelchair": null,
    "extras": {
        "healthcare": "clinic",
        "healthcare:speciality": "minor_injuries",
        "operator": "NHS"
    }
}
```

### Tips for best results

- 🎯 **Start small** — use `maxItems: 50` to preview results before extracting thousands of POIs
- 📍 **Be specific with location names** — "Paris, France" works better than just "Paris"
- 🗺️ **Use bounding box for precise areas** — copy coordinates from [bbox.2live.de](https://bbox.2live.de/) or [bboxfinder.com](http://bboxfinder.com/)
- 🏷️ **Enable `includeAllTags`** for research — OSM tags contain cuisine type, seating capacity, email, social media, accessibility details, and more
- ⚡ **Large areas return more results** — a 10 km radius in a major city may return 5,000+ restaurants; use `maxItems` to cap costs
- 🔁 **Schedule runs** to detect new or closed venues over time (Apify's built-in scheduler works great for monthly refreshes)
- 🔍 **Custom queries** let you filter by multiple tags — e.g., only vegan restaurants (`amenity=restaurant` + `diet:vegan=yes`)

### Integrations

**OpenStreetMap POI Extractor → Google Sheets**
Extract all restaurants in your city and pipe results directly to Google Sheets via the Apify → Google Sheets integration. Refresh weekly to detect new openings. Build a live competitor map without any manual data entry.

**OpenStreetMap POI Extractor → Slack/Discord alerts**
Schedule a daily run to detect new hospitals, clinics, or healthcare facilities in your target area. When new POIs appear, trigger a Slack webhook to notify your research team automatically.

**OpenStreetMap POI Extractor → Make (Integromat) / Zapier**
Connect extracted POI data to your CRM, send location data to field sales teams, or auto-populate a property management system with nearby amenities. The flat JSON output maps directly to most form fields.

**Batch multi-city extraction via Apify API**
Use the API to queue extractions for 50 cities at once. Each run targets a single city; your pipeline aggregates results into a master dataset for cross-market analysis.

**Scheduled accessibility audits**
Run the actor monthly with `category: "all_amenities"` and `includeAllTags: true` to track changes in `wheelchair` accessibility tags across a neighborhood. Use this for urban planning or disability advocacy research.

### Using the Apify API

**Node.js**

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

const client = new ApifyClient({ token: 'YOUR_APIFY_TOKEN' });

const run = await client.actor('automation-lab/openstreetmap-poi-extractor').call({
    location: 'Vienna, Austria',
    radiusKm: 2,
    category: 'restaurants',
    maxItems: 100,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} POIs`);
```

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient(token="YOUR_APIFY_TOKEN")

run = client.actor("automation-lab/openstreetmap-poi-extractor").call(run_input={
    "location": "Berlin, Germany",
    "radiusKm": 3,
    "category": "hotels",
    "maxItems": 200,
})

items = client.dataset(run["defaultDatasetId"]).list_items().items
print(f"Extracted {len(items)} POIs")
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/automation-lab~openstreetmap-poi-extractor/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "location": "Tokyo, Japan",
    "radiusKm": 1,
    "category": "parks",
    "maxItems": 50
  }'
```

### Use with AI agents via MCP

OpenStreetMap POI Extractor is available as a tool for AI assistants that support the [Model Context Protocol (MCP)](https://docs.apify.com/platform/integrations/mcp).

Add the Apify MCP server to your AI client — this gives you access to all Apify actors, including this one:

#### Setup for Claude Code

```bash
claude mcp add --transport http apify "https://mcp.apify.com"
```

#### Setup for Claude Desktop, Cursor, or VS Code

Add this to your MCP config file:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com"
        }
    }
}
```

Your AI assistant will use OAuth to authenticate with your Apify account on first use.

#### Example prompts

Once connected, try asking your AI assistant:

- "Use automation-lab/openstreetmap-poi-extractor to find all restaurants within 2 km of the Eiffel Tower and save results to a CSV file"
- "Extract all hospitals and clinics in Vienna, Austria using the OpenStreetMap POI extractor, then show me which ones are wheelchair accessible"
- "Find all parks and green spaces in a 5 km radius around Central Park, New York using OpenStreetMap data"

Learn more in the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp).

### Is it legal to extract OpenStreetMap data?

Yes. OpenStreetMap data is published under the [Open Database License (ODbL)](https://opendatacommons.org/licenses/odbl/), which permits free use, sharing, and adaptation — including commercial use — as long as you attribute OpenStreetMap contributors and share any derived databases under the same license.

This actor queries the **Overpass API**, which is the official read-only API for OpenStreetMap data. It is designed for exactly this type of programmatic access. The actor follows Overpass API best practices by:

- Using a descriptive `User-Agent` header identifying the application
- Respecting rate limits with delays between requests
- Not storing OSM data beyond the actor's dataset output

For your own use case, review the [OSM copyright guidelines](https://www.openstreetmap.org/copyright) and add attribution in any published work. **This actor is intended for research, business intelligence, and application development using lawfully accessible public data.**

### FAQ

**How accurate is OpenStreetMap POI data?**
OSM data quality varies by region. Major cities in Europe and North America have excellent coverage (often better than Google Maps for specialized places). Rural areas or less-mapped countries may have sparser data. OSM is community-maintained and updated continuously — millions of edits happen every week.

**How fast does the actor run?**
For most queries (under 1,000 POIs), the actor completes in under 30 seconds. The Overpass API typically responds in 5-15 seconds. Larger areas with thousands of results may take 60-120 seconds due to Overpass processing time.

**How much does it cost to extract 1,000 restaurants?**
At the FREE tier price of $0.0008/POI + $0.005 start fee: 1,000 × $0.0008 + $0.005 = **$0.805**. On the GOLD tier (business subscribers): 1,000 × $0.00052 + $0.00375 = **$0.524**. Apify's free $5/month credit gets you ~6,000 POIs on the FREE tier.

**Why do some POIs have null address or phone fields?**
OSM is a community-contributed dataset — not all places have complete address or contact information. Many nodes have a name and coordinates but no structured address tags. Enabling `includeAllTags: true` may reveal additional fields like `contact:email`, `contact:facebook`, or informal address notes in other tag keys.

**Why are results empty for my location?**
First check that your location name is recognized (try a more specific format like "City, Country"). Second, some areas have sparse OSM coverage — try a larger `radiusKm`. Third, some categories like `museums` have fewer POIs than `restaurants` — the search is working correctly, there may just be fewer mapped places in that area.

**Can I filter by sub-categories, like vegan restaurants or 5-star hotels?**
Yes — use the `custom` category with an Overpass QL query. For example, to find vegan restaurants:

```
[out:json][timeout:60];
(node["amenity"="restaurant"]["diet:vegan"="yes"](LAT1,LON1,LAT2,LON2););
out center;
```

See the [OSM Map Features wiki](https://wiki.openstreetmap.org/wiki/Map_features) for all available tags.

**The actor runs but returns fewer results than expected — why?**
If you search a very small radius (under 0.5 km) or a category with few POIs, fewer results are normal. For dense categories in large cities, increase `radiusKm` or use a bounding box covering the full city. Note that OSM coverage for some business types (e.g., specific shop subtypes) may be incomplete in certain regions.

### Other location data tools

- [Google Maps Lead Finder](https://apify.com/automation-lab/google-maps-lead-finder) — extract business leads from Google Maps with reviews, ratings, and contact details
- [AAAA Record Checker](https://apify.com/automation-lab/aaaa-record-checker) — check IPv6 DNS records for domains in bulk
- [Accessibility Checker](https://apify.com/automation-lab/accessibility-checker) — scan websites for WCAG accessibility violations
- [Ads.txt Checker](https://apify.com/automation-lab/ads-txt-checker) — validate ads.txt files for publisher compliance
- [Anti-Blocking Diagnostics](https://apify.com/automation-lab/anti-blocking-diagnostics) — test your scraping setup against bot detection systems

# Actor input Schema

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

Enter a city, neighborhood, or address to search around. The actor geocodes this to coordinates automatically. Example: "Vienna, Austria" or "Times Square, New York".

## `radiusKm` (type: `integer`):

Radius in kilometers around the location. Only used when 'Location name' is set. Default: 2 km.

## `boundingBox` (type: `string`):

Precise area as "south,west,north,east" coordinates. Example: "48.18,16.33,48.24,16.42". Leave empty to use Location name + radius instead.

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

Type of places to extract. Choose a preset category or "custom" to write your own Overpass query.

## `customQuery` (type: `string`):

Full Overpass QL query to execute. Only used when Category is set to "custom". Example: \[out:json]\[timeout:60];(node["amenity"="bicycle\_parking"](48.18,16.33,48.24,16.42););out center;

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

Maximum number of POIs to extract. Set to 0 for unlimited. Useful for testing or controlling costs.

## `includeAllTags` (type: `boolean`):

Include all raw OpenStreetMap tags in the 'extras' field of each POI. Useful for advanced analysis but increases output size.

## `overpassEndpoint` (type: `string`):

Custom Overpass API server URL. Leave empty to use the default public server (overpass-api.de). Use a private instance for high-volume runs.

## Actor input object example

```json
{
  "location": "Vienna, Austria",
  "radiusKm": 2,
  "category": "restaurants",
  "maxItems": 50,
  "includeAllTags": false
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "location": "Vienna, Austria",
    "radiusKm": 2,
    "category": "restaurants",
    "maxItems": 50,
    "includeAllTags": false
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/openstreetmap-poi-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 = {
    "location": "Vienna, Austria",
    "radiusKm": 2,
    "category": "restaurants",
    "maxItems": 50,
    "includeAllTags": False,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/openstreetmap-poi-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 '{
  "location": "Vienna, Austria",
  "radiusKm": 2,
  "category": "restaurants",
  "maxItems": 50,
  "includeAllTags": false
}' |
apify call automation-lab/openstreetmap-poi-extractor --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "OpenStreetMap POI Extractor",
        "description": "Extract POIs from OpenStreetMap via Overpass API. Search by location + radius or bounding box. Filter by 20+ categories (restaurants, hotels, hospitals, parks, shops). Outputs name, coords, address, phone, website, opening hours. No API key needed.",
        "version": "0.1",
        "x-build-id": "jbpdQPMtFOpQpfy6O"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~openstreetmap-poi-extractor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-openstreetmap-poi-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~openstreetmap-poi-extractor/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-openstreetmap-poi-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~openstreetmap-poi-extractor/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-openstreetmap-poi-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": {
                    "location": {
                        "title": "📍 Location name",
                        "type": "string",
                        "description": "Enter a city, neighborhood, or address to search around. The actor geocodes this to coordinates automatically. Example: \"Vienna, Austria\" or \"Times Square, New York\"."
                    },
                    "radiusKm": {
                        "title": "Search radius (km)",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Radius in kilometers around the location. Only used when 'Location name' is set. Default: 2 km.",
                        "default": 2
                    },
                    "boundingBox": {
                        "title": "Bounding box",
                        "type": "string",
                        "description": "Precise area as \"south,west,north,east\" coordinates. Example: \"48.18,16.33,48.24,16.42\". Leave empty to use Location name + radius instead."
                    },
                    "category": {
                        "title": "🏷️ Category",
                        "enum": [
                            "restaurants",
                            "cafes",
                            "bars",
                            "fast_food",
                            "hotels",
                            "shops",
                            "supermarkets",
                            "hospitals",
                            "pharmacies",
                            "schools",
                            "universities",
                            "parks",
                            "museums",
                            "attractions",
                            "banks",
                            "parking",
                            "fuel",
                            "post_offices",
                            "police",
                            "fire_stations",
                            "gyms",
                            "cinemas",
                            "all_amenities",
                            "custom"
                        ],
                        "type": "string",
                        "description": "Type of places to extract. Choose a preset category or \"custom\" to write your own Overpass query.",
                        "default": "restaurants"
                    },
                    "customQuery": {
                        "title": "Custom Overpass query",
                        "type": "string",
                        "description": "Full Overpass QL query to execute. Only used when Category is set to \"custom\". Example: [out:json][timeout:60];(node[\"amenity\"=\"bicycle_parking\"](48.18,16.33,48.24,16.42););out center;"
                    },
                    "maxItems": {
                        "title": "Max POIs",
                        "minimum": 0,
                        "type": "integer",
                        "description": "Maximum number of POIs to extract. Set to 0 for unlimited. Useful for testing or controlling costs.",
                        "default": 0
                    },
                    "includeAllTags": {
                        "title": "Include all OSM tags",
                        "type": "boolean",
                        "description": "Include all raw OpenStreetMap tags in the 'extras' field of each POI. Useful for advanced analysis but increases output size.",
                        "default": false
                    },
                    "overpassEndpoint": {
                        "title": "Overpass API endpoint",
                        "type": "string",
                        "description": "Custom Overpass API server URL. Leave empty to use the default public server (overpass-api.de). Use a private instance for high-volume runs."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```