# Atlas Obscura Scraper (`crawlerbros/atlas-obscura-scraper`) Actor

Scrape Atlas Obscura, the world's definitive guide to 30K+ hidden wonders, unusual, and offbeat destinations. Search places, browse by location, country, or category. Returns coordinates, descriptions, images, and more.

- **URL**: https://apify.com/crawlerbros/atlas-obscura-scraper.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Travel, Developer tools, Automation
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

## Atlas Obscura Scraper

Scrape [Atlas Obscura](https://www.atlasobscura.com) — the world's definitive guide to hidden wonders, unusual, and offbeat destinations. Access 30,000+ extraordinary places with coordinates, descriptions, categories, and images.

### What you can do

- **Search** for unusual places by keyword (ghost towns, underground cities, haunted castles)
- **Browse by location** — find hidden wonders near any lat/lng coordinates
- **Browse by country** — explore all unusual places in a specific country
- **Browse by category** — filter by abandoned, caves, ruins, natural wonders, and 26 more categories
- **Get trending** — recently added or featured places

### Input

| Field | Type | Description |
|-------|------|-------------|
| `mode` | Select | `search`, `byLocation`, `byCountry`, `byCategory`, `trending` |
| `query` | Text | Search keyword (mode=search). E.g. `ghost town`, `underground city` |
| `country` | Text | Country name filter (mode=search or mode=byCountry). E.g. `Japan` |
| `category` | Select | Category to browse (mode=byCategory). E.g. `abandoned`, `caves`, `ruins` |
| `latitude` | Number | Center latitude for nearby search (mode=byLocation). E.g. `48.8566` |
| `longitude` | Number | Center longitude for nearby search (mode=byLocation). E.g. `2.3522` |
| `radius` | Integer | Search radius in km (mode=byLocation, default: 50) |
| `fetchDetails` | Boolean | Fetch full place page for description and categories (default: true) |
| `maxItems` | Integer | Max places to return (1–500, default: 20) |

#### Example inputs

**Search for ghost towns:**
```json
{
  "mode": "search",
  "query": "ghost town",
  "maxItems": 20
}
````

**Find places near Paris:**

```json
{
  "mode": "byLocation",
  "latitude": 48.8566,
  "longitude": 2.3522,
  "radius": 25,
  "maxItems": 20
}
```

**Browse abandoned places:**

```json
{
  "mode": "byCategory",
  "category": "abandoned",
  "maxItems": 50
}
```

**All unusual places in Japan:**

```json
{
  "mode": "byCountry",
  "country": "Japan",
  "maxItems": 100
}
```

### Output

Each record includes:

| Field | Description |
|-------|-------------|
| `placeId` | Atlas Obscura internal place ID |
| `name` | Place name |
| `subtitle` | One-line teaser description |
| `description` | Full place description (when fetchDetails=true) |
| `city` | City where the place is located |
| `country` | Country where the place is located |
| `region` | State/region (when available) |
| `address` | Street address (when available) |
| `postalCode` | Postal code (when available) |
| `latitude` | Geographic latitude |
| `longitude` | Geographic longitude |
| `categories` | List of Atlas Obscura category tags |
| `imageUrl` | Main place image URL |
| `placeUrl` | Full Atlas Obscura place URL |
| `datePublished` | When the place was added to Atlas Obscura |
| `location` | "City, Country" location string |
| `recordType` | Always `"place"` |
| `scrapedAt` | ISO timestamp when the record was scraped |

#### Example output record

```json
{
  "placeId": 36622,
  "name": "Gold 20-stater of Eucratides I",
  "subtitle": "The heaviest gold coin ever minted.",
  "description": "In the third century B.C., the early Roman Republic issued...",
  "city": "Paris",
  "country": "France",
  "region": "Île-de-France",
  "address": "60 Rue de Rivoli",
  "postalCode": "75004",
  "latitude": 48.856614,
  "longitude": 2.352222,
  "categories": ["Coins", "Money", "Collections", "Museums And Collections"],
  "imageUrl": "https://img.atlasobscura.com/abc123/img.jpg",
  "placeUrl": "https://www.atlasobscura.com/places/gold-20-stater-of-eucratides-i",
  "datePublished": "2020-05-04",
  "location": "Paris, France",
  "recordType": "place",
  "scrapedAt": "2026-05-25T10:00:00+00:00"
}
```

### Data Source

Atlas Obscura is an award-winning travel media company cataloging the world's most unusual and extraordinary places. Their database contains 30,000+ destinations across 196 countries. The site provides a public JSON search API and rich HTML pages with schema.org structured data. No authentication is required.

### Available Categories

`abandoned` · `ancient` · `architectural-oddities` · `art` · `caves` · `churches` · `educational` · `engineering` · `food` · `forests` · `graveyards` · `historic-sites` · `hotels` · `islands` · `lakes` · `libraries` · `markets` · `mountains` · `museums` · `natural-wonders` · `observatories` · `offbeat` · `parks` · `ruins` · `science` · `shrines` · `temples` · `underground` · `urban-exploration` · `waterfalls`

### FAQ

**How many places does Atlas Obscura have?**
Atlas Obscura has over 30,000 extraordinary places cataloged across 196 countries.

**Does this require an API key or login?**
No. Atlas Obscura places are publicly accessible without authentication.

**How fast does the scraper run?**
With `fetchDetails=true`, each place requires one additional request for the full description and categories. For large datasets, consider setting `fetchDetails=false` for faster runs with basic metadata only.

**Can I filter by multiple categories?**
Currently one category per run. Run the actor multiple times with different categories and merge the results.

**What's the maximum number of results I can get?**
The actor supports up to 500 places per run. Atlas Obscura's search API returns up to 10,000 results and supports pagination.

**Why does `byLocation` return places worldwide instead of just nearby?**
Atlas Obscura's API returns globally relevant places alongside nearby ones when the local area has few entries. The coordinates and `distance_from_query` field indicate actual distance.

**Is there a rate limit?**
The actor respects Atlas Obscura's servers with polite delays between requests. For large extractions (200+ places with full details), runs may take a few minutes.

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `query` (type: `string`):

Free-text search query (mode=search). E.g. 'ghost town', 'underground city', 'haunted castle'.

## `country` (type: `string`):

Country name to filter results (mode=search or mode=byCountry). E.g. 'Japan', 'United States', 'Italy'.

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

Atlas Obscura category tag to filter by (mode=byCategory).

## `latitude` (type: `number`):

Center latitude for location-based search (mode=byLocation). E.g. 48.8566 for Paris.

## `longitude` (type: `number`):

Center longitude for location-based search (mode=byLocation). E.g. 2.3522 for Paris.

## `radius` (type: `integer`):

Search radius in kilometers around the given lat/lng (mode=byLocation). Default: 50.

## `fetchDetails` (type: `boolean`):

Fetch the full place HTML page to get description text, categories, and address. Slower but richer data.

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

Maximum number of places to return.

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

Apify proxy configuration. Atlas Obscura blocks datacenter IPs — Apify AUTO group (free) is used by default to bypass this.

## Actor input object example

```json
{
  "mode": "search",
  "query": "ghost town",
  "category": "abandoned",
  "radius": 50,
  "fetchDetails": true,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `places` (type: `string`):

Dataset containing all scraped Atlas Obscura places.

# 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 = {
    "mode": "search",
    "query": "ghost town",
    "category": "abandoned",
    "radius": 50,
    "fetchDetails": true,
    "maxItems": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/atlas-obscura-scraper").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 = {
    "mode": "search",
    "query": "ghost town",
    "category": "abandoned",
    "radius": 50,
    "fetchDetails": True,
    "maxItems": 5,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/atlas-obscura-scraper").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 '{
  "mode": "search",
  "query": "ghost town",
  "category": "abandoned",
  "radius": 50,
  "fetchDetails": true,
  "maxItems": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call crawlerbros/atlas-obscura-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/atlas-obscura-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Atlas Obscura Scraper",
        "description": "Scrape Atlas Obscura, the world's definitive guide to 30K+ hidden wonders, unusual, and offbeat destinations. Search places, browse by location, country, or category. Returns coordinates, descriptions, images, and more.",
        "version": "1.0",
        "x-build-id": "8wiOEQEtrSCaRFTnV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~atlas-obscura-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-atlas-obscura-scraper",
                "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/crawlerbros~atlas-obscura-scraper/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-atlas-obscura-scraper",
                "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/crawlerbros~atlas-obscura-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-atlas-obscura-scraper",
                "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",
                "required": [
                    "mode"
                ],
                "properties": {
                    "mode": {
                        "title": "Mode",
                        "enum": [
                            "search",
                            "byLocation",
                            "byCountry",
                            "byCategory",
                            "trending"
                        ],
                        "type": "string",
                        "description": "What to fetch.",
                        "default": "search"
                    },
                    "query": {
                        "title": "Search query",
                        "type": "string",
                        "description": "Free-text search query (mode=search). E.g. 'ghost town', 'underground city', 'haunted castle'.",
                        "default": "ghost town"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "Country name to filter results (mode=search or mode=byCountry). E.g. 'Japan', 'United States', 'Italy'."
                    },
                    "category": {
                        "title": "Category",
                        "enum": [
                            "abandoned",
                            "ancient",
                            "architectural-oddities",
                            "art",
                            "caves",
                            "churches",
                            "educational",
                            "engineering",
                            "food",
                            "forests",
                            "graveyards",
                            "historic-sites",
                            "hotels",
                            "islands",
                            "lakes",
                            "libraries",
                            "markets",
                            "mountains",
                            "museums",
                            "natural-wonders",
                            "observatories",
                            "offbeat",
                            "parks",
                            "ruins",
                            "science",
                            "shrines",
                            "temples",
                            "underground",
                            "urban-exploration",
                            "waterfalls"
                        ],
                        "type": "string",
                        "description": "Atlas Obscura category tag to filter by (mode=byCategory).",
                        "default": "abandoned"
                    },
                    "latitude": {
                        "title": "Latitude",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Center latitude for location-based search (mode=byLocation). E.g. 48.8566 for Paris."
                    },
                    "longitude": {
                        "title": "Longitude",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Center longitude for location-based search (mode=byLocation). E.g. 2.3522 for Paris."
                    },
                    "radius": {
                        "title": "Radius (km)",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Search radius in kilometers around the given lat/lng (mode=byLocation). Default: 50.",
                        "default": 50
                    },
                    "fetchDetails": {
                        "title": "Fetch full place details",
                        "type": "boolean",
                        "description": "Fetch the full place HTML page to get description text, categories, and address. Slower but richer data.",
                        "default": true
                    },
                    "maxItems": {
                        "title": "Max items",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of places to return.",
                        "default": 20
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Apify proxy configuration. Atlas Obscura blocks datacenter IPs — Apify AUTO group (free) is used by default to bypass this.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
