# Google Maps Rank Tracker (`vasram/google-maps-rank-tracker`) Actor

See exactly where your business ranks on Google Maps with a visual geo-grid heatmap. Get competitor analysis, threat scores, zone breakdown, trend tracking, and a shareable HTML dashboard. LocalFalcon alternative — 50% cheaper, no monthly fees. Pay only per scan.

- **URL**: https://apify.com/vasram/google-maps-rank-tracker.md
- **Developed by:** [Vasram Sonagara](https://apify.com/vasram) (community)
- **Categories:** SEO tools, Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

Track your **Google Business Profile ranking** across a geographic grid — just like [LocalFalcon](https://localfalcon.com) — but at **half the cost** and fully automated on Apify. Enter your business name, a keyword, and a location. The actor scans [Google Maps](https://maps.google.com) at every point on a customizable geo-grid and calculates professional **Local SEO metrics**: Share of Local Voice (SoLV), Average Rank Position (ARP), competitor leaderboards, gap analysis, zone-by-zone breakdown, trend tracking, and a beautiful **interactive HTML heatmap dashboard** — ready for client presentations.

No coding required. Results in JSON, CSV, Excel, or a self-contained HTML dashboard.

🎁 **LAUNCH OFFER — Free for first 2 weeks! Only pay Apify compute charges. Start tracking now!**

![Hero screenshot of the HTML dashboard with geo-grid heatmap](https://plain-apac-prod-public.komododecks.com/202605/19/4ehM04ZzHaYSlbgO334S/image.png)

---

### 🎯 What can Google Maps Rank Tracker do?

This actor is a **complete local SEO rank tracking tool** built for agencies, small business owners, and SEO consultants. It replicates the functionality of expensive tools like LocalFalcon and BrightLocal's Local Search Grid — at a fraction of the cost.

**Core capabilities:**

- 📍 **Geo-grid rank scanning** — Scan a 3×3 or 5×5 grid around your business location (7×7 to 15×15 coming soon!)
- 📊 **Industry-standard metrics** — SoLV (Share of Local Voice), ARP (Average Rank Position), ATRP (Average True Rank Position), Dominance Score, Visibility %
- 🏆 **Competitor leaderboard** — See who's outranking you, where they beat you, and their threat level (🔴 HIGH / 🟡 MEDIUM / 🟢 LOW)
- 📉 **Gap analysis** — Rating gap, review count gap, and category advantage vs. the market leader
- 🗺️ **Interactive HTML heatmap** — A self-contained dashboard with Leaflet.js map, color-coded grid, and score cards
- 📈 **Trend tracking over time** — Compare scans to see rank changes, SoLV deltas, and new/lost competitors
- 🔍 **Zone-by-zone analysis** — North, South, East, West, Center — see exactly where you're strong, weak, or have opportunities
- 💡 **Automated insights & alerts** — CRITICAL / WARNING / OPPORTUNITY alerts with suggested actions and recommendations
- ⭐ **Review breakdown** — Star distribution (1★–5★) for your business without extra tools
- 🏷️ **Category mismatch detection** — Flags competitors ranking for your keyword who are in a different business category
- 🌍 **10 language support** — English, Hindi, Spanish, French, German, Portuguese, Arabic, Japanese, Korean, Chinese
- 🔗 **Apify platform integrations** — Schedule daily/weekly scans, use webhooks, connect with Zapier, Make, or your own API

![Scoring dashboard showing grade and 4-component breakdown](https://plain-apac-prod-public.komododecks.com/202605/19/JA9A6UlZruWHJCdTe1OW/image.png)

---

### 📊 What data can you extract from Google Maps rankings?

| Data Category | What You Get |
|:---|:---|
| **Your Business Profile** | Name, address, rating, reviews, categories, phone, website, opening hours, Place ID, Google Maps URL, business status |
| **Review Breakdown** | Star-by-star distribution (5★ to 1★ count), price level |
| **Rank at Each Grid Point** | Rank position (1–20+), Local Pack status (top 3), zone color (🟢🟡🔴⚫), direction (N/S/E/W/NE/NW/SE/SW/Center), distance from center, Google Maps search link |
| **Core Metrics** | SoLV, ARP, ATRP, Visibility %, Dominance Score (0–100), Letter Grade (A+ to F), rank distribution, median rank |
| **Scoring Breakdown** | Overall score with 4 weighted components: Local Pack Presence (35%), Overall Visibility (25%), Rank Quality (25%), Geographic Coverage (15%) |
| **Competitor Leaderboard** | Top competitors ranked by threat score — with their SoLV, ARP, rating, reviews, head-to-head comparison, and category mismatch flag |
| **Gap Analysis** | Rating gap to leader, review count gap, category advantage detection |
| **Zone Analysis** | N/S/E/W/Center performance with per-zone SoLV, grade, and status (DOMINANT / STRONG / WEAK / CRITICAL) + strongest, weakest, and opportunity zone |
| **Trend Tracking** | Rank changes vs. previous scan, SoLV delta, new/lost competitors (requires 2+ scans) |
| **Automated Insights** | Alerts (CRITICAL / WARNING / POSITIVE / OPPORTUNITY), actionable recommendations, and a plain-English summary |
| **HTML Dashboard** | Interactive map with color-coded grid markers, score card, competitor table, zone chart — downloadable as a single HTML file |

---

### 💡 Why track your Google Maps rankings?

Tracking your Google Maps rank from a single location gives you **incomplete data**. Your ranking changes depending on where the searcher is standing. A customer 2 miles north of your business might see you at #1, while someone 3 miles south sees you at #15 — or not at all.

**Geo-grid rank tracking solves this** by scanning your rank from dozens of locations across your service area.

Here's how businesses use this data:

- 🏢 **Local SEO agencies** — Generate professional client reports showing exactly where they rank (and where they don't)
- 🔧 **Service businesses** (plumbers, HVAC, lawyers, dentists) — Discover which neighborhoods you're invisible in
- 📈 **Track SEO progress** — Run weekly scans to measure whether your optimization efforts are actually working
- 🕵️ **Competitive intelligence** — See which competitors dominate your area and how you compare head-to-head
- 📋 **Multi-location brands** — Audit Google Maps performance for each branch or franchise location
- 💼 **Pitch new clients** — Show prospects their current ranking gaps to win local SEO contracts

---

### 🚀 How to track Google Maps rankings

It takes less than 2 minutes to run your first scan. No coding needed.

1. **Click "Try for free"** on this page to open the actor in Apify Console
2. **Enter your business name** exactly as it appears on Google Maps (e.g., `"Joe's Pizza"`)
3. **Enter a search keyword** you want to track (e.g., `"pizza near me"`, `"best plumber"`)
4. **Enter your location** — a city name or full address (e.g., `"Brooklyn, NY"`) — or provide exact lat/lng coordinates
5. **Choose your grid size** — Pick 3×3 (9 points) for a quick scan, or 5×5 (25 points) for deeper analysis. Larger grids (up to 15×15) coming soon!
6. **Click "Start"** — The actor scans Google Maps at every grid point and delivers your full report

![Screenshot of the Apify Console input form with fields filled in](https://plain-apac-prod-public.komododecks.com/202605/19/DvAGoN7XNSVCqJltDvvy/image.png)

> 💡 **Pro tip:** Schedule this actor to run daily or weekly using [Apify Schedules](https://docs.apify.com/platform/schedules) to automatically track your ranking trends over time.

---

### 📥 Google Maps Rank Tracker input configuration

The actor accepts the following inputs. For full technical details, see the **Input tab** on the actor page.

| Field | Required | Default | Description |
|:---|:---:|:---:|:---|
| `businessName` | ✅ | — | Your business name as shown on Google Maps |
| `keyword` | ✅ | — | Search keyword to track (e.g., `"dentist near me"`) |
| `location` | ⭐ | — | Address or city name (auto-geocoded to lat/lng) |
| `lat` / `lng` | — | — | Exact coordinates (use instead of location) |
| `placeId` | — | — | Google Place ID for exact business matching (starts with `ChI`) |
| `gridSize` | — | `3x3` | Grid dimensions: `3x3` or `5x5` (7×7 to 15×15 coming soon) |
| `radius` | — | `5` | Search radius from center (0.1–100) |
| `measurement` | — | `km` | Unit: `km` or `miles` |
| `gridSpacingKm` | — | auto | Custom grid spacing in km (overrides auto-calculation from radius) |
| `language` | — | `en` | Search language (10 languages supported) |
| `country` | — | `us` | 2-letter country code (e.g., `in`, `uk`, `de`) |
| `maxCompetitorsPerPoint` | — | `5` | Competitors to track per grid point (1–20) |
| `fetchReviews` | — | `true` | Fetch star distribution for your business |

**Example input (JSON):**

```json
{
    "businessName": "Joe's Pizza",
    "keyword": "best pizza",
    "location": "Brooklyn, NY",
    "gridSize": "5x5",
    "radius": 5,
    "measurement": "km",
    "language": "en",
    "country": "us",
    "maxCompetitorsPerPoint": 5,
    "fetchReviews": true
}
````

***

### 📤 Google Maps Rank Tracker output example

You can download the dataset in **JSON, CSV, Excel, XML, or HTML** format from the Output tab. The actor also generates an **interactive HTML dashboard** saved in the Key-Value Store.

Here's a simplified example of the JSON output for a single scan:

```json
{
    "scanId": "scan_586f0187b2ba",
    "status": "COMPLETED",
    "scanDate": "2026-05-18T11:06:41.807Z",
    "scanDurationSeconds": 39.1,
    "platform": "google_maps",
    "version": "1.0.0",

    "scanConfig": {
        "gridSize": "3x3",
        "totalGridPoints": 9,
        "radiusKm": 2.0,
        "keyword": "mexican restaurant near me",
        "language": "en",
        "country": "in"
    },

    "targetBusiness": {
        "name": "Mexicano by the Bay",
        "placeId": "ChIJ2X9gXEaFXjkR2appNaI5hYM",
        "address": "Ground Floor, Riverfront House, Ahmedabad, Gujarat 380009",
        "googleMapsUrl": "https://maps.google.com/?cid=9477044359714679513",
        "rating": 4.3,
        "totalReviews": 4297,
        "primaryCategory": "Mexican restaurant",
        "reviewsBreakdown": { "5star": 2148, "4star": 1289, "3star": 215, "2star": 215, "1star": 430 },
        "priceLevel": "₹400–600",
        "openingHours": { "Monday": "10 AM–11:30 PM", "...": "..." },
        "businessStatus": "OPERATIONAL"
    },

    "metrics": {
        "solv": 100.0,
        "solvGrade": "A+",
        "solvDescription": "You DOMINATE this area",
        "arp": 1.33,
        "arpGrade": "A",
        "atrp": 1.33,
        "visibilityPercent": 100.0,
        "dominanceScore": 98.1,
        "totalPoints": 9,
        "pointsRanked": 9,
        "pointsInTop3": 9,
        "pointsInTop10": 9,
        "bestRank": 1,
        "worstRank": 3,
        "medianRank": 1.0,
        "rankDistribution": { "rank1": 7, "rank2": 1, "rank3": 1, "rank4to5": 0, "rank6to10": 0, "notRanked": 0 }
    },

    "scoring": {
        "overallScore": 98,
        "overallGrade": "A+",
        "breakdown": {
            "localPackPresence": { "score": 100.0, "weight": 0.35, "label": "Local Pack Presence (Top 3)" },
            "overallVisibility": { "score": 100.0, "weight": 0.25, "label": "Overall Visibility (Top 20)" },
            "rankQuality": { "score": 93.7, "weight": 0.25, "label": "Rank Quality (Avg Position)" },
            "coverageSpread": { "score": 96.6, "weight": 0.15, "label": "Geographic Coverage Spread" }
        }
    },

    "gridData": {
        "totalPoints": 9,
        "gridSummaryMatrix": [[1, 1, 1], [3, 1, 1], [1, 2, 1]],
        "points": [
            {
                "pointIndex": 0,
                "lat": 23.041151,
                "lng": 72.540717,
                "direction": "NW",
                "rank": 1,
                "rankFound": true,
                "zone": "localPack",
                "zoneColor": "#22C55E",
                "zoneEmoji": "🟢",
                "inLocalPack": true,
                "searchUrl": "https://www.google.com/maps/search/...",
                "topCompetitorsAtPoint": [
                    { "rank": 1, "name": "Mexicano by the Bay", "rating": 4.3, "totalReviews": 4297 },
                    { "rank": 2, "name": "DosBros Mexican Restaurant", "rating": 4.4, "totalReviews": 1360 }
                ]
            }
        ]
    },

    "competitorAnalysis": {
        "totalUniqueCompetitors": 12,
        "leaderboard": [
            {
                "rank": 1,
                "name": "The Mexican Tapas Bar",
                "solv": 66.67,
                "solvGrade": "B",
                "arp": 3.5,
                "threatLevel": "LOW",
                "threatEmoji": "🟢",
                "pointsWhereTheyBeatYou": 0,
                "pointsWhereYouBeatThem": 8,
                "isCategoryMismatch": true
            }
        ],
        "gapAnalysis": {
            "ratingGapToLeader": -0.4,
            "reviewGapToLeader": 4232,
            "categoryAdvantage": false,
            "leader": { "name": "The Mexican Tapas Bar", "rating": 4.7, "totalReviews": 65 }
        }
    },

    "zoneAnalysis": {
        "zones": [
            { "zone": "CENTER", "emoji": "🏠", "avgRank": 1.0, "solv": 100.0, "grade": "A+", "status": "DOMINANT", "insight": "You dominate CENTER. Excellent core presence!" },
            { "zone": "NORTH", "emoji": "⬆️", "avgRank": 1.0, "solv": 100.0, "grade": "A+", "status": "DOMINANT" },
            { "zone": "SOUTH", "emoji": "⬇️", "avgRank": 1.5, "solv": 100.0, "grade": "A+", "status": "DOMINANT" },
            { "zone": "EAST", "emoji": "➡️", "avgRank": 1.0, "solv": 100.0, "grade": "A+", "status": "DOMINANT" },
            { "zone": "WEST", "emoji": "⬅️", "avgRank": 1.7, "solv": 100.0, "grade": "A+", "status": "DOMINANT" }
        ],
        "strongestZone": { "zone": "CENTER", "grade": "A+" },
        "weakestZone": { "zone": "WEST", "grade": "A+" },
        "opportunityZone": { "zone": "WEST", "grade": "A+" }
    },

    "insights": {
        "alerts": [
            {
                "type": "POSITIVE",
                "emoji": "🏆",
                "title": "Excellent Local Pack Presence!",
                "message": "You appear in the Local Pack at 9 out of 9 points (100% SoLV).",
                "suggestedAction": "Keep it up! Continue posting regularly and collecting reviews."
            }
        ],
        "totalAlerts": 1,
        "criticalAlerts": 0,
        "recommendations": [
            "🏷️ Consider adding categories: Takeout Restaurant (used by a top competitor).",
            "📝 Post weekly Google Business updates with local keywords and photos."
        ],
        "summary": "Your business ranks in the Google Maps Local Pack (top 3) at 9 out of 9 grid points (100% SoLV)."
    },

    "trendComparison": null,

    "exportInfo": {
        "generatedBy": "GMaps-Rank-Grid-Tracker v1.0.0",
        "reportUrl": "https://api.apify.com/v2/key-value-stores/.../records/report.html"
    }
}
```

> 📌 This is a **simplified example** from an actual scan. The full output contains detailed data for every grid point, all competitors with contact info, and complete zone breakdowns. `trendComparison` populates automatically when you run multiple scans over time.
>
> 🔗 **[View the full JSON output from a live scan →](https://api.apify.com/v2/datasets/4zoSTTlkPdA29ru4y/items?format=json\&limit=1000\&clean=true)**

***

### 🗺️ Interactive HTML heatmap dashboard

Every scan generates a **self-contained HTML report** saved in the Key-Value Store as `report.html`. Open it in any browser — no server needed.

**The dashboard includes:**

- 🗺️ **Interactive Leaflet.js map** — Color-coded grid markers showing your rank at each point (🟢 Top 3 / 🟡 4-10 / 🔴 11-20 / ⚫ Not Found)
- 📊 **Score card** — Overall grade, SoLV, ARP, ATRP, and Dominance Score at a glance
- 🏆 **Competitor leaderboard table** — Sortable list of all competitors with head-to-head metrics
- 🧭 **Zone analysis chart** — Compass-based geographic performance (N/S/E/W/Center)
- 💡 **Insights panel** — Automated alerts and recommended actions
- 📈 **Trend comparison** — Side-by-side current vs. previous scan metrics (when available)

The report is designed for **client presentations** — print it or save as PDF directly from your browser.

> 🌐 **[Open a live HTML dashboard example →](https://api.apify.com/v2/key-value-stores/hO1UbCGpZgmC6bMCY/records/report.html)**

![Full dashboard showing the map with grid markers and score card](https://plain-apac-prod-public.komododecks.com/202605/19/rjTbC9JS6NCFijA4GCad/image.png)

![Close-up of the interactive map with colored grid point markers](https://plain-apac-prod-public.komododecks.com/202605/19/5nXLDg5YuCmGhkPezhdm/image.png)

***

### 💰 How much does it cost to track Google Maps rankings?

#### 🎁 Launch offer — Free for first 2 weeks!

**For the first 2 weeks, this actor is completely free to use.** You only pay standard Apify platform compute charges (which are minimal — typically a few cents per scan). This is your chance to try professional-grade local SEO tracking at zero cost.

After the launch period, pricing will follow a simple **pay-per-scan** model — still dramatically cheaper than any alternative on the market.

#### Pricing comparison: Google Maps Rank Tracker vs. alternatives

| Feature | 📍 This Actor | LocalFalcon | BrightLocal |
|:---|:---:|:---:|:---:|
| **Monthly cost** | **Pay per scan** | $25–$200/mo | $39–$79/mo |
| **Cost per scan (5×5 grid)** | **$0.60** | $1.25 (PAYG) | ~$3.00+ |
| **Grid sizes** | 3×3, 5×5 *(up to 15×15 soon)* | 3×3 to 21×21 | Fixed grids |
| **Competitor leaderboard** | ✅ Included | ❌ Extra cost | ✅ Limited |
| **Gap analysis** | ✅ Included | ❌ Not available | ❌ Not available |
| **Automated insights** | ✅ Free | ❌ Not available | ❌ Not available |
| **Trend tracking** | ✅ Built-in | ✅ Available | ✅ Available |
| **Interactive HTML report** | ✅ Downloadable | ❌ Web only | ❌ Web only |
| **API access** | ✅ Full REST API | ❌ Limited | ❌ Limited |
| **Scheduling** | ✅ Via Apify | ✅ Built-in | ✅ Built-in |
| **JSON/CSV export** | ✅ Free | ✅ Included | ✅ Included |
| **Zapier / Make integration** | ✅ Yes | ❌ No | ❌ Limited |
| **No monthly commitment** | ✅ Pay as you go | ❌ Monthly plan | ❌ Monthly plan |

#### Estimated cost per scan

| Grid Size | Points Scanned | Cost per Scan | LocalFalcon PAYG | You Save | Status |
|:---:|:---:|:---:|:---:|:---:|:---:|
| 3×3 | 9 | **$0.25** | $0.45 | 44% | ✅ Available now |
| 5×5 | 25 | **$0.60** | $1.25 | 52% | ✅ Available now |
| 7×7 | 49 | **~$1.10** | $2.45 | 55% | 🔜 Coming soon |
| 9×9 | 81 | **~$1.80** | $4.05 | 56% | 🔜 Coming soon |
| 15×15 | 225 | **~$4.90** | $11.25 | 56% | 🔜 Coming soon |

> 💡 **Example:** Run **80+ full 5×5 scans for just $49/month** — that's 80 complete client reports with competitor analysis, insights, and HTML dashboards. The same on LocalFalcon would cost **$100+**.

Apify gives you **$5 free usage credits every month** on the [Free plan](https://apify.com/pricing). That's enough for approximately **8 scans (5×5 grid)** — completely free, every month!

***

### 🔗 Can I use Google Maps Rank Tracker as an API?

Yes. You can use the [Apify API](https://docs.apify.com/api/v2) to run this actor programmatically from any language.

**Python example:**

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_API_TOKEN")

run = client.actor("YOUR_USERNAME/google-maps-rank-tracker").call(run_input={
    "businessName": "Joe's Pizza",
    "keyword": "best pizza",
    "location": "Brooklyn, NY",
    "gridSize": "5x5",
})

dataset = client.dataset(run["defaultDatasetId"]).list_items().items
print(dataset[0]["metrics"]["solv"])  ## 72.5
print(dataset[0]["scoring"]["overallGrade"])  ## "B+"
```

**Node.js example:**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'YOUR_API_TOKEN' });

const run = await client.actor('YOUR_USERNAME/google-maps-rank-tracker').call({
    businessName: "Joe's Pizza",
    keyword: "best pizza",
    location: "Brooklyn, NY",
    gridSize: "5x5",
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0].metrics.solv); // 72.5
```

You can also integrate with **[Zapier](https://apify.com/integrations)**, **[Make](https://apify.com/integrations)**, **Google Sheets**, **Slack**, and more using Apify's built-in integrations.

***

### ❓ Frequently Asked Questions

#### What is Share of Local Voice (SoLV)?

SoLV measures the percentage of grid points where your business appears in the **top 3 results** (the Google Maps "Local Pack"). A SoLV of 72% means your business shows up in the Local Pack at 72% of the scanned locations. Higher is better — top-performing local businesses typically score 70%+.

#### Is this a LocalFalcon alternative?

Yes. This actor provides the same geo-grid rank tracking functionality as [LocalFalcon](https://localfalcon.com), including SoLV scoring, grid-based heatmaps, and competitor analysis — but at a **fraction of the cost**. Key differences:

- **No monthly subscription** — Pay only for what you scan
- **Full API access** — Automate scans and integrate with your tools
- **Downloadable HTML reports** — Own your data, present it offline
- **Automated insights** — Alerts, recommendations, and gap analysis included at no extra cost
- **Category mismatch detection** — See when competitors from different categories are outranking you

#### Is this a BrightLocal alternative?

Yes. This actor provides similar **Local Search Grid** functionality to [BrightLocal](https://www.brightlocal.com), including geo-grid rank tracking and competitor analysis. Key advantages over BrightLocal:

- **No monthly subscription** — BrightLocal starts at $39/mo. This actor has no monthly fees.
- **Per-scan pricing** — Pay only when you run a scan, starting at $0.25
- **Full API access** — Run scans programmatically from Python, Node.js, or any language
- **Gap analysis included** — See your rating and review gap vs. the market leader
- **Downloadable HTML reports** — Self-contained dashboard you can share offline

#### Can I use this Google Maps rank tracker API in Python?

Yes. Use the official `apify-client` [PyPI package](https://docs.apify.com/api/client/python/) to access this actor programmatically. See the [API code examples above](#-can-i-use-google-maps-rank-tracker-as-an-api).

#### How does the geo-grid ranking work?

The actor creates a grid of geographic coordinates around your business location based on the radius and grid size you specify. At each grid point, it queries [Google Maps](https://maps.google.com) for your keyword and checks where your business appears in the results. This gives you a map of your ranking across your entire service area — not just from one location.

#### What are the advantages over the Google Maps API?

The official [Google Maps Places API](https://developers.google.com/maps/documentation/places/web-service) does **not** provide ranking data — it only returns place details. This actor uses a different approach to determine your actual position in Google Maps search results for a given keyword at specific geographic coordinates. The official API also has strict rate limits and costs $17 per 1,000 requests.

#### How accurate is the rank data?

The actor queries real-time Google Maps results with geographic precision (latitude/longitude + search keyword). Results reflect what a user would see when searching from that exact location at the time of the scan. Each grid point triggers an independent search to ensure location-specific accuracy.

#### Can I track multiple keywords?

Currently, each scan tracks **one keyword at a time**. To track multiple keywords (e.g., "plumber near me" AND "emergency plumber"), run separate scans for each keyword. You can automate this using [Apify Schedules](https://docs.apify.com/platform/schedules).

#### How does trend tracking work?

Trend comparison activates automatically when you run **2 or more scans** for the same business and keyword. The actor compares your current scan with the previous one and shows you: SoLV change (📈 up / 📉 down), rank improvements, new competitors that appeared, and competitors that dropped out. Schedule regular scans to build a history.

#### What grid size should I use?

- **3×3 (9 points)** — Quick overview. Good for initial testing. ✅ Available now
- **5×5 (25 points)** — Recommended for most businesses. Provides detailed coverage. ✅ Available now
- **7×7 to 15×15** — 🔜 Coming soon! Larger grids for deep analysis in competitive markets.

> 📢 **Roadmap:** We're actively working on expanding grid support up to 15×15 (225 points). Stay tuned for updates!

#### What is the Dominance Score?

The Dominance Score (0–100) is a composite metric that combines your Local Pack presence, overall visibility, rank quality, and geographic coverage into a single number. It's accompanied by a letter grade (A+ to F) so you can quickly assess your local SEO health at a glance.

#### What is Gap Analysis?

Gap Analysis compares your business against the top competitor in your area. It shows you:

- **Rating gap** — How your Google rating compares to the market leader
- **Review gap** — How many more (or fewer) reviews you have
- **Category advantage** — Whether you're in the same business category as your top competitors

This helps you identify exactly what to improve to overtake the competition.

***

### ⚖️ Is it legal to track Google Maps rankings?

This actor queries publicly available Google Maps search results — the same data any person can see by searching on Google Maps. It does **not** extract private user data, personal information, or data behind any login wall.

We believe this tool, when used for ethical business intelligence and SEO analysis, is safe and compliant. However, you should be aware that your results could contain publicly listed business information. If you are unsure about your use case, consult your legal team.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

***

### 🆘 Support and feedback

- **Found a bug?** Report it on the [Issues tab](https://apify.com/vasram/google-maps-rank-tracker/issues) — I respond within 24 hours
- **Need help?** Leave a comment on the [Issues tab](https://apify.com/vasram/google-maps-rank-tracker/issues) or contact me directly
- **Feature request?** I'm actively developing this actor and welcome suggestions
- **Need a custom solution?** I can build custom Local SEO tools tailored to your needs — reach out via the [Issues tab](https://apify.com/vasram/google-maps-rank-tracker/issues)

Your feedback helps make this tool better for everyone. If you find it useful, please leave a ⭐ review!

# Actor input Schema

## `businessName` (type: `string`):

Exact name of your business as it appears on Google Maps (2-200 characters)

## `placeId` (type: `string`):

Google Place ID for exact matching (starts with 'ChI'). Leave empty to match by name.

## `keyword` (type: `string`):

The keyword to track (e.g., 'plumber near me', 'best restaurant'). 2-100 characters.

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

Enter your business address or city name. We'll auto-detect lat/lng from this. Example: '123 Main St, New York' or 'Connaught Place, Delhi'

## `lat` (type: `number`):

Latitude of grid center (-90 to 90). Leave empty if you provided a Location above.

## `lng` (type: `number`):

Longitude of grid center (-180 to 180). Leave empty if you provided a Location above.

## `gridSize` (type: `string`):

Grid dimensions (more sizes coming soon — up to 15×15!)

## `radius` (type: `number`):

Search radius from center point. Set measurement unit below.

## `measurement` (type: `string`):

Unit for the radius — kilometers or miles

## `language` (type: `string`):

Language for Google Maps search results (e.g., English, Hindi)

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

2-letter country code (e.g., 'in', 'us', 'uk', 'de')

## `maxCompetitorsPerPoint` (type: `integer`):

How many competitor details to store per point (1-20)

## `fetchReviews` (type: `boolean`):

Fetch star distribution (1★-5★) for your business. Uses 1 extra API credit.

## `gridSpacingKm` (type: `number`):

Optional: Override automatic grid spacing. Use smaller values for dense urban areas (e.g., 0.5 km). Leave empty for auto-calculation based on radius.

## Actor input object example

```json
{
  "businessName": "Joe's Pizza",
  "keyword": "best pizza near me",
  "location": "Brooklyn, NY",
  "gridSize": "5x5",
  "radius": 5,
  "measurement": "km",
  "language": "en",
  "country": "us",
  "maxCompetitorsPerPoint": 5,
  "fetchReviews": true
}
```

# Actor output Schema

## `scanResults` (type: `string`):

Full scan data with rankings, SoLV, ARP, competitor leaderboard, gap analysis, zone breakdown, and trend comparison.

## `htmlDashboard` (type: `string`):

Self-contained HTML report with Leaflet.js map, color-coded grid, score cards, and competitor analysis. Opens in any browser.

## `csvExport` (type: `string`):

Flat CSV-compatible rows for spreadsheet import with one row per grid point.

# 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 = {
    "businessName": "Joe's Pizza",
    "keyword": "best pizza near me",
    "location": "Brooklyn, NY",
    "gridSize": "5x5",
    "radius": 5,
    "country": "us"
};

// Run the Actor and wait for it to finish
const run = await client.actor("vasram/google-maps-rank-tracker").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 = {
    "businessName": "Joe's Pizza",
    "keyword": "best pizza near me",
    "location": "Brooklyn, NY",
    "gridSize": "5x5",
    "radius": 5,
    "country": "us",
}

# Run the Actor and wait for it to finish
run = client.actor("vasram/google-maps-rank-tracker").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 '{
  "businessName": "Joe'\''s Pizza",
  "keyword": "best pizza near me",
  "location": "Brooklyn, NY",
  "gridSize": "5x5",
  "radius": 5,
  "country": "us"
}' |
apify call vasram/google-maps-rank-tracker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=vasram/google-maps-rank-tracker",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Rank Tracker",
        "description": "See exactly where your business ranks on Google Maps with a visual geo-grid heatmap. Get competitor analysis, threat scores, zone breakdown, trend tracking, and a shareable HTML dashboard. LocalFalcon alternative — 50% cheaper, no monthly fees. Pay only per scan.",
        "version": "1.0",
        "x-build-id": "gDf5gMQPjK2Yuujgy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/vasram~google-maps-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-vasram-google-maps-rank-tracker",
                "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/vasram~google-maps-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-vasram-google-maps-rank-tracker",
                "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/vasram~google-maps-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-vasram-google-maps-rank-tracker",
                "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": [
                    "businessName",
                    "keyword"
                ],
                "properties": {
                    "businessName": {
                        "title": "Business Name",
                        "minLength": 2,
                        "maxLength": 200,
                        "type": "string",
                        "description": "Exact name of your business as it appears on Google Maps (2-200 characters)"
                    },
                    "placeId": {
                        "title": "Place ID (Optional)",
                        "type": "string",
                        "description": "Google Place ID for exact matching (starts with 'ChI'). Leave empty to match by name."
                    },
                    "keyword": {
                        "title": "Search Keyword",
                        "minLength": 2,
                        "maxLength": 100,
                        "type": "string",
                        "description": "The keyword to track (e.g., 'plumber near me', 'best restaurant'). 2-100 characters."
                    },
                    "location": {
                        "title": "Location (Address / City)",
                        "type": "string",
                        "description": "Enter your business address or city name. We'll auto-detect lat/lng from this. Example: '123 Main St, New York' or 'Connaught Place, Delhi'"
                    },
                    "lat": {
                        "title": "Center Latitude (Optional)",
                        "minimum": -90,
                        "maximum": 90,
                        "type": "number",
                        "description": "Latitude of grid center (-90 to 90). Leave empty if you provided a Location above."
                    },
                    "lng": {
                        "title": "Center Longitude (Optional)",
                        "minimum": -180,
                        "maximum": 180,
                        "type": "number",
                        "description": "Longitude of grid center (-180 to 180). Leave empty if you provided a Location above."
                    },
                    "gridSize": {
                        "title": "Grid Size",
                        "enum": [
                            "3x3",
                            "5x5"
                        ],
                        "type": "string",
                        "description": "Grid dimensions (more sizes coming soon — up to 15×15!)",
                        "default": "3x3"
                    },
                    "radius": {
                        "title": "Radius",
                        "minimum": 0.1,
                        "maximum": 100,
                        "type": "number",
                        "description": "Search radius from center point. Set measurement unit below.",
                        "default": 5
                    },
                    "measurement": {
                        "title": "Measurement Unit",
                        "enum": [
                            "km",
                            "miles"
                        ],
                        "type": "string",
                        "description": "Unit for the radius — kilometers or miles",
                        "default": "km"
                    },
                    "language": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "hi",
                            "es",
                            "fr",
                            "de",
                            "pt",
                            "ar",
                            "ja",
                            "ko",
                            "zh"
                        ],
                        "type": "string",
                        "description": "Language for Google Maps search results (e.g., English, Hindi)",
                        "default": "en"
                    },
                    "country": {
                        "title": "Country",
                        "type": "string",
                        "description": "2-letter country code (e.g., 'in', 'us', 'uk', 'de')",
                        "default": "us"
                    },
                    "maxCompetitorsPerPoint": {
                        "title": "Competitors per Grid Point",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "How many competitor details to store per point (1-20)",
                        "default": 5
                    },
                    "fetchReviews": {
                        "title": "Fetch Review Breakdown",
                        "type": "boolean",
                        "description": "Fetch star distribution (1★-5★) for your business. Uses 1 extra API credit.",
                        "default": true
                    },
                    "gridSpacingKm": {
                        "title": "Custom Grid Spacing (km)",
                        "minimum": 0.1,
                        "maximum": 50,
                        "type": "number",
                        "description": "Optional: Override automatic grid spacing. Use smaller values for dense urban areas (e.g., 0.5 km). Leave empty for auto-calculation based on radius."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
