How to Use a Google Maps Scraper MCP Server ?

A Google Maps Scraper MCP server allows an AI agent to request current Google Maps business data while it works.
You can ask an agent to find businesses in a city, check their public reviews, or retrieve listing photos—saving you from manually copying each record into a spreadsheet.
For example:

The agent interprets the request, selects the appropriate MCP tool, sends the query, and returns the results in the format you requested.
This guide uses the remote Google Maps Scraper MCP server provided by G Maps Extractor. The main setup examples use Claude Code and Cursor, followed by shorter configurations for VS Code and Codex. For direct application integrations and JSON workflows, use the Google Maps Scraper API. Want an easier, no-code solution? Try the online Google Maps Scraper here.

Before You Configure the Server

You need a G Maps Extractor account and an API key.

The MCP endpoint is:

https://cloud.gmapsextractor.com/api/mcp

Authentication is sent through an HTTP header:

Authorization: Bearer YOUR_API_KEY

Replace YOUR_API_KEY with your actual key.
Be careful where you save it. Cursor and VS Code configurations often live inside a project folder, which means they can accidentally be committed to Git. Check your repository status before pushing the configuration anywhere public.
The server provides tools for business searches, public reviews, and Google Maps photo data.
A business search may return fields such as the listing name, address, phone number, website, category, rating, review count, coordinates, opening hours, and Google Maps URL. The exact fields depend on what is publicly available for each listing.
Missing values are normal. A business may not publish a website or phone number, and the agent should leave those fields empty rather than trying to infer them.

Connecting Claude Code

Claude Code is a convenient place to test the MCP server because the connection can be created directly from the terminal.
Run:

claude mcp add --transport http google-maps-scraper-mcp \
  https://cloud.gmapsextractor.com/api/mcp \
  --header "Authorization: Bearer YOUR_API_KEY"

Replace the placeholder with your API key, then open a new Claude Code session.
Before asking for business data, confirm that Claude can see the tools:
If the connection has loaded correctly, Claude should display tools related to Google Maps search, reviews, or photos.
A simple first request is enough to confirm that the complete path is working:
Look for an actual MCP tool call in the interface. A polished answer containing familiar coffee shops does not prove that the server was used; the model may have answered from its existing knowledge.
A screenshot showing the tool call and returned records would be useful in the published article here.

Connecting Cursor

Cursor reads project-level MCP settings from:
.cursor/mcp.json
Create the file and add:

{
  "mcpServers": {
    "google-maps-scraper-mcp": {
      "url": "https://cloud.gmapsextractor.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

The file should sit inside the project you currently have open:

your-project/
├── .cursor/
│   └── mcp.json
├── src/
└── package.json

Save it and reload Cursor.
If the server does not appear, inspect the JSON before changing anything else. A trailing comma is enough to prevent the configuration from loading:

{
  "headers": {
    "Authorization": "Bearer YOUR_API_KEY",
  }
}

That final comma is valid in some JavaScript contexts, but not in standard JSON.
It is also easy to create .cursor/mcp.json in one folder while Cursor has another folder open. In that situation, the file can be perfectly valid and still have no effect.
Once the server appears in Cursor’s MCP or tools panel, try a request that forces the agent to use current listing data:
The instruction about missing values is worth keeping. When an agent is later asked to clean or enrich results, it may otherwise fill gaps with plausible-looking information that did not come from Google Maps.
A screenshot of Cursor showing the connected server would fit well after this section.

Using It for an Actual Prospecting Task

Consider a local marketing agency looking for dental clinics that may need help improving their Google Maps presence.
Begin with a normal business search:
Review what comes back before asking the agent to do more.
A search for dentists may include orthodontists, cosmetic clinics, chains, and practices just outside the city boundary. That is not necessarily wrong. It simply means you should decide which results belong in the project before using another API request to analyze them.
You can then ask the agent to reduce the list:
At this stage, the result is still only a list of possible opportunities. A low review count does not prove that a clinic has a marketing problem.
Recent reviews can provide a more concrete reason to investigate:
This produces a more defensible result than asking the model to assign a vague “marketing opportunity score.”
If several customers mention unanswered calls or long appointment delays, the outreach angle is based on visible evidence. If no pattern appears, the report should say that rather than manufacture one.

Prompt Specificity Matters More Than Prompt Length

A request such as:
can technically work, but it leaves too much unresolved. Texas is large, the number of results is unknown, and the agent has no instruction about which data you need.
A more useful version would be:
This is not better because it is longer. It is better because the agent does not have to guess what counts as a valid result.
Avoid adding every possible filter to the first request. A search requiring a high rating, low review count, public phone number, website, email address, recent photos, and specific opening hours may return almost nothing.
It is usually easier to inspect a reasonable first batch and then filter the records already returned.

Getting Useful Review Analysis

Review prompts often produce bland summaries because the request itself is bland.
“Analyze these reviews” gives the agent freedom to write something that sounds reasonable without showing how it reached the conclusion.
Ask for evidence that can be checked:
This format makes it harder for the agent to overstate an isolated complaint.
The same principle applies when comparing competitors. An unexplained reputation score may look useful in a table, but it is difficult to audit. Repeated themes, review dates, rating changes, and response patterns are easier to verify.

Working With Google Maps Photos

Retrieving photo URLs and visually analyzing photos are not always the same operation.
A request such as:
keeps that distinction clear.
Some MCP clients may receive photo metadata without loading every image into the model’s visual context. In that case, the agent can report that photos exist but should not confidently judge whether they are attractive, recent, or professionally taken.
For a local SEO audit, even simple counts can still be useful. A listing with only two public photos may deserve attention when nearby competitors have dozens.

VS Code Setup

Create:
.vscode/mcp.json
Then add:

{
  "servers": {
    "google-maps-scraper-mcp": {
      "type": "http",
      "url": "https://cloud.gmapsextractor.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

Reload the VS Code window after saving.
Where the tools appear depends on the extension or AI agent you use. A valid configuration alone is not enough if that extension only supports local command-based MCP servers and not remote HTTP connections.

Codex Setup

Open:
~/.codex/config.toml
Add:

[mcp_servers.google-maps-scraper-mcp]
type = "http"
url = "https://cloud.gmapsextractor.com/api/mcp"

[mcp_servers.google-maps-scraper-mcp.headers]
Authorization = "Bearer YOUR_API_KEY"

Restart Codex after saving the file.
Do not paste the Cursor JSON block into this file. Codex uses TOML, so the section names, quotation rules, and assignment syntax are different.

Diagnosing a 401 Response

A 401 Unauthorized response means the server was reached, but it did not accept the credentials.
The expected header is:

Authorization: Bearer YOUR_API_KEY

These common variations will fail:

Authorization: YOUR_API_KEY

Authorization: BearerYOUR_API_KEY

Authentication: Bearer YOUR_API_KEY

There must be a space after Bearer, and the header itself must be named Authorization.
Also check whether the API key was copied with surrounding quotation marks or spaces. A configuration may look correct while still sending an extra character at the beginning or end of the token.

When the Server Loads but the Agent Ignores It

An AI agent does not have to call every available tool.
If you ask for “good restaurants in New York,” it may answer from general knowledge because the prompt does not clearly require live listing data.
Name the server and request fields that normally require a current lookup:
In tools that display calls, confirm that a request was actually made before relying on the output.

Irrelevant or Incomplete Search Results

Broad searches are more likely to contain noise.
“Marketing agencies in California” may return general web-design studios, advertising firms, consultants, and agencies hundreds of miles apart.
A query such as “local SEO agencies in San Diego” gives the search a clearer boundary. You can also state what does not belong:
Large geographic requests create a different problem. A single search for restaurants across Los Angeles should not be treated as a complete market list.
For better coverage, divide the search by neighborhood or ZIP code, combine the results afterward, and remove duplicates using a stable place identifier where available.

Missing Fields Are Part of the Data

An empty website or phone field does not automatically mean the scraper failed.
Some listings simply do not publish that information. The same applies to opening hours, reviews, and photos.
Preserve missing values as null or blank cells. Guessing a domain from the company name can contaminate the dataset with a website belonging to a different business.
This matters even more in automated workflows. One invented value can later be treated as verified data by a CRM import, enrichment process, or outreach tool.

Google Maps Scraper MCP and Google’s Maps MCP Are Different Tools

Google’s Maps Code Assist MCP is designed to help coding agents access current Google Maps Platform documentation, policies, tutorials, and code examples.
It is useful when you are building an application with Google Maps Platform APIs.
A Google Maps Scraper MCP server serves a different purpose. It provides business listing data for tasks such as prospect research, listing comparisons, review analysis, and photo collection.
The similar names can be confusing, but the intended workflows are not the same.

Start Small Before Running a Large Job

A five-record request reveals more than a long setup checklist.
It shows whether the category was interpreted correctly, whether the location boundary makes sense, which fields tend to be missing, and whether the output is suitable for the next part of your workflow.
Once that small request works, increase the result count or divide the search into geographic batches.
For recurring jobs involving hundreds or thousands of records, the underlying scraper API or cloud extraction interface will usually be easier to monitor than a long chat session. MCP is most useful when an agent needs to decide what to search, inspect the returned data, and use the result as part of a wider task.