# Hotels & Lodging Scraper – OpenStreetMap Hotel Data (`dataquarry/hotels-lodging`) Actor

Extract hotels, hostels, guest houses, motels & apartments from OpenStreetMap by area, radius, or name. Get stars, room count, brand, operator, contact and address. No API key; open (ODbL) data.

- **URL**: https://apify.com/dataquarry/hotels-lodging.md
- **Developed by:** [Daniel Brenner](https://apify.com/dataquarry) (community)
- **Categories:** Travel, Lead generation, Real estate
- **Stats:** 2 total users, 0 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

## Hotels & Lodging Scraper – OpenStreetMap Hotel Data

Extract **hotels, hostels, guest houses, motels and apartments from OpenStreetMap** by area, radius, or name — **no API key, no booking-site scraping, no anti-bot battles**. Open, legal (ODbL) data you can redistribute.

Give it an area like `"Edinburgh, United Kingdom"` and get back tidy rows for every place to stay: name, lodging type, **star rating**, **room count**, brand, operator, internet access, full address, coordinates, contact, and the raw OpenStreetMap tags. You can also search **around a point** (every hotel within X km of a landmark) or **filter by name** (e.g. every `"Premier Inn"` or `"Hilton"`).

### Why use this scraper?

- **Lodging-specific fields.** Not just a generic POI dump — `stars`, `rooms`, `lodging_type`, brand, operator and internet access are parsed out of the OpenStreetMap tags for you.
- **Legal & open.** OpenStreetMap data is ODbL-licensed — redistributable with attribution. No booking-site Terms-of-Service issues, no login.
- **No API key.** No hotel/OTA developer account, no per-call quota.
- **Search by area, radius, or name.** A whole city/region, everything within X metres of a point, or every property of one brand.
- **Filter by type.** Hotels only, or hostels + guest houses, etc.
- **No duplicates.** When OpenStreetMap maps one property twice (a node and a building outline), you get a single, richer row.
- **Honest data.** Every value comes straight from OpenStreetMap; anything not mapped is left empty (`null`) — never guessed. `stars`/`rooms` are read only from explicit tags.
- **Global coverage & reliable.** Anywhere OSM has data; retries across multiple Overpass mirrors.

### Great for

- Travel & hospitality datasets, hotel-finder apps, trip planners
- Hotel market research, brand/coverage analysis, competitive mapping
- Site selection and real-estate/hospitality analysis
- Travel AI/RAG pipelines and dashboards

### Input

| Field | Type | Description |
|---|---|---|
| `area` | string | Place to search within, e.g. `"Paris, France"`. Geocoded to a bounding box. |
| `aroundLocation` | string | *(optional)* Address/place to search **around** within a radius. Pair with `radiusMeters`. |
| `radiusMeters` | integer | *(optional)* Radius in metres for around-a-location search (default `3000`). |
| `centerPoint` | object | *(advanced)* Explicit center `{ "lat":.., "lon":.. }` to search around. |
| `boundingBox` | object | *(advanced)* Explicit `{ "south":.., "west":.., "north":.., "east":.. }`. Overrides `area`. |
| `lodgingTypes` | array | *(optional)* Which types to include: `hotel`, `guest_house`, `hostel`, `motel`, `apartment`, `chalet`. Default: all. |
| `searchTerm` | string | *(optional)* Only return places whose **name** contains this text (case-insensitive), e.g. `"Hilton"`. |
| `maxResults` | integer | Maximum number of places to return (default `1000`). |

#### Example input

```json
{
  "area": "Edinburgh, United Kingdom",
  "lodgingTypes": ["hotel", "guest_house", "hostel"],
  "maxResults": 500
}
```

Every Premier Inn within 20 km of a point:

```json
{
  "aroundLocation": "Manchester Piccadilly",
  "radiusMeters": 20000,
  "lodgingTypes": ["hotel"],
  "searchTerm": "Premier Inn"
}
```

### Output

One row per lodging place:

| Field | Description |
|---|---|
| `name` | Property name |
| `lodging_type` | hotel / guest\_house / hostel / motel / apartment / chalet |
| `stars` | Star rating (from OSM `stars`) |
| `rooms` | Number of rooms (from OSM `rooms`) |
| `brand`, `operator` | Brand / chain and operator |
| `branch` | Branch / location name of a chain outlet (OSM `branch`), e.g. `Times Square` — disambiguates outlets of the same chain; `null` when not a tagged branch |
| `brand_wikidata` | Wikidata id of the brand/chain (e.g. `Q598884`) — stable entity id for chain analysis, when tagged |
| `brand_logo` | Official brand logo image URL from the brand's Wikidata entity (P154), when it has one; `null` otherwise — optional enrichment, never guessed |
| `internet_access` | wlan / yes / no / … |
| `wheelchair` | Accessibility |
| `latitude`, `longitude` | Coordinates |
| `street`, `housenumber`, `city`, `postcode`, `country` | Address |
| `state` | State / province (OSM `addr:state` / `addr:province`) — common in US/CA/AU, `null` where not tagged |
| `phone`, `email`, `website` | Contact |
| `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": "The Balmoral Hotel",
  "lodging_type": "hotel",
  "stars": 5,
  "rooms": 188,
  "brand": "Rocco Forte Hotels",
  "operator": "Rocco Forte Hotels",
  "internet_access": "wlan",
  "city": "Edinburgh",
  "postcode": "EH2 2EQ",
  "country": "GB",
  "website": "https://example.test/",
  "latitude": 55.9521,
  "longitude": -3.1897,
  "osm_type": "way",
  "source_url": "https://www.openstreetmap.org/way/..."
}
```

Any field is `null` when the property 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 Booking.com or Expedia 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. You get each property's own details (stars, rooms, brand, contact) rather than OTA listings or reviews.

**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.
- `stars` reflects what is tagged in OSM, which may differ from official/marketing ratings.

⭐ **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. "Paris, France". 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 place to search AROUND within a radius, e.g. "Eiffel Tower". Geocoded to a center point; set the radius with "radiusMeters".

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

Radius in meters for the around-a-location search (used with Around Location or Center Point). Default 3000.

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

Optional advanced alternative: an explicit center as {"lat":.., "lon":..} to search around. Overrides Around Location when set.

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

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

## `lodgingTypes` (type: `array`):

Which lodging types to include. Supported: hotel, guest\_house, hostel, motel, apartment, chalet. Default: all of them.

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

Optional. Only return places whose name contains this text (case-insensitive), e.g. "Hilton", "Premier Inn".

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

Maximum number of lodging places to return.

## Actor input object example

```json
{
  "area": "Edinburgh, United Kingdom",
  "radiusMeters": 3000,
  "lodgingTypes": [
    "hotel",
    "guest_house",
    "hostel"
  ],
  "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": "Edinburgh, United Kingdom",
    "lodgingTypes": [
        "hotel",
        "guest_house",
        "hostel"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataquarry/hotels-lodging").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": "Edinburgh, United Kingdom",
    "lodgingTypes": [
        "hotel",
        "guest_house",
        "hostel",
    ],
}

# Run the Actor and wait for it to finish
run = client.actor("dataquarry/hotels-lodging").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": "Edinburgh, United Kingdom",
  "lodgingTypes": [
    "hotel",
    "guest_house",
    "hostel"
  ]
}' |
apify call dataquarry/hotels-lodging --silent --output-dataset

```

## MCP server setup

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

```

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/PVFQL8o5mvd7sjS4G/builds/TJ1V3L6ERT0G8sd6M/openapi.json