# OpenStreetMap Places Scraper — POIs, Addresses, Opening Hours (`highbrow_fame/openstreetmap-places`) Actor

Points of interest from OpenStreetMap by place or map box: restaurants, shops, hotels, pharmacies, 62 categories or any OSM tag, with address, coordinates, opening hours and website.

- **URL**: https://apify.com/highbrow\_fame/openstreetmap-places.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.70 / 1,000 place delivereds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## OpenStreetMap Places Scraper — POIs, Addresses, Opening Hours

Get points of interest from OpenStreetMap, the free map of the world: restaurants, cafés, shops, hotels, pharmacies, fuel stations, schools and 55 more ready categories — or anything you can describe with an OSM tag. Every place comes with its name, type, coordinates, street address, opening hours, website and — for businesses and public places, as tagged in OpenStreetMap — brand, cuisine, wheelchair access and all its other OSM tags. Type a place name, paste an openstreetmap.org link, or draw a bounding box.

**Why this one**

- 🗺️ **Any place, exactly its boundary.** Type a city, a district or a postcode (Szentendre, Mitte, Berlin, 10115 Berlin) and it is searched inside its official boundary — not a rough rectangle. Or give a bounding box, or a radius around the centre of a place.
- 🏷️ **62 ready categories, or any OSM tag.** Tick restaurants, hotels, pharmacies, supermarkets, car repair … or write your own filter: `amenity=restaurant & cuisine=pizza`, `shop=bakery|pastry`, `["diet:vegan"="yes"]`.
- ⚡ **Fast.** A live test run read nine searches — restaurants, hotels and cafés with outdoor seating in Budapest, Berlin-Mitte and central Paris — 5,056 places in 4 min 41 s, waiting its turn on the public servers. The small example search (restaurants and cafés in Szentendre) takes 5-7 seconds.
- 🔒 **No private homes, no personal contacts.** Places that look like somebody's home — a holiday flat, an office or workshop in a house, a private pool, a bare address — are left out. The website is kept only for named businesses and public places; phone numbers, e-mail addresses, social accounts, operators and tax numbers are never in the output.
- 🤝 **Kind to the free servers.** It uses the public Overpass API and Nominatim within their rules: at most two queries at a time, rate limits waited out, one geocoding request a second. If a server is busy, the query moves to another public Overpass server.
- 💸 **You pay only for places delivered.** A place that OpenStreetMap does not know, a broken filter or an empty search comes back as a free record with the reason.

### What you get

For every place:

| Field | What it is |
|---|---|
| `name`, `type`, `category` | the name, the main OSM tag (`amenity=restaurant`), and the category or filter that found it |
| `lat`, `lon` | coordinates (the centre for buildings and areas) |
| `street`, `houseNumber`, `postcode`, `city`, `country`, `address` | the address as tagged in OSM, and as one line |
| `website`, `openingHours` | the website as tagged in OSM (named businesses and public places only) and opening hours in OSM syntax (`Mo-Fr 08:00-18:00`) |
| `brand`, `cuisine`, `wheelchair`, `wikidata` | chain brand, cuisines as a list, wheelchair access, Wikidata id |
| `tags` | every other OSM tag: outdoor seating, payment methods, diets, stars, capacity, … |
| `osmType`, `osmId`, `osmUrl` | the OSM object (node, way or relation) and its link |
| `dataAsOf` | the time of the OpenStreetMap data the server answered from |
| `input`, `place`, `position`, `scrapedAt`, `status`, `error` | which area it came from (and how Nominatim named it), and why a search gave nothing |

#### Example

A real record from a live run — restaurants in Szentendre, Hungary, 26 September 2026:

```json
{
  "input": "Szentendre",
  "place": "Szentendre, Szentendrei járás, Pest, Central Hungary, 2000, Hungary",
  "osmType": "node",
  "osmId": 3473873341,
  "osmUrl": "https://www.openstreetmap.org/node/3473873341",
  "name": "Parola vendéglő",
  "category": "restaurant",
  "type": "amenity=restaurant",
  "lat": 47.67545,
  "lon": 19.067667,
  "street": "Vasvári Pál utca",
  "houseNumber": "2",
  "postcode": "2000",
  "city": "Szentendre",
  "country": "HU",
  "address": "Vasvári Pál utca 2, 2000 Szentendre",
  "website": "https://parolavendeglo.hu/",
  "openingHours": "Mo-Tu 11:30-22:00; Th-Su 11:30-22:00",
  "cuisine": ["hungarian"],
  "tags": {
    "amenity": "restaurant",
    "capacity": "76",
    "diet:vegetarian": "yes",
    "outdoor_seating": "yes",
    "payment:credit_cards": "no",
    "smoking": "outside",
    "start_date": "1985",
    "…": "…"
  },
  "dataAsOf": "2026-09-26T01:33:51Z",
  "status": "OK"
}
```

### How to use it

1. Type **Places** (one per line), or paste openstreetmap.org links to a relation or way, or add **Bounding boxes** (south, west, north, east).
2. Tick **Categories**, and/or write **OSM tags** for anything else.
3. Set **Max places per search** — each place × category is one search.
4. Press **Start**, and download the results from the **Output** tab as JSON, CSV or Excel.

Leave **Only places with a name** on for business lists; turn it off to get unnamed things too (benches, car parks, post boxes). Use **Radius around the place** for "everything within 1 km of the Eiffel Tower".

