# OpenStreetMap Place Search — Businesses & POIs Worldwide (`dalbian/openstreetmap-place-search`) Actor

Find businesses, amenities and points of interest anywhere in the world from OpenStreetMap, by place name, bounding box or radius, with contact details, opening hours, accessibility and the full tag detail behind each one.

- **URL**: https://apify.com/dalbian/openstreetmap-place-search.md
- **Developed by:** [Benjamin Jerez](https://apify.com/dalbian) (community)
- **Categories:** Travel, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Place Search — Businesses & POIs Worldwide

Find businesses, amenities and points of interest anywhere on Earth from OpenStreetMap: by place name, by bounding box, or in a radius around a point. Pick from **61 ready-made categories** — hotels, restaurants, pharmacies, EV chargers, campsites, museums, coworking spaces — or write raw OSM tags when you need something the list does not cover.

### Why OpenStreetMap

Most place-data Actors read a commercial map whose terms forbid storing or redistributing what you extract. OpenStreetMap is different: it is a public database under the **Open Database License**, built to be reused, downloaded and republished. You can keep it, join it to your own data, ship it inside your product and sell the result, provided you credit OpenStreetMap and keep derived databases under the same licence.

It also carries detail commercial sources flatten away. A restaurant in OSM can tell you its cuisine, whether it has outdoor seating, whether it delivers, whether it is wheelchair accessible, whether it serves vegan food and what hours it keeps. A hotel can tell you its star rating and room count. A charging station can tell you its socket types and capacity. This Actor lifts all of that into named columns.

### An honest word on coverage

OpenStreetMap is volunteer-mapped, so completeness varies enormously by place and by category. In a European city centre, expect most restaurants to be present but only a third to carry a phone number. In a rural area or outside Europe, coverage can be thin.

Rather than let you discover that after you have built something on it, every run returns the numbers: how many places were found, and what share of them carry a name, a phone, a website and opening hours. Avignon searched for restaurants, hotels and museums returns 199 places, of which 33% have a phone and 28% have opening hours. Now you know what you are working with.

### Three ways to define an area

**Place names** are resolved to their official boundary. Be specific enough to be unambiguous — `Avignon, France` rather than `Avignon`, because there is more than one.

**Bounding boxes** as `south,west,north,east` when you already know the exact extent and want no ambiguity at all.

**Points with a radius** when you care about walking distance rather than administrative lines — a station, a hotel, a site you are evaluating.

### What comes back

One summary row per area with the counts and completeness shares, then one row per place:

| Field | Example |
| --- | --- |
| `name`, `primaryCategory` | Hôtel du Palais des Papes, `tourism=hotel` |
| `address`, `city`, `postcode` | 3 Place du Palais, Avignon |
| `phone`, `website`, `email` | +33 4 90 86 04 13 |
| `openingHours` | `Su-Th 12:00-13:45, 19:00-21:30` |
| `cuisine`, `stars`, `rooms`, `capacity` | regional / 3 |
| `wheelchair`, `outdoorSeating`, `takeaway`, `delivery` | yes |
| `latitude`, `longitude`, `osmUrl` | 43.9503, 4.8079 |

`matchedTags` records every filter a place matched, so a venue that is both a bar and a restaurant is visible as both.

### Who uses this

Location intelligence and site-selection teams counting competitors and footfall generators. Travel and hospitality products building an inventory they are allowed to keep. Logistics and field-service planners mapping fuel, parking and charging. Retail and franchise expansion comparing catchment areas. Accessibility and mobility projects, for which OSM is often the only source that records step-free access at all. Researchers who need a reproducible, citable extract rather than a screen-scrape.

### Fair use

Overpass, the query engine behind this Actor, is donated infrastructure shared by the whole OpenStreetMap community. Requests are therefore sent one at a time, never in parallel, with automatic fallback across three public mirrors and a polite pause between geocoding calls. If a very large area combined with a very high cap times out, narrow the area rather than raising the cap — that is the behaviour that keeps the service available to everyone.

### Licence and attribution

Data is **© OpenStreetMap contributors**, available under the [Open Database License](https://www.openstreetmap.org/copyright). If you publish anything derived from this output you must credit OpenStreetMap, and if you publish a derived *database* you must license it under ODbL as well. Geocoding of place names uses Nominatim, operated by the OpenStreetMap Foundation.

### Frequently asked

**Why does a place have no address?**
Because nobody has mapped one. OSM records what contributors have surveyed; a restaurant can have a name and coordinates but no street number. The completeness shares in the summary row tell you how often this happens in your area.

**Can I search a whole country?**
Technically yes, practically no — a national query on a common tag will exceed what a shared Overpass instance will do for one user. Split it by region or city.

**Is this a Google Maps replacement?**
For legal reuse and for rich attributes, often yes. For sheer completeness of small businesses in some countries, no. The honest answer depends on your area, which is exactly why the coverage figures are returned.

**Does the summary count towards my place charges?**
No. Areas and places are charged separately, and an area that returns nothing is charged only as an area.

# Actor input Schema

## `places` (type: `array`):

Towns, cities, districts or regions, one per line. Each is resolved to its boundary by Nominatim, so be specific enough to avoid the wrong continent — 'Avignon, France' rather than 'Avignon'.

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

Explicit boxes as 'south,west,north,east' in WGS84 degrees, one per line. Use these when you already know the exact extent and want no ambiguity from a place name.

## `aroundPoints` (type: `array`):

Search a circle around each point, given as 'longitude,latitude', longitude first as in GeoJSON. This follows walking distance rather than administrative boundaries.

## `radiusMeters` (type: `integer`):

Radius around each point above. Only applies to the points, not to place names or boxes.

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

What to look for. Each friendly name expands to the OpenStreetMap tags that actually find it, so you do not need to know that a doctor is amenity=doctors and a supermarket is shop=supermarket. Pick several to compare them in one run.

## `customTags` (type: `array`):

Raw OpenStreetMap filters as key=value, one per line, for anything the categories do not cover — for example 'amenity=ice\_cream' or 'shop=\*' for every shop. These are added to the categories above, not instead of them.

## `namedPlacesOnly` (type: `boolean`):

Drop features with no name. OpenStreetMap contains many unnamed objects — a bench, an untitled parking area — which are noise in a business list but matter for infrastructure work.

## `includeStatistics` (type: `boolean`):

Return a summary row per area: how many places were found, the breakdown by category, and what share carry a phone number, a website or opening hours. That last figure tells you how complete the local mapping is before you rely on it.

## `maxPlacesPerArea` (type: `integer`):

Hard cap per area. Overpass is donated infrastructure with fair-use limits, so a very large area combined with a very high cap may time out; narrow the area instead of raising this.

## Actor input object example

```json
{
  "places": [
    "Avignon, France"
  ],
  "radiusMeters": 2000,
  "categories": [
    "restaurants"
  ],
  "namedPlacesOnly": false,
  "includeStatistics": true,
  "maxPlacesPerArea": 500
}
```

# Actor output Schema

# 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 = {
    "places": [
        "Avignon, France"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dalbian/openstreetmap-place-search").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 = { "places": ["Avignon, France"] }

# Run the Actor and wait for it to finish
run = client.actor("dalbian/openstreetmap-place-search").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 '{
  "places": [
    "Avignon, France"
  ]
}' |
apify call dalbian/openstreetmap-place-search --silent --output-dataset

```

## MCP server setup

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

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/qQeGANKSgdsToIrls/builds/kFY5JAxjkvXCpy0hK/openapi.json