# Tourist Attractions & Museums Scraper – OpenStreetMap (`dataquarry/tourist-attractions`) Actor

Extract tourist attractions, museums, galleries & public artworks from OpenStreetMap by area, radius, or name. Includes Wikidata/Wikipedia links, fee, website and address. No API key; open (ODbL) data.

- **URL**: https://apify.com/dataquarry/tourist-attractions.md
- **Developed by:** [Daniel Brenner](https://apify.com/dataquarry) (community)
- **Categories:** Travel, Lead generation, Developer tools
- **Stats:** 4 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Tourist Attractions & Museums Scraper – OpenStreetMap

Extract **tourist attractions, museums, galleries and public artworks from OpenStreetMap** by area, radius, or name — **no API key, no ticketing-site scraping, no anti-bot battles**. Open, legal (ODbL) data you can redistribute.

Give it an area like `"Florence, Italy"` and get back tidy rows for every attraction: name, **attraction type**, entry **fee**, **Wikidata & Wikipedia links**, website, full address, coordinates, and the raw OpenStreetMap tags. You can also search **around a landmark** (everything within X km) or **filter by name** (e.g. every `"National"` museum).

### Why use this scraper?

- **Built-in Wikidata & Wikipedia links.** Many attractions carry a `wikidata` QID and `wikipedia` article — perfect for enrichment, knowledge graphs, and AI/RAG pipelines. We surface them directly.
- **Tourism-specific fields.** `attraction_type`, `fee`, operator and accessibility — parsed out of the OpenStreetMap tags.
- **Legal & open.** OpenStreetMap data is ODbL-licensed — redistributable with attribution. No login, no ticketing-platform Terms-of-Service issues.
- **No API key.** No tourism/maps developer account, no quota.
- **Search by area, radius, or name.** A whole city/region, everything within X metres of a landmark, or every place matching a name.
- **Filter by type.** Museums only, or galleries + artworks, etc.
- **No duplicates.** When OpenStreetMap maps one site twice (a node and an outline), you get a single, richer row.
- **Honest data.** Every value comes straight from OpenStreetMap; anything not mapped is left empty (`null`) — never guessed.
- **Global coverage & reliable.** Anywhere OSM has data; retries across multiple Overpass mirrors.

### Great for

- Travel apps, itinerary & trip planners, city-guide datasets
- Tourism market research and cultural/heritage mapping
- Knowledge-graph / RAG enrichment (via the Wikidata/Wikipedia links)
- Things-to-do directories and dashboards

### Input

| Field | Type | Description |
|---|---|---|
| `area` | string | Place to search within, e.g. `"Rome, Italy"`. Geocoded to a bounding box. |
| `aroundLocation` | string | *(optional)* Landmark/place to search **around** within a radius. Pair with `radiusMeters`. |
| `radiusMeters` | integer | *(optional)* Radius in metres for around-a-location search (default `5000`). |
| `centerPoint` | object | *(advanced)* Explicit center `{ "lat":.., "lon":.. }` to search around. |
| `boundingBox` | object | *(advanced)* Explicit `{ "south":.., "west":.., "north":.., "east":.. }`. Overrides `area`. |
| `attractionTypes` | array | *(optional)* Which types to include: `attraction`, `museum`, `gallery`, `artwork`, `theme_park`, `zoo`, `viewpoint`. Default: all. |
| `searchTerm` | string | *(optional)* Only return places whose **name** contains this text (case-insensitive), e.g. `"National"`. |
| `maxResults` | integer | Maximum number of attractions to return (default `1000`). |

#### Example input

```json
{
  "area": "Florence, Italy",
  "attractionTypes": ["attraction", "museum", "gallery"],
  "maxResults": 500
}
```

Every museum within 3 km of a landmark:

```json
{
  "aroundLocation": "Colosseum, Rome",
  "radiusMeters": 3000,
  "attractionTypes": ["museum"]
}
```

### Output

One row per attraction:

| Field | Description |
|---|---|
| `name` | Attraction name |
| `attraction_type` | attraction / museum / gallery / artwork / theme\_park / zoo / viewpoint |
| `fee` | Entry fee flag (yes / no / donation / unknown) |
| `wikidata` | Wikidata QID (e.g. `Q2723633`) |
| `wikipedia` | Wikipedia article (e.g. `en:Charles Dickens Museum`) |
| `operator`, `brand` | Operator (e.g. National Trust) and brand |
| `branch` | Branch / location name of a chain outlet (OSM `branch`), e.g. `Times Square`; null when not a tagged branch |
| `wheelchair` | Accessibility |
| `latitude`, `longitude` | Coordinates |
| `street`, `housenumber`, `city`, `postcode`, `country` | Address |
| `state` | State / province (`addr:state` / `addr:province`); common in US/CA/AU, null where not tagged |
| `phone`, `email`, `website`, `opening_hours` | Contact + hours |
| `osm_id`, `osm_type`, `all_tags`, `source_url` | OpenStreetMap identifiers, raw tags, and link |
| `full_address` | All present address parts in one string (e.g. `Main St 1, 10115 Berlin`) |
| `map_url` | Google Maps link to the coordinates |

#### Example output

```json
{
  "name": "Charles Dickens Museum",
  "attraction_type": "museum",
  "fee": "yes",
  "wikidata": "Q2723633",
  "wikipedia": "en:Charles Dickens Museum",
  "operator": null,
  "city": "London",
  "country": "GB",
  "website": "https://example.test/",
  "opening_hours": "Tu-Su 10:00-17:00",
  "latitude": 51.5234,
  "longitude": -0.1166,
  "osm_type": "way",
  "source_url": "https://www.openstreetmap.org/way/..."
}
```

Any field is `null` when the attraction hasn't tagged it in OpenStreetMap — values are never guessed.

### FAQ

**Do I need an API key or account?**
No — give it an area (plus optional radius/name filters) and run. No data-provider key, no quota, no setup.

**Is the data legal to use and redistribute?**
Yes. It comes from OpenStreetMap under the Open Database License (ODbL): public data you can redistribute with attribution (© OpenStreetMap contributors). No logins, no Terms-of-Service violations.

**How is this different from a Google Maps or TripAdvisor scraper?**
It uses open OpenStreetMap data instead of scraping a site behind anti-bot defenses and Terms of Service — so it's legal, needs no API key, and returns an honest `null` for anything OSM hasn't mapped instead of guessing. Each attraction also carries its Wikidata/Wikipedia links where mapped.

**How much does it cost?**
Pay-per-result: **$3 per 1,000 results** — you only pay for the rows you actually get.

**Which countries does it cover?**
Worldwide — anywhere OpenStreetMap has data.

**How fresh is the data?**
It's pulled live from OpenStreetMap at run time, so it reflects the current map.

### Data source & license

Data comes from **OpenStreetMap** via the public **Nominatim** (geocoding) and **Overpass** (querying) APIs. OpenStreetMap data is **© OpenStreetMap contributors**, licensed under the **Open Database License (ODbL)**. If you publish or redistribute results, attribute "© OpenStreetMap contributors".

### Notes

- Coverage and tag richness vary by region — OSM is community-mapped, so cities are richer than rural areas.
- `wikidata` / `wikipedia` are present only where the OSM community has added them (a large share of notable attractions do).

⭐ **Found this useful?** A quick rating on this actor's Store page helps others discover it — and if something is off or you wish it did more, open an issue on the actor. I read every one.

### More OpenStreetMap data actors

Part of **dataquarry**'s family of clean, ODbL OpenStreetMap extractors — same flexible **area / radius / bounding-box / name** search, same honest-null data (a field that isn't mapped is left empty, never guessed):

