# ChatGPT Maps Local Recommendations Scraper (`rainminer/chatgpt-maps-scraper`) Actor

Scrape chatgpt.com/maps for any question, from restaurants and hotels to dentists and gyms. Each row has rank, rating, reviews, price, address, phone, website, hours, photos, the sentence ChatGPT wrote, and the sources it cited. No OpenAI account or login required.

- **URL**: https://apify.com/rainminer/chatgpt-maps-scraper.md
- **Developed by:** [rainminer](https://apify.com/rainminer) (community)
- **Categories:** Travel, Lead generation, AI
- **Stats:** 2 total users, 1 monthly users, 80.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.37 / 1,000 place 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

## ChatGPT Maps Scraper

![ChatGPT Maps answering "best pizza places in Brooklyn, New York" with a map and place cards](https://api.apify.com/v2/key-value-stores/3hcDJgyNtDDkU4KTO/records/chatgpt-maps-scraper-banner.png)

**ChatGPT Maps Scraper** asks [ChatGPT Maps](https://chatgpt.com/maps) a local search question — `best pizza places in Brooklyn, New York`, `24 hour pharmacy near Union Square`, `kid friendly hotels in Anaheim` — and saves every place ChatGPT recommends as a structured row: **rank, name, rating, review count, price range, address, phone, website, opening hours, coordinates, photos**, the sentence ChatGPT wrote about that place, the **full answer in Markdown**, and the **sources ChatGPT cited**. No OpenAI account, no API key, no login.

If you do local SEO, reputation management, or market research, this is how you find out **which businesses ChatGPT recommends** for the queries your customers actually type — and whether yours is one of them.

***

### What does ChatGPT Maps Scraper do?

[ChatGPT Maps](https://chatgpt.com/maps) is OpenAI's dedicated place-search experience: you describe what you need, ChatGPT searches the web and local business listings, and returns a handful of recommended places pinned on a map with ratings, categories, price levels, and opening hours. Those recommendations are increasingly where people decide where to eat, stay, shop, and book — but there is no ChatGPT Maps API, no export button, and no way to monitor results over time.

This Actor fills that gap. For each query you enter it:

1. Opens ChatGPT Maps in a fresh, logged-out session (each query is independent — no chat history bleeds into the next answer).
2. Types your question exactly as a person would and waits for ChatGPT to finish answering.
3. Reads the places ChatGPT featured on the map together with the answer text and its citations.
4. Saves **one dataset item per recommended place**, in the order ChatGPT listed them, with the ChatGPT answer attached.

You can run it once, schedule it daily, and export the results as **JSON, CSV, Excel, XML, or HTML** or pull them from the Apify API.

***

### What can this ChatGPT Maps scraper do?

- Scrape **ChatGPT Maps recommendations** for any natural-language local query (restaurants, hotels, dentists, gyms, attractions, services)
- Capture the **rank order** ChatGPT used — the same order shown on the map cards
- Extract each place's **rating, review count, price range, categories, address, phone, website, weekly opening hours, open/closed status, and GPS coordinates**
- Save the **place photo** ChatGPT displayed, ready for Console thumbnails and reports
- Keep the **exact sentence ChatGPT wrote about each place** (`answerSnippet`) and the **whole answer** (`answerText`) with numbered citations
- Record the **cited sources** (The Infatuation, Tripadvisor, Yelp, local news, official sites) so you know what ChatGPT reads before recommending
- Optionally include the **candidate places ChatGPT looked up but did not feature** (`featured: false`), useful for gap analysis
- Batch dozens of queries per run, optionally appending one `location` to all of them
- Schedule runs and diff results to **track ChatGPT rankings over time**

***

### Why scrape ChatGPT Maps?

ChatGPT is becoming a discovery channel next to Google Maps, Yelp, and Tripadvisor. Unlike those, ChatGPT explains its picks, so its answers are a goldmine for anyone who works with local businesses:

- **Local SEO and AI visibility tracking** — Check whether your client's restaurant, clinic, or store shows up when ChatGPT is asked for "best X in Y". Re-run weekly and see rank changes.
- **Agency reporting** — Add a "ChatGPT recommendations" section to monthly reports with the exact quote ChatGPT gives about each client.
- **Competitor research** — See which competitors ChatGPT keeps recommending, what it praises them for, and which review sites it cites.
- **Citation and PR strategy** — The `sources` list shows which publications influence ChatGPT for your category; pitch them.
- **Multi-location brands** — Run the same query template across 50 cities (`location` field) and find markets where you are invisible.
- **Hospitality and travel research** — Compare ChatGPT's hotel, cafe, and attraction picks across destinations.
- **Lead generation** — ChatGPT-recommended businesses come with phone, website, and address; they are the winners in their niche.
- **Review-site benchmarking** — Compare ChatGPT's rating and review counts against your own Google/Yelp data.
- **Market entry** — Ask "best coworking spaces in Lisbon" or "dog groomers in Austin" and map the incumbents in minutes.
- **Content ideas** — ChatGPT's reasoning ("go here for the Sicilian square") shows what attributes matter in each category.
- **Academic and media research** — Study how a generative AI ranks and describes local businesses across regions.

***

### What ChatGPT Maps data can you extract?

| Field | Description |
| --- | --- |
| `query` | The question you asked (with `location` appended when set) |
| `rank` | Position in ChatGPT's recommendation list (1 = first card on the map) |
| `featured` | `true` when the place was pinned on the ChatGPT map; `false` for extra candidates |
| `mentionedInAnswer` | Whether ChatGPT wrote about this place in the answer text |
| `name`, `categories` | Business name and category labels (e.g. `Pizza restaurant`) |
| `rating`, `reviewCount` | Star rating and number of reviews ChatGPT displayed |
| `priceRange` | Price level shown by ChatGPT (`$10–20`, `$$`) |
| `address`, `location` | Street address and the area ChatGPT searched (`Brooklyn, NY, USA`) |
| `latitude`, `longitude` | Map pin coordinates |
| `phone`, `websiteUrl` | Contact details shown on the place card |
| `imageUrl`, `imageUrls` | Place photo(s) ChatGPT displayed |
| `hours` | Weekly opening hours as `{ day, open, close }` (24h clock) |
| `isOpen`, `isClosedPermanently`, `isClosedTemporarily` | Status flags at scrape time |
| `answerSnippet` | The bullet or paragraph ChatGPT wrote about this place |
| `answerText` | The complete ChatGPT answer in Markdown with `[1]`, `[2]` citation markers |
| `sources` | Cited web sources: `index`, `title`, `url`, `attribution` |
| `chatgptPlaceId`, `conversationId`, `model` | Identifiers for deduplication and auditing |
| `scrapedAt` | ISO timestamp of the run |

***

### How to scrape ChatGPT Maps

1. Open **ChatGPT Maps Scraper** in [Apify Console](https://console.apify.com/actors/rainminer~chatgpt-maps-scraper) and click **Try for free**.
2. Enter one or more **Search queries**, one per line, written the way you would ask ChatGPT (`best brunch spots in Austin`, `emergency vet open now in Denver`).
3. Optionally set **Location** to append the same city or neighborhood to every query.
4. Set **Maximum places per query** (ChatGPT usually features 5–10 places) and decide whether to **Include candidate places**.
5. Keep the default **residential US proxy**, or switch the proxy country to change which region ChatGPT treats as "nearby".
6. Click **Start**. Each query takes roughly 20–60 seconds while ChatGPT searches and writes its answer.
7. Open the **Overview** tab to see ranked places with photos, or the **ChatGPT answers** tab for the full text and sources. Export in the format you need.

Tip: use a schedule (daily or weekly) and compare `rank` per `query` to build a ChatGPT local ranking tracker.

***

### Input

```json
{
  "queries": [
    "best pizza places in Brooklyn, New York",
    "family friendly hotels near Disneyland Anaheim"
  ],
  "maxItems": 10,
  "includeCandidatePlaces": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"],
    "apifyProxyCountry": "US"
  }
}
```

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `queries` | Array of strings | — | Local search questions for ChatGPT Maps, one per entry. Include the city unless you set `location`. |
| `location` | String | — | Appended to every query as ` in <location>`. Handy for running one query template across many cities. |
| `maxItems` | Integer | `10` | Maximum places saved per query. Applies per query, not per run. |
| `includeCandidatePlaces` | Boolean | `false` | Also save places ChatGPT looked up but did not feature (`featured: false`). |
| `proxyConfiguration` | Object | Residential, US | chatgpt.com blocks datacenter IPs, so residential proxies are required. The proxy country influences "nearby" results. |

***

### Output

Each dataset item is **one recommended place** for one query. Items are pushed in ChatGPT's order, so `rank` is stable within a query.

```json
{
  "query": "best pizza places in Brooklyn, New York",
  "rank": 1,
  "featured": true,
  "mentionedInAnswer": true,
  "name": "L'industrie Pizzeria - Williamsburg",
  "categories": ["Pizza restaurant"],
  "rating": 4.7,
  "reviewCount": 6087,
  "priceRange": "$10–20",
  "address": "254 S 2nd St, Brooklyn, NY 11211",
  "location": "Brooklyn, NY, USA",
  "latitude": 40.7116053,
  "longitude": -73.9578691,
  "phone": "+17185990002",
  "websiteUrl": "http://www.lindustriebk.com/",
  "imageUrl": "https://images.openai.com/static-rsc-1/...",
  "imageUrls": ["https://images.openai.com/static-rsc-1/..."],
  "hours": [
    { "day": "Monday", "open": "12:00", "close": "22:00" },
    { "day": "Tuesday", "open": "12:00", "close": "22:00" }
  ],
  "isOpen": true,
  "isClosedPermanently": false,
  "isClosedTemporarily": false,
  "answerSnippet": "L'industrie Pizzeria - Williamsburg — Williamsburg Excellent thin, crisp-yet-chewy slices and creative toppings. The Infatuation currently gives it a 9.0 and calls out its consistency and burrata pie. [1]",
  "answerText": "If you’re looking for **great pizza in Brooklyn**, these are the spots I’d put on a shortlist. ...",
  "sources": [
    {
      "index": 1,
      "title": "The 22 Best Pizza Places In Brooklyn - New York - The Infatuation",
      "url": "https://www.theinfatuation.com/new-york/guides/a-guide-to-the-best-brooklyn-pizza",
      "attribution": "The Infatuation"
    }
  ],
  "chatgptPlaceId": "lbe1_OD3p9PjdiyDg2-y4ZSh0LHDA",
  "conversationId": "6ab7821b-1f84-83ea-ac98-c26561ee38b7",
  "model": "gpt-5-6",
  "scrapedAt": "2026-09-26T08:40:10.588Z"
}
```

`answerText` and `sources` are identical on every row of the same query, so you can group by `query` and read them once.

***

### How much does it cost to scrape ChatGPT Maps?

ChatGPT Maps Scraper uses **pay per event + platform usage**. You pay Apify's compute and residential-proxy usage for the run, plus:

| Event | Price (Free plan) | What it is |
| --- | --- | --- |
| Actor start | $0.00005 per GB of memory | Once per run |
| ChatGPT answer | $0.005 | One answered query |
| Place result | $0.49 per 1,000 | One saved place |

Place-result prices are lower on paid Apify plans (about $0.37 per 1,000 on Gold and above). A typical query returns 5–10 places. Exact prices are on the **Pricing** tab.

Each query runs in a real browser through a residential proxy, which is the usage charge on your Apify bill. Keep `maxItems` at the default and only enable `includeCandidatePlaces` when you need the extra rows.

***

### FAQ

#### Does this need an OpenAI account or ChatGPT Plus?

No. ChatGPT Maps is available to logged-out visitors and this Actor uses that public experience. You never provide credentials.

#### Why do results differ between runs?

ChatGPT generates a fresh answer every time, so the set and order of places can change slightly, just as it would for two different people asking the same question. That variance is part of what you measure when tracking AI visibility — schedule repeated runs and look at trends rather than a single snapshot.

#### Are results location-aware?

Yes, in two ways. Put the place name in your query (`… in Brooklyn`) for explicit targeting, or leave it out and ChatGPT uses the proxy's region as "nearby". Change `apifyProxyCountry` to test other markets.

#### What if ChatGPT answers without a map?

Some questions (very broad or non-local ones) return prose with no places pinned. The run logs a warning for that query and saves no rows; rephrase with a clearer place type and location.

#### Can I use this as a ChatGPT Maps API?

Yes. Start runs and fetch the dataset through the Apify API (see the **API** tab), trigger them from Zapier, Make, or n8n, or schedule them in Console. There is no official ChatGPT Maps API today; this Actor is the closest equivalent.

#### Is it legal to scrape ChatGPT Maps?

The Actor collects the publicly shown answer for a query and the public business listing details ChatGPT displays (business names, addresses, ratings). It does not access private accounts or personal data. Use the data responsibly and review OpenAI's terms for your use case.

#### Related Actors

- [Google Maps Reviews & AI Insights Scraper](https://apify.com/rainminer/google-maps-place-reviews-scraper) — reviews, ratings, and AI themes for the places ChatGPT recommends
- [Google Maps Menu Scraper](https://apify.com/rainminer/google-maps-menu-scraper) — menu items and prices for restaurants
- [Google Maps Review Summary Scraper](https://apify.com/rainminer/google-maps-review-summary-scraper) — Google's review summaries per listing

Questions or feature requests? Open a ticket on the **Issues** tab.

### Image Credit

Image credit: [chatgpt.com](https://chatgpt.com/maps)

# Actor input Schema

## `queries` (type: `array`):

Natural-language place searches, one per line, exactly as you would ask ChatGPT Maps. Include the city or area in the query (for example `best pizza places in Brooklyn, New York`) unless you fill in the Location field below.

## `location` (type: `string`):

City, neighborhood, or address appended to every query as ` in <location>`. Leave empty when your queries already contain a location.

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

Maximum number of recommended places to save for each query. ChatGPT Maps typically features 5–10 places per answer.

## `includeCandidatePlaces` (type: `boolean`):

Also save the places ChatGPT looked up for the query but did not feature in its answer or on the map. These rows have `featured: false` and count toward Maximum places per query.

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

chatgpt.com blocks datacenter IPs, so residential proxies are required. The proxy country also decides which region ChatGPT treats as 'nearby' for queries without an explicit location.

## Actor input object example

```json
{
  "queries": [
    "best pizza places in Brooklyn, New York"
  ],
  "maxItems": 10,
  "includeCandidatePlaces": false,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# 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 = {
    "queries": [
        "best pizza places in Brooklyn, New York"
    ],
    "location": "",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "US"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rainminer/chatgpt-maps-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 = {
    "queries": ["best pizza places in Brooklyn, New York"],
    "location": "",
    "maxItems": 10,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "US",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("rainminer/chatgpt-maps-scraper").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 '{
  "queries": [
    "best pizza places in Brooklyn, New York"
  ],
  "location": "",
  "maxItems": 10,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}' |
apify call rainminer/chatgpt-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,rainminer/chatgpt-maps-scraper"
        }
    }
}
```

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/ySgOoAwxoFBmALcvB/builds/K2oraISjml2elcTUA/openapi.json