# Google Maps Real Estate Agency Data Scraper (`enezli/realestate-agency-maps-scraper`) Actor

Google Maps scraper for real estate agencies and agents in any city. Get clean, de-duplicated JSON: name, address, phone, website, category, rating, and place ID. No API key needed, no quota limits.

- **URL**: https://apify.com/enezli/realestate-agency-maps-scraper.md
- **Developed by:** [Turgay NANTA](https://apify.com/enezli) (community)
- **Categories:** Agents, MCP servers, Real estate
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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

## Real Estate Agency Maps Scraper — No API Key, Real Browser Rendering

Search Google Maps for real estate agencies and agents in any city and get clean, de-duplicated business JSON — name, address, phone, website, category, rating, coordinates, and Google Place ID. No API key, no quota limits.

Runs with **one click — no required fields**. Type a city/niche query (or use the default), get clean, de-duplicated JSON. Built for both humans and AI agents (MCP-ready).

### What it does

Google Maps doesn't expose a public API for this kind of search — and even a "view source" HTTP fetch of the search page returns almost nothing, because Google loads real results **after** the page renders, through a separate background request your browser makes automatically. This actor drives a real headless Chromium browser (Playwright), lets Google Maps load exactly as it would for a human visitor, and captures that background data response directly — so it gets the same structured data Google itself uses to draw the results panel, not a fragile HTML scrape of visible text.

Focused on **real estate agencies and agents** specifically (not property listings) — a narrower, less-saturated slice of Google Maps business data than a generic "search anything" Maps scraper.

### Quick start (no code)

1. Click **Start** with the default query, or type your own (e.g. `"real estate agency Denver CO"`, `"realtor Miami"`).
2. Wait a few seconds while a real browser loads the search and the actor captures the results.
3. Export the dataset as JSON, CSV, or Excel directly from the Apify Console, or pull it via API.

### Input

| Field | Required | Description |
|---|---|---|
| `query` | no | What to search on Google Maps — niche + city works best (default: `real estate agency Austin TX`) |
| `maxResults` | no | Max clean results (default 20, cap 500 — see Limitations: a single query page returns up to ~20) |
| `enrich` | no | Deterministic enrichment per record (email extraction, domain, completeness score) |
| `monitor` | no | Compare with the previous run, flag NEW businesses only — ideal for scheduled runs tracking a market over time |

### Output (dataset, per record)

Real example — query `"real estate agency Seattle WA"` (captured live 2026-08-11, unedited):

```json
{
  "id": "",
  "title": "Every Door Real Estate",
  "url": "https://www.everydoorrealestate.com/",
  "location": "5506 6th Ave S #204, Seattle, WA 98108",
  "rating": 4.9,
  "phone": "+12062220531",
  "category": "Real estate agency",
  "categories": ["Real estate agency", "Commercial real estate agency", "Real estate agent", "Real estate consultant", "Real estate developer"],
  "lat": 47.5531558,
  "lng": -122.3260943,
  "place_id": "ChIJOR9o-cBBkFQRR-k_PH6pJzc",
  "timezone": "America/Los_Angeles",
  "photo": "https://lh4.googleusercontent.com/-BapoiMOP6YM/AAAAAAAAAAI/AAAAAAAAAAA/NNgzBJxuClU/s44-p-k-no-ns-nd/photo.jpg",
  "completeness": 0.5
}
```

The final dataset row `_summary` carries run totals (`total_clean`, `deduped`, `enriched`). In monitor mode, a `_changes` row lists Place IDs that are new since the last run.

**Field reference**
| Field | Meaning |
|---|---|
| `title` | Business name |
| `location` | Full formatted address |
| `phone` | E.164 phone number (`+1...`) |
| `category` / `categories` | Google's business category, primary + all listed |
| `lat` / `lng` | Coordinates |
| `place_id` | Google's official Place ID (`ChIJ...`) — stable, usable in Google's own APIs |
| `timezone` | IANA timezone of the business location |
| `photo` | Cover photo URL, when Google has one |

### Use cases

- **Local market mapping** — pull every real estate agency in a city or ZIP for territory planning.
- **Lead lists** — name, phone and website in one clean row, ready to import into a CRM.
- **Competitor tracking** — monitor a market weekly (`monitor: true`) to catch new agencies opening.
- **Recruiting research** — brokerages find independent agents/teams to recruit by scanning a metro area.
- **AI agents** — an agent researching a local market can call this directly via MCP instead of writing scrape code.

### Enrichment (optional, charged only when it produces something)

With `enrich: true`, each record gets an `emails` field (extracted from any text fields), a `domain` field (canonical host from the website URL) and a `completeness` score (0–1). No LLM is used anywhere in this actor — enrichment is deterministic, so output is stable run to run and costs are fully predictable in advance.

### Monitor mode — change alerts on a schedule

Set `monitor: true` and schedule the actor (daily/weekly via Apify's built-in Scheduler). Each run compares the current result set against the previous one and adds a `_changes` row listing only the Place IDs that weren't there before — wire an alert off new agencies opening in a market without re-processing the whole result set yourself.

### Use it from your code

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("enezli/realestate-agency-maps-scraper").call(run_input={
    "query": "real estate agency Denver CO",
    "maxResults": 20,
    "enrich": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)
```

```bash
curl "https://api.apify.com/v2/acts/enezli~realestate-agency-maps-scraper/run-sync-get-dataset-items?token=<YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"query": "real estate agency Denver CO", "maxResults": 20}'
```

### Use it with AI agents (MCP)

This actor is listed under the `MCP_SERVERS` category and works out of the box as an Apify MCP tool — an agent researching a local real estate market can call it directly with a `query` and get structured JSON back, no scraping code for the agent to write or maintain.

### Pricing — Pay-Per-Event, start is free

You only pay for what you get — no subscription, no charge for a run that finds nothing useful:
| Event | When charged |
|---|---|
| `actor-start` | $0.0001 — symbolic, effectively free |
| `result` | $0.002 per clean business record returned |
| `enrichment` | $0.01 — only for a record that actually got enriched |
| `change-alert` | $0.005 — monitor mode only, per NEW business since the previous run |

Volume discounts apply automatically via Apify account tiers (up to −44% on GOLD).

### Is this legal?

This actor collects **publicly available data only** — the same business information any visitor sees on Google Maps in a browser, without logging in. It does not bypass authentication, does not access private data, and does not store personal credentials. You are responsible for using the output in compliance with Google's Terms of Service and applicable law (e.g. GDPR, TCPA if you use phone numbers for outbound calls/texts) in your jurisdiction.

### Support & feedback

Found a bug, or need a field this actor doesn't return yet (e.g. review count — see Limitations below)? **Open an issue** on the actor's Issues tab. Feature requests are welcome; frequently-requested fields get added to the standard output in a future version.

### Changelog

- **0.1 (2026-08-11)** — Initial release: real-browser-rendered Google Maps search, clean/de-duplicated JSON, optional deterministic enrichment, monitor mode.

### Limitations (honest ones)

- **No review count in this version.** Google's minimal search-results response includes a star rating but not the number of reviews behind it (verified across 20+ live businesses during development) — adding it means an extra request per business, planned for a future version, not silently promised here.
- **Single page of results (~20 max) per query.** Getting more requires simulating map panning/scrolling, which this version doesn't do — for full city coverage, run multiple narrower queries (by neighborhood or ZIP) instead of one broad one.
- Uses a real headless browser, so a run is slower (typically 15-30s) and slightly more resource-intensive than a plain HTTP-based actor in this family — reflected in the same per-result pricing, not a separate surcharge.
- Google's internal response format can change without notice; if a run suddenly returns 0 results, please open an issue so the parser can be updated.

### FAQ

**Do I need a Google API key or billing account?** No — it drives a real browser against the public Maps site, no Google Cloud project or API key required.
**Does this scrape property listings (like Zillow)?** No — this actor returns real estate **agencies and agents** as Google Maps business listings, not for-sale/for-rent property data.
**Can I get more than ~20 results for one city?** Run several queries scoped to neighborhoods or ZIP codes within the city instead of one citywide query — each returns its own up-to-20 set.
**Why is `completeness` sometimes below 1.0?** The scoring field checks a general set of business fields (title, url, price, location, seller, rating); this actor doesn't set `price` or `seller` (not meaningful for an agency listing), so a partial score is expected, not a data-quality problem.

# Actor input Schema

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

What to search for on Google Maps. Leave empty to use the default example query — the actor runs with one click, no required fields.

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

Maximum number of clean results to return (capped at 500).

## `enrich` (type: `boolean`):

Adds deterministic enrichment per record: extracted emails, canonical domain and a completeness score. Charged per enriched record (see Pricing).

## `monitor` (type: `boolean`):

Compares this run with the previous one and flags NEW records only. Ideal for scheduled runs — get alerted when something changes. Charged per change.

## Actor input object example

```json
{
  "query": "real estate agency Austin TX",
  "maxResults": 20,
  "enrich": false,
  "monitor": false
}
```

# Actor output Schema

## `results` (type: `string`):

Clean, normalized and de-duplicated records scraped from Google Maps, as JSON. Each item follows the dataset schema (see storages.dataset.fields in actor.json).

# 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 = {
    "query": "real estate agency Austin TX"
};

// Run the Actor and wait for it to finish
const run = await client.actor("enezli/realestate-agency-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 = { "query": "real estate agency Austin TX" }

# Run the Actor and wait for it to finish
run = client.actor("enezli/realestate-agency-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 '{
  "query": "real estate agency Austin TX"
}' |
apify call enezli/realestate-agency-maps-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,enezli/realestate-agency-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/1cgrgmWiv2wZNQAUj/builds/7yASP4ywwTcNaew04/openapi.json