You can also call it from the Apify API, from Make, Zapier or n8n, or from an AI agent through the Apify MCP server.

### Pricing

You are charged **per place delivered** — see the price on this page. Places OpenStreetMap does not know, filters that cannot be read and searches with no results are free.

### FAQ

**Where does the data come from?** From OpenStreetMap, through the public Overpass API; place names are looked up with Nominatim. The data is © OpenStreetMap contributors and available under the Open Database Licence (ODbL): if you publish it, credit "© OpenStreetMap contributors" and share derived databases under the same licence — see [openstreetmap.org/copyright](https://www.openstreetmap.org/copyright).

**How fresh is it?** Minutes old: the main Overpass servers were 1-2 minutes behind OpenStreetMap when tested. Only when all the others are busy does a query go to overpass.private.coffee, whose copy was two months old when tested — every record's `dataAsOf` says which data it came from.

**How complete is it?** As complete as OpenStreetMap is in that area — very good in most European cities, thinner in rural areas. Websites and opening hours are there when a mapper added them: in the live run over Budapest, Berlin-Mitte and central Paris (5,056 restaurants, hotels and cafés), 65% had a street address, 57% opening hours and 50% a website.

**How many places per search?** All of them — there is no paging limit: a live run delivered all 1,780 named restaurants of Budapest from one search, and found 6,501 shops in Kraków. Very large areas (a whole country for "every kind of shop") can be too heavy for the public servers; split them into regions or bounding boxes, or set **Your own Overpass server**.

**My two areas overlap — do I pay twice?** No. A place found by two searches in the same run is delivered once, under the first search that found it; a search whose places were all delivered already says so in a free record. (In a live run, Berlin-Mitte "any shop" gave 1,222 new places after the postcode 10115 inside it had taken 195.)

**Why is a place a little outside my bounding box?** A building or area that reaches into the box is included, and its point is its centre — which can lie just outside (1 of 1,892 places in a live run).

**Why no phone numbers or e-mails?** A small business often lists its owner's own mobile, so no phone number is delivered; the website is. E-mail addresses, phone numbers, social accounts and the names of operators are left out, and places that look like private homes are not delivered at all. Some small businesses carry their owner's name as their business name; it is output as the map shows it.

**Is this affiliated with OpenStreetMap?** No. This is an independent tool that reads the public OpenStreetMap data through the public Overpass and Nominatim services. It is not endorsed by the OpenStreetMap Foundation.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

# Actor input Schema

## `locations` (type: `array`):

Cities, towns, districts or postcodes (Szentendre, Mitte, Berlin, 10115 Berlin), found with OpenStreetMap's Nominatim and searched inside their boundary. Or paste an openstreetmap.org link to a relation or way (https://www.openstreetmap.org/relation/1244004). One per line.

## `boundingBoxes` (type: `array`):

Or an exact rectangle: south, west, north, east in degrees, e.g. 47.49, 19.03, 47.52, 19.08. One per line.

## `categories` (type: `array`):

What kind of places to get. Each place (or box) is searched once per category.

## `osmTags` (type: `array`):

Optional, for anything not in the list: OpenStreetMap tags as key=value (amenity=restaurant), key for any value (shop), key=a|b for either, several joined with & (amenity=restaurant & cuisine=pizza), or Overpass brackets (\["cuisine"~"pizza"]). Each line is one more category.

## `onlyNamed` (type: `boolean`):

Leaves out unnamed places (a bench, an unnamed car park). Turn off to get them too.

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

Optional: search this many km around the centre of each place instead of inside its boundary. Handy for a landmark or an address. 0 = the boundary.

## `maxPlacesPerSearch` (type: `integer`):

Stops each place × category search after this many places.

## `maxConcurrency` (type: `integer`):

How many searches run at the same time. The public Overpass servers allow two queries at a time per IP.

## `overpassUrl` (type: `string`):

The interpreter URL of an Overpass server you run or pay for, e.g. https://overpass.example.com/api/interpreter. Empty = the public servers (overpass-api.de, then maps.mail.ru and overpass.private.coffee when one is busy).

## `proxyConfiguration` (type: `object`):

Used only when a connection fails: the requests go out directly, and the servers' rate limits are waited out, not dodged.

## Actor input object example

```json
{
  "locations": [
    "Szentendre"
  ],
  "categories": [
    "restaurant",
    "cafe"
  ],
  "onlyNamed": true,
  "radiusKm": 0,
  "maxPlacesPerSearch": 30,
  "maxConcurrency": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `results` (type: `string`):

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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 = {
    "locations": [
        "Szentendre"
    ],
    "categories": [
        "restaurant",
        "cafe"
    ],
    "maxPlacesPerSearch": 30,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/openstreetmap-places").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 = {
    "locations": ["Szentendre"],
    "categories": [
        "restaurant",
        "cafe",
    ],
    "maxPlacesPerSearch": 30,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/openstreetmap-places").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "locations": [
    "Szentendre"
  ],
  "categories": [
    "restaurant",
    "cafe"
  ],
  "maxPlacesPerSearch": 30,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/openstreetmap-places --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,highbrow_fame/openstreetmap-places"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/qfczAThbckNKQGV4i/builds/ETZhdG1PEzkZTwGwU/openapi.json