# Google Maps Rank Tracker (Geo-Grid Local SEO) (`crashlattice57/geo-grid-rank-tracker`) Actor

Track where a business ranks in the Google Maps local pack across a geo-grid of points around its location. Enter a business name, keyword, and city to get per-point ranks, average rank, share of local voice, and top competitors per area. A pay-per-scan LocalFalcon alternative.

- **URL**: https://apify.com/crashlattice57/geo-grid-rank-tracker.md
- **Developed by:** [MooreIQ](https://apify.com/crashlattice57) (community)
- **Categories:** Lead generation, SEO tools, Automation
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.00 / 1,000 grid point scanneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Google Maps Rank Tracker (Geo-Grid Local SEO)

This is a Google Maps rank tracker that shows where a business ranks in the local pack from dozens of points across a city, not just one. You type a business name, a keyword, and a city. It finds the business on Google Maps for you, lays a grid of points over the area, runs the search from each point, and reports the map rank at every point. The result is a geo-grid heatmap of local rankings, plus average rank and share of local voice for each keyword.

![Google Maps geo-grid rank tracker heatmap with average rank and share of local voice](https://api.apify.com/v2/key-value-stores/lWqW7ECIEEBVzg9SA/records/geogrid-hero.png)

It is the same kind of geo-grid local rank tracking that agencies pay a monthly subscription for. Here you pay per scan, with nothing to install.

### Type three things and run

No coordinates. No setup. No CRM connection.

![Enter a business name, keyword, and city - the grid centers on the business automatically](https://api.apify.com/v2/key-value-stores/lWqW7ECIEEBVzg9SA/records/geogrid-easymode.png)

- **Business name**, for example `Loyal Coffee`
- **Keyword**, for example `coffee shop near me`
- **City or area**, for example `Colorado Springs, CO`

The actor looks the business up on Google Maps, reads its real location, and centers the scan there. Everything else has a working default. Advanced settings like grid size and radius are optional and tucked out of the way.

### What it does

- Track Google Maps rankings for any business across a geographic grid
- Find local pack rankings for a keyword at every point in a city
- See a map pack rank tracker heatmap of where a business shows up and where it does not
- Measure average rank position (ARP) for each keyword
- Measure share of local voice (SoLV), the percent of the map a business owns
- Auto-locate a Google Business Profile by name, no coordinates needed
- Capture the top three competitors ranking at each point
- Export results to JSON, CSV, or Excel

### Who uses it

- **Local SEO agencies** reporting rank progress to clients with a real map, not a single number
- **Multi-location businesses** checking coverage across a whole metro
- **Google Business Profile owners** who want to see how far their ranking reaches
- **Freelancers and consultants** who need geo-grid reports without a monthly tool subscription

### How geo-grid rank tracking works

A single rank check tells you one number from one spot. Real customers search from all over town, and Google Maps ranks a business differently depending on where the searcher is standing.

This actor divides the area around a business into a grid of points, usually 5 by 5 (25 points) or larger. At each point it searches your keyword as if a customer were standing there, then records where the business lands in the results. Points near the business usually rank well. Points on the edge of town often drop off. Plotting all of them shows the true reach of a listing.

### Input

The only required fields are the business name and at least one keyword. Add a city so the lookup is accurate.

| Field | Required | What it is |
| --- | --- | --- |
| `businessName` | Yes | The business to track, as it appears on Google Maps. |
| `keywords` | Yes | What customers search. One per line, up to 10. |
| `location` | Recommended | City, state, or neighborhood. Finds the business and sets the area. |
| `gridSize` | No | Rows by columns. 5 means a 5 by 5 grid of 25 points. Default 5. |
| `radiusMiles` | No | How far out from the business to scan, in miles. Default 2. |
| `centerLat`, `centerLng` | No | Power-user override. Set both to skip the auto lookup. |
| `zoom`, `maxRank`, `placeId` | No | Fine-tuning. Safe to ignore. |

#### Example input

```json
{
  "businessName": "Loyal Coffee",
  "keywords": ["coffee shop near me", "espresso"],
  "location": "Colorado Springs, CO",
  "gridSize": 5,
  "radiusMiles": 2
}
````

### What you get

Two kinds of records in the dataset.

**One row per grid point**, so you can build a heatmap:

```json
{
  "recordType": "point",
  "keyword": "coffee shop near me",
  "row": 0, "col": 0,
  "lat": 38.8277, "lng": -104.8224,
  "rank": 1,
  "found": true,
  "targetRating": 4.7,
  "targetReviews": 1824,
  "top3": [{ "name": "Loyal Coffee", "rank": 1 }]
}
```

**One summary row per keyword:**

```json
{
  "recordType": "summary",
  "keyword": "coffee shop near me",
  "arp": 2.4,
  "solv": 71.5,
  "pctTop3": 64.0,
  "found": 22,
  "total": 25
}
```

- **arp**, average rank position across points where the business ranked
- **solv**, share of local voice, how much of the map the business owns from 0 to 100
- **pctTop3**, percent of points ranking in the top three
- **found / total**, how many of the grid points ranked the business at all

### Pricing

You pay per grid point scanned. The size of a scan is grid points times keywords.

- A 5 by 5 grid for one keyword is 25 points
- A 5 by 5 grid for three keywords is 75 points
- A 9 by 9 grid for five keywords is 405 points

The current per-point price is shown at the top of this page. There is no subscription and no minimum. Run one scan or a thousand.

### Geo-grid vs a single rank check

A single rank check tells you where a business sits from one location on one day. It hides the fact that the same business can be number one downtown and invisible five miles away. A geo-grid scan shows the whole picture on a map, which is what wins clients and what proves that local SEO work is moving rankings.

### FAQ

**Do I need latitude and longitude?**
No. Type the business name and a city and the actor finds the exact location for you. Coordinates are an optional override for power users.

**What is share of local voice?**
It is how much of the local map a business owns for a keyword, from 0 to 100. A business ranking first at every point has a high share. One ranking on the edges has a low share.

**How many points should I scan?**
5 by 5 (25 points) is a good default for a single business in one town. Use a larger grid or a bigger radius in miles to cover a full metro.

**Can I track more than one keyword?**
Yes. Add up to 10 keywords and each one is scanned across the whole grid and summarized on its own.

**Does it work outside the United States?**
The default proxy is United States residential. Change the proxy country in the advanced settings for other regions.

**How do I build a heatmap?**
Each point row includes its row, column, latitude, longitude, and rank. Color each point by rank (green for 1 to 3, yellow for 4 to 10, red beyond) and plot it on a map.

# Actor input Schema

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

The business you want to track, exactly as it appears on Google Maps. Example: Loyal Coffee

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

What customers type into Google Maps to find a business like this. Add one per line. Up to 10.

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

City, state, or neighborhood to find the business and set the search area. Example: Colorado Springs, CO

## `gridSize` (type: `integer`):

The scan uses a grid of this many rows by columns. 5 means a 5 x 5 grid of 25 points. Bigger grids cost more.

## `radiusMiles` (type: `number`):

How far out from the business to scan, in miles. 2 covers a typical town. Use a bigger number for a whole metro.

## `centerLat` (type: `number`):

Only for power users. If you set both latitude and longitude, the actor skips the automatic business lookup and centers the grid here.

## `centerLng` (type: `number`):

Only for power users. Set together with center latitude to skip the automatic business lookup and center the grid here.

## `zoom` (type: `integer`):

Google Maps zoom level for each search.

## `maxRank` (type: `integer`):

Positions past this are recorded as not ranked.

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

Optional exact-match hint. Usually left blank because the actor detects it automatically.

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

Proxy used for Google Maps requests. Residential US proxy is the default and recommended setting.

## Actor input object example

```json
{
  "businessName": "Loyal Coffee",
  "keywords": [
    "coffee shop near me"
  ],
  "location": "Colorado Springs, CO",
  "gridSize": 3,
  "radiusMiles": 2,
  "zoom": 13,
  "maxRank": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "US"
  }
}
```

# Actor output Schema

## `results` (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 = {
    "businessName": "Loyal Coffee",
    "keywords": [
        "coffee shop near me"
    ],
    "location": "Colorado Springs, CO",
    "gridSize": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("crashlattice57/geo-grid-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": "Loyal Coffee",
    "keywords": ["coffee shop near me"],
    "location": "Colorado Springs, CO",
    "gridSize": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("crashlattice57/geo-grid-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": "Loyal Coffee",
  "keywords": [
    "coffee shop near me"
  ],
  "location": "Colorado Springs, CO",
  "gridSize": 3
}' |
apify call crashlattice57/geo-grid-rank-tracker --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Google Maps Rank Tracker (Geo-Grid Local SEO)",
        "description": "Track where a business ranks in the Google Maps local pack across a geo-grid of points around its location. Enter a business name, keyword, and city to get per-point ranks, average rank, share of local voice, and top competitors per area. A pay-per-scan LocalFalcon alternative.",
        "version": "0.0",
        "x-build-id": "Wifo6BxZhf6xdzIrJ"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crashlattice57~geo-grid-rank-tracker/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crashlattice57-geo-grid-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/crashlattice57~geo-grid-rank-tracker/runs": {
            "post": {
                "operationId": "runs-sync-crashlattice57-geo-grid-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/crashlattice57~geo-grid-rank-tracker/run-sync": {
            "post": {
                "operationId": "run-sync-crashlattice57-geo-grid-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",
                    "keywords"
                ],
                "properties": {
                    "businessName": {
                        "title": "Business name",
                        "type": "string",
                        "description": "The business you want to track, exactly as it appears on Google Maps. Example: Loyal Coffee"
                    },
                    "keywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "What customers type into Google Maps to find a business like this. Add one per line. Up to 10.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "City or area",
                        "type": "string",
                        "description": "City, state, or neighborhood to find the business and set the search area. Example: Colorado Springs, CO"
                    },
                    "gridSize": {
                        "title": "Grid size",
                        "minimum": 3,
                        "maximum": 13,
                        "type": "integer",
                        "description": "The scan uses a grid of this many rows by columns. 5 means a 5 x 5 grid of 25 points. Bigger grids cost more.",
                        "default": 5
                    },
                    "radiusMiles": {
                        "title": "Scan radius (miles)",
                        "minimum": 0.25,
                        "maximum": 25,
                        "type": "number",
                        "description": "How far out from the business to scan, in miles. 2 covers a typical town. Use a bigger number for a whole metro.",
                        "default": 2
                    },
                    "centerLat": {
                        "title": "Center latitude (advanced)",
                        "type": "number",
                        "description": "Only for power users. If you set both latitude and longitude, the actor skips the automatic business lookup and centers the grid here."
                    },
                    "centerLng": {
                        "title": "Center longitude (advanced)",
                        "type": "number",
                        "description": "Only for power users. Set together with center latitude to skip the automatic business lookup and center the grid here."
                    },
                    "zoom": {
                        "title": "Map zoom",
                        "minimum": 8,
                        "maximum": 18,
                        "type": "integer",
                        "description": "Google Maps zoom level for each search.",
                        "default": 13
                    },
                    "maxRank": {
                        "title": "Max rank to record",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Positions past this are recorded as not ranked.",
                        "default": 20
                    },
                    "placeId": {
                        "title": "Google place ID (advanced)",
                        "type": "string",
                        "description": "Optional exact-match hint. Usually left blank because the actor detects it automatically."
                    },
                    "proxyConfiguration": {
                        "title": "Proxy",
                        "type": "object",
                        "description": "Proxy used for Google Maps requests. Residential US proxy is the default and recommended setting.",
                        "default": {
                            "useApifyProxy": true,
                            "apifyProxyGroups": [
                                "RESIDENTIAL"
                            ],
                            "apifyProxyCountry": "US"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