- [OpenStreetMap Places Scraper](https://apify.com/dataquarry/osm-places-scraper) — POI & local business, 115+ categories
- [EV Charging Stations Scraper](https://apify.com/dataquarry/ev-charging-stations) — socket types, power (kW), networks
- [Hotels & Lodging Scraper](https://apify.com/dataquarry/hotels-lodging) — stars, rooms, brands
- [Healthcare Facilities Scraper](https://apify.com/dataquarry/healthcare-facilities) — pharmacies, doctors, dentists, clinics
- [Tourist Attractions & Museums Scraper](https://apify.com/dataquarry/tourist-attractions) — Wikidata & Wikipedia links
- [Fuel Station Scraper](https://apify.com/dataquarry/fuel-stations) — fuel types, brands, payment methods
- [Supermarket & Grocery Scraper](https://apify.com/dataquarry/supermarkets) — brands, organic, payment methods

# Actor input Schema

## `area` (type: `string`):

Place to search within, e.g. "Rome, Italy". Geocoded to a bounding box via Nominatim. Provide this OR a bounding box OR a center for radius search.

## `aroundLocation` (type: `string`):

Optional. An address or landmark to search AROUND within a radius. Geocoded to a center point; set the radius with "radiusMeters".

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

Radius in meters for the around-a-location search. Default 5000.

## `centerPoint` (type: `object`):

Optional advanced alternative: an explicit center as {"lat":.., "lon":..}. Overrides Around Location.

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

Explicit bounding box as {"south":..,"west":..,"north":..,"east":..}. Overrides Area.

## `attractionTypes` (type: `array`):

Which types to include. Supported: attraction, museum, gallery, artwork, theme\_park, zoo, viewpoint. Default: all of them.

## `searchTerm` (type: `string`):

Optional. Only return places whose name contains this text (case-insensitive), e.g. "National", "Modern".

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

Maximum number of attractions to return.

## Actor input object example

```json
{
  "area": "Florence, Italy",
  "radiusMeters": 5000,
  "attractionTypes": [
    "attraction",
    "museum",
    "gallery"
  ],
  "maxResults": 1000
}
```

# 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 = {
    "area": "Florence, Italy",
    "attractionTypes": [
        "attraction",
        "museum",
        "gallery"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataquarry/tourist-attractions").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 = {
    "area": "Florence, Italy",
    "attractionTypes": [
        "attraction",
        "museum",
        "gallery",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dataquarry/tourist-attractions").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 '{
  "area": "Florence, Italy",
  "attractionTypes": [
    "attraction",
    "museum",
    "gallery"
  ]
}' |
apify call dataquarry/tourist-attractions --silent --output-dataset

```

## MCP server setup

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

```

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/GPfQgv9KeybQWuJBY/builds/efhtb7QGqJvDs3tBU/openapi.json