# Snapchat Snap Map Place & Live Snap Extractor (`dataspryva/snapchat-snap-map-place-and-live-snap-extractor`) Actor

Search Snapchat's Snap Map by place name or landmark and get each place's coordinates, category, favorite and snap counts, plus the media link for its most recent public snap.

- **URL**: https://apify.com/dataspryva/snapchat-snap-map-place-and-live-snap-extractor.md
- **Developed by:** [Dataspryva](https://apify.com/dataspryva) (community)
- **Categories:** Social media, Lead generation, Travel
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 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/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

## Snapchat Snap Map Place & Live Snap Extractor

Snap Map shows the public snaps and places people are posting about right now. This actor reads Snapchat's public web pages and turns them into a clean dataset: place coordinates, address, category, rating, opening hours, a 7×24 popularity heatmap and the public snap sample at each place, with media URLs, creators and timestamps. Search by keyword, paste place links, or browse US cities and categories. No Snapchat account, cookies, API key or proxy setup is needed.

### What you can collect

- **Place search** — one keyword returns the Snap Map places Snapchat matches, plus the public Spotlight videos, creators, profiles, publishers, episodes and lenses shown for the same query.
- **Place details** — paste place URLs or UUIDs and get the full public place profile: geometry, address, phone, website, category, rating and reviews, opening hours, favorites and nearby places.
- **Live snaps** — every place page carries a sample of public snaps posted at or shared about the place: media URL, thumbnail, video or image type, creator username and display name, timestamp and snap source (`map` or `spotlight`). Snapchat mixes recent map posts with older Spotlight shares, so use `snapMaxAgeHours` when you need a fresh-only feed.
- **7×24 popularity** — Snapchat's hourly popularity values for the whole week (168 values), plus the peak hour and day index. Use it as a per-place heatmap signal.
- **US city and category discovery** — browse a city hub or a category page such as bars, restaurants or historic landmarks. Each row includes the live-snap count, rating, popularity hours and coordinates, which makes it easy to map activity.
- **Flat live-snap rows** — switch the output to one row per snap when you want a snap-level dataset instead of nested arrays.

### Modes

| Mode | What it does | Main input |
|---|---|---|
| `searchPlaces` | Search Snap Map and optionally the other Explore result groups | `keywords` |
| `placeDetails` | Load full details for specific places | `placeUrls` |
| `browseLocal` | Browse a US city hub or category pages | `cityUrls`, optional `categories` |

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | select | `searchPlaces` | Which collection mode to run |
| `keywords` | string list | — | Place names or landmarks for search mode; the form prefill uses `["Times Square"]` |
| `placeUrls` | string list | — | Full place URLs, `/place/...` paths or bare place UUIDs |
| `cityUrls` | string list | — | US city names, Snapchat local URLs or local paths |
| `categories` | string list | — | Category slugs for browse mode, e.g. `bars`, `restaurants`, `historic-landmarks` |
| `resultTypes` | multi-select | `["places"]` | Explore groups to return: places, spotlight, users, profiles, publishers, episodes, lenses |
| `outputType` | select | `placeRecords` | One row per place, or one row per live snap |
| `maxResultsPerKeyword` | integer | 10 | Cap per result type per keyword |
| `maxPlaces` | integer | 100 | Cap for place-details mode |
| `maxPlacesPerCity` | integer | 100 | Cap per city in browse mode |
| `maxSnapsPerPlace` | integer | 10 | Live snaps to keep per place |
| `includeSnapData` | boolean | true | Add the public snap sample and the legacy first-snap fields |
| `includePlaceDetails` | boolean | true | Open each place page for coordinates, contact, rating and hours; nearby/reviews/live-snap output open pages automatically |
| `includeNearbyPlaces` | boolean | false | Add the places Snapchat lists at the same location |
| `includeReviews` | boolean | false | Add up to 20 public place reviews |
| `includePopularityHours` | boolean | true | Add the 168-value popularity series and peak |
| `minRating` | number | 0 | Keep places at or above this rating |
| `requireLiveSnaps` | boolean | false | Keep only places that currently have public snaps |
| `snapMaxAgeHours` | integer | 0 | Keep only snaps newer than this; 0 keeps all. Counts and `latestSnapAt` reflect kept snaps |
| `sortBy` | select | `source` | Order by source, rating, favorites or live-snap count |
| `proxyConfiguration` | proxy | — | Optional; the public pages work without a proxy |

Legacy tasks keep working: `maxPlacesPerKeyword` from older versions is read in code and mapped onto `maxResultsPerKeyword`.

### Output

Every row has `recordType` so mixed datasets stay readable: `place`, `liveSnap`, `spotlight`, `user`, `profile`, `publisher`, `episode` or `lens`. Empty fields are omitted, never written as `null`, `""` or `[]`.

#### Place fields

| Field | Description |
|---|---|
| `placeId` | Snapchat place UUID |
| `displayName`, `placeUrl` | Place name and canonical Snapchat URL |
| `lat`, `lng`, `boundingBox` | Centroid and southwest/northeast bounds |
| `address` | Street, city, region, postal code, country and formatted address |
| `categoryName`, `categoryId`, `placeType` | Snapchat category and place type |
| `phone`, `email`, `website`, `menuUrl`, `reservationUrl`, `storeUrl` | Public contact and action links |
| `rating`, `reviewCount`, `ratingProvider`, `ratings` | Public rating summary (provider value is rounded to 2 decimals) |
| `reviews` | Optional review rows with text, rating, date and source URL |
| `openingHours` | Day-by-day ranges, special hours and time zone |
| `isOpen` | Open-now flag from local discovery pages |
| `favoriteCount`, `favoriteDisplayCount` | Snapchat favorite count |
| `profilePhotoUrl`, `profilePhotoProvider`, `photoUrls` | Public photos |
| `popularityHours` | 168 hourly values, 7 days × 24 hours |
| `popularityPeakHour`, `popularityPeakDayIndex`, `popularityPeakValue` | Peak of the series (day index 0 = Sunday) |
| `liveSnapCount`, `latestSnapAt`, `liveSnaps` | Public snap sample after `snapMaxAgeHours` filtering, its latest timestamp and up to `maxSnapsPerPlace` rows |
| `nearbyPlaces` | Optional places at the same location |
| `placeHierarchy` | Neighborhood, ZIP, city and state breadcrumbs |
| `snapCount`, `firstSnapId`, `thumbnailUrl` | Legacy place-level snap fields |
| `snapId`, `mediaUrl`, `previewUrl`, `mediaType`, `postedAt`, `creatorUsername`, `creatorDisplayName` | Legacy first-snap aliases |
| `scrapedAt`, `sourcePage` | Collection timestamp and source surface |

#### Live snap row fields (`outputType: liveSnapRecords`)

`snapId`, `placeId`, `placeName`, `categoryName`, `city`, `lat`, `lng`, `mediaUrl`, `thumbnailUrl`, `previewUrl`, `mediaType`, `storyType`, `duration`, `postedAt`, `creatorUsername`, `creatorDisplayName`, `creatorUserId`, `scrapedAt`.

#### Example: search

```json
{
  "mode": "searchPlaces",
  "keywords": ["Times Square"],
  "maxResultsPerKeyword": 3,
  "includePlaceDetails": true,
  "includeSnapData": true,
  "includePopularityHours": true
}
```

#### Example: place details

```json
{
  "mode": "placeDetails",
  "placeUrls": ["https://www.snapchat.com/place/times-square/c8b4f0ee-9992-11e8-88c9-673ed985ff70"],
  "includeNearbyPlaces": true,
  "includeReviews": true
}
```

#### Example: city browse

```json
{
  "mode": "browseLocal",
  "cityUrls": ["new-york"],
  "categories": ["bars", "restaurants"],
  "outputType": "liveSnapRecords",
  "maxSnapsPerPlace": 5
}
```

### How the popularity heatmap works

Snapchat publishes 168 popularity integers per place, one for every hour of the week. The array starts at hour 0 and runs through the week, so `popularityPeakHour` is `index % 24` and `popularityPeakDayIndex` is `index // 24` (0 = Sunday). The values are relative popularity, not absolute visitor counts.

### Limits

- **Snap Map mobile API is not used.** The app's private endpoints (`ms.sc-jpl.com`) refuse every web and cloud TLS client, so this actor uses Snapchat's public web pages instead. Live snaps and popularity come from the public place pages.
- **Local discovery covers the United States.** Snapchat's `/local` directory returns 404 outside the US.
- **20 places per city or category page.** The page reports a larger total but serves a 20-row display cap; split by category to get more rows.
- **Search groups are capped by Snapchat.** Places return up to 10 rows and other groups about 20–24; there is no cursor.
- **Live snaps are a public sample, not a real-time feed.** A place page exposes roughly 2–36 snaps mixing recent map posts with older Spotlight shares (verified samples span hours to over a year). `snapMaxAgeHours` keeps only the age you want, and `liveSnapCount` reflects the kept rows. City pages carry their own older story samples; the default `includePlaceDetails: true` and the `liveSnapRecords` output read the place pages instead.
- **Some legacy snap fields are gone.** The 2026 page payload no longer publishes duration, width, height, overlay text or sponsored flags, so those keys appear only when Snapchat supplies them.

### FAQ

**Do I need a Snapchat account or cookies?**
No. Every surface used here is public.

**Do I need a proxy?**
No. The pages load directly. A proxy field is available if you want extra redundancy.

**Why is a field missing on some places?**
Snapchat does not publish every field for every place. Missing values are omitted rather than filled with placeholders.

**Can I get snaps for a radius or a map tile?**
That is the Snap Map app API, which is not reachable from web clients. Use place details or city browse for public snap data, and join `lat`/`lng` with your own geometry.

**Are media URLs permanent?**
They are public CDN links that work without cookies or a Referer and are cached for a day. Snapchat can expire them, so download the media promptly if you need the file.

**Is this affiliated with Snapchat?**
No. This actor independently reads Snapchat's public web pages and is not affiliated with or endorsed by Snap Inc.

# Actor input Schema

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

Choose what to scrape: search Snap Map places by keyword, look up specific place URLs or IDs, or browse US cities and categories.

## `keywords` (type: `array`):

Place names, landmarks, venues or addresses to search on Snap Map. Used in Search places mode. Examples: Times Square, Eiffel Tower, Tokyo Station.

## `placeUrls` (type: `array`):

Snapchat place page URLs, /place/ paths, or bare place UUIDs. Used in Get details mode. Example: https://www.snapchat.com/place/times-square/c8b4f0ee-9992-11e8-88c9-673ed985ff70.

## `cityUrls` (type: `array`):

US city names, Snapchat local URLs, or local paths for Browse mode. Examples: new-york, chicago, https://www.snapchat.com/local/united-states/california/los-angeles.

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

Optional category slugs for Browse mode, such as bars, restaurants, coffee-shops, historic-landmarks or parks. Leave empty to use the city hub's six featured categories.

## `resultTypes` (type: `array`):

Which Explore result groups to return in Search places mode. Places is the Snap Map place search; the other groups are the public entities Snapchat shows for the same keyword.

## `outputType` (type: `string`):

Place records keep one row per place with live snaps nested. Live snap records flatten every live snap into its own row with the place's coordinates, which is easier for maps and time-series analysis.

## `maxResultsPerKeyword` (type: `integer`):

Maximum rows to keep for each result type per keyword. Snapchat returns up to 10 places and roughly 20-24 items for the other groups.

## `maxPlaces` (type: `integer`):

Maximum places to process in Get details mode.

## `maxPlacesPerCity` (type: `integer`):

Maximum places to keep per city in Browse mode after merging the hub categories.

## `maxSnapsPerPlace` (type: `integer`):

Maximum live snaps to keep per place. Snapchat's public page exposes a sample of 2-36 current snaps per place.

## `includeSnapData` (type: `boolean`):

Add the public snap sample for each place with media URL, thumbnail, creator and timestamp. Snapchat mixes recent map posts with older Spotlight shares, so use the age filter below to keep only fresh posts. Also fills the legacy first-snap fields.

## `includePlaceDetails` (type: `boolean`):

Open each place page to fill coordinates, address, phone, website, category, rating, reviews, opening hours, popularity and nearby places. Turn off for a faster search-card-only run. Nearby places, reviews, favorite sorting, live-snap output and the live-snap filter open place pages automatically because those values only exist there.

## `includeNearbyPlaces` (type: `boolean`):

Add the places Snapchat lists at the same location, with their coordinates and categories.

## `includeReviews` (type: `boolean`):

Add up to 20 public place reviews with rating, text, date and source URL.

## `includePopularityHours` (type: `boolean`):

Add Snapchat's 168 hourly popularity values per place (7 days x 24 hours) plus the peak hour and day index. This is the per-place heatmap signal.

## `minRating` (type: `number`):

Keep only places whose public rating is at least this value. Places without a rating are dropped when this is above 0.

## `requireLiveSnaps` (type: `boolean`):

Drop places that currently have no public live snaps.

## `snapMaxAgeHours` (type: `integer`):

Keep only snaps posted within this many hours. Set 0 to keep every snap the public page returns. liveSnapCount and latestSnapAt describe only the kept snaps, and the live-snap filter uses that kept count.

## `sortBy` (type: `string`):

Order places by Snapchat's source order, rating, favorite count or number of live snaps.

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

Optional. The public Snapchat pages used here work without a proxy.

## Actor input object example

```json
{
  "mode": "searchPlaces",
  "keywords": [
    "Times Square"
  ],
  "placeUrls": [],
  "cityUrls": [],
  "categories": [],
  "resultTypes": [
    "places"
  ],
  "outputType": "placeRecords",
  "maxResultsPerKeyword": 1,
  "maxPlaces": 1,
  "maxPlacesPerCity": 20,
  "maxSnapsPerPlace": 3,
  "includeSnapData": true,
  "includePlaceDetails": true,
  "includeNearbyPlaces": false,
  "includeReviews": false,
  "includePopularityHours": true,
  "minRating": 0,
  "requireLiveSnaps": false,
  "snapMaxAgeHours": 0,
  "sortBy": "source"
}
```

# Actor output Schema

## `records` (type: `string`):

Dataset containing all scraped Snap Map places, live snaps and related Explore entities.

# 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": "searchPlaces",
    "keywords": [
        "Times Square"
    ],
    "placeUrls": [],
    "cityUrls": [],
    "categories": [],
    "resultTypes": [
        "places"
    ],
    "outputType": "placeRecords",
    "maxResultsPerKeyword": 1,
    "maxPlaces": 1,
    "maxPlacesPerCity": 20,
    "maxSnapsPerPlace": 3,
    "includeSnapData": true,
    "includePlaceDetails": true,
    "includeNearbyPlaces": false,
    "includeReviews": false,
    "includePopularityHours": true,
    "minRating": 0,
    "requireLiveSnaps": false,
    "snapMaxAgeHours": 0,
    "sortBy": "source"
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataspryva/snapchat-snap-map-place-and-live-snap-extractor").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": "searchPlaces",
    "keywords": ["Times Square"],
    "placeUrls": [],
    "cityUrls": [],
    "categories": [],
    "resultTypes": ["places"],
    "outputType": "placeRecords",
    "maxResultsPerKeyword": 1,
    "maxPlaces": 1,
    "maxPlacesPerCity": 20,
    "maxSnapsPerPlace": 3,
    "includeSnapData": True,
    "includePlaceDetails": True,
    "includeNearbyPlaces": False,
    "includeReviews": False,
    "includePopularityHours": True,
    "minRating": 0,
    "requireLiveSnaps": False,
    "snapMaxAgeHours": 0,
    "sortBy": "source",
}

# Run the Actor and wait for it to finish
run = client.actor("dataspryva/snapchat-snap-map-place-and-live-snap-extractor").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 '{
  "mode": "searchPlaces",
  "keywords": [
    "Times Square"
  ],
  "placeUrls": [],
  "cityUrls": [],
  "categories": [],
  "resultTypes": [
    "places"
  ],
  "outputType": "placeRecords",
  "maxResultsPerKeyword": 1,
  "maxPlaces": 1,
  "maxPlacesPerCity": 20,
  "maxSnapsPerPlace": 3,
  "includeSnapData": true,
  "includePlaceDetails": true,
  "includeNearbyPlaces": false,
  "includeReviews": false,
  "includePopularityHours": true,
  "minRating": 0,
  "requireLiveSnaps": false,
  "snapMaxAgeHours": 0,
  "sortBy": "source"
}' |
apify call dataspryva/snapchat-snap-map-place-and-live-snap-extractor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,dataspryva/snapchat-snap-map-place-and-live-snap-extractor"
        }
    }
}
```

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/OnjT5Guhg9dgP9PKv/builds/AJWGw6hpbjxZtYxx5/openapi.json