Google Maps Remote MCP Server
Server Details
Google Maps places, reviews, contributor history, photos and posts as JSON. No Google Cloud.
- Status
- Healthy
- Uptime
- 77.0% over 62 days
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- Repository
- HasData/google-maps-mcp
- GitHub Stars
- 7
- Server Listing
- Google Maps MCP Server
TDQS
Scored across 6 tools
Each tool targets a distinct resource (search, place details, place reviews, contributor reviews, photos, posts), but two tools share the identical suffix 'getMapReviews' and could be momentarily confused—one fetches reviews for a place, the other by a contributor. The descriptions do clarify the distinction via contributorId vs placeId, so overlap risk is low but present.
Names follow a predictable hasdata_google_maps_<category>_<action> snake_case pattern that reads consistently across the set. The one flaw is that two tools literally end in 'getMapReviews', which is a mild collision rather than a convention break.
Six tools is well-scoped for a Google Maps data-extraction server, with each tool covering a distinct data type (search, place, reviews, contributor reviews, photos, posts). No filler tools and nothing obviously redundant.
The surface covers search, place details, reviews, contributor reviews, photos, and posts, which is solid coverage for POI intelligence. Minor gaps include no geocoding/autocomplete or directions/routing, though those are adjacent to the core listing-enrichment purpose.
Available Tools
6 toolshasdata_google_maps_contributor_reviews_getMapReviewsgoogle_maps_contributor_reviews: GET /ARead-onlyInspect
Get Map Contributor Reviews
Lists all Google Maps reviews authored by a specific Local Guide / contributor by contributorId, with language/country targeting and nextPageToken pagination. Returns per-review rating, text, date, place name, place address, photos, and owner responses. Use for reviewer reputation checks, detecting fake/bot review patterns, local-guide activity analysis, and building review-author profiles for trust scoring.
| Name | Required | Description | Default |
|---|---|---|---|
| gl | No | The two-letter country code for the country you want to limit the search to. Provide one exact documented value (245 allowed), e.g. `ac`, `af`. | |
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| num | No | Number of results per page, ranging from 10 to 200. | |
| contributorId | Yes | Google Maps Contributor ID. | |
| nextPageToken | No | Defines the next page token. It is used for retrieving the next page results. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true, and destructiveHint=false, so the safety profile is covered. The description adds the pagination model (nextPageToken) and the per-review return shape (rating, text, date, place name/address, photos, owner responses), which is useful behavioral context beyond the annotations.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three sentences, front-loaded with the core purpose followed by return shape and use cases. Every sentence earns its place, though the return-field list is fairly dense.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
No output schema exists, but the description enumerates the returned per-review fields, compensating well. Combined with annotations covering the safety profile and the 100%-covered schema, an agent has enough to call this correctly; minor gaps remain around pagination termination behavior.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the parameters are already fully documented in the schema (gl, hl, num, contributorId, nextPageToken). The description restates language/country targeting and pagination in prose but adds no syntax or constraint detail beyond the schema, so the baseline 3 is correct.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource: lists Google Maps reviews authored by a specific Local Guide/contributor, keyed on contributorId. This clearly distinguishes it from the sibling hasdata_google_maps_reviews_getMapReviews, which returns reviews for a place rather than a contributor.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Provides explicit usage contexts (reviewer reputation checks, fake/bot detection, local-guide activity analysis, trust scoring). It gives clear when-to-use guidance but no explicit when-not or named alternative sibling to route against, so it stops short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
hasdata_google_maps_photos_getMapPhotosgoogle_maps_photos: GET /ARead-onlyInspect
Get Place Photos
Fetches the photo gallery of a Google Maps place by dataId or placeId, paginated with nextPageToken and filterable by categoryId. Returns each photo with image URL and thumbnail. Use for restaurant-menu extraction, venue/ambience visual audits, building rich place detail pages, and sourcing up-to-date imagery for POI listings.
| Name | Required | Description | Default |
|---|---|---|---|
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| dataId | No | Google Maps data ID. Either dataId or placeId should be set. | |
| placeId | No | Unique reference to a place on Google Maps. Either dataId or placeId should be set. | |
| categoryId | No | Filters photos by category. | |
| nextPageToken | No | Token for fetching the next page of photos. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description adds genuine behavioral context beyond that: the result set is paginated via nextPageToken, filterable by categoryId, and each item carries an image URL plus thumbnail. Auth requirements and rate limits remain undisclosed, keeping it short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action, then mechanism, then use cases, in three tight sentences. The leading 'Get Place Photos' largely restates the title and is mildly redundant, but nothing else is wasted.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by stating what each returned photo contains, and it explains pagination and filtering. All parameters are optional and the mutual dataId/placeId requirement is handled by the schema, so little is missing; only error/edge behavior is absent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the baseline is 3. The description usefully ties categoryId to filtering and nextPageToken to pagination, but adds no format or syntax detail beyond the schema's own parameter descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (fetches) and resource (the photo gallery of a Google Maps place) plus the keying identifiers, so it is instantly distinguishable from siblings like getPlaceDetails, getMapReviews, and getMapPosts. An agent can tell what it returns (photos with image URL and thumbnail) without opening the schema.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete application scenarios (restaurant-menu extraction, venue/ambience audits, place detail pages, POI imagery sourcing) that make the intended use clear. However, it names no alternatives or exclusions, so an agent must infer when to prefer this over getPlaceDetails or getMapPosts rather than being routed explicitly.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
hasdata_google_maps_place_getPlaceDetailsgoogle_maps_place: GET /ARead-onlyInspect
Get Place Details
Fetches full Google Maps place data by placeId with optional domain/language localization. Returns name, address, coordinates, phone, website, categories, hours, rating, review count, price level, photos, attributes/amenities, and plus_code. With fetchWebResults, also returns the place panel's web results (the business's own site and its Instagram, Facebook, delivery and other listings) with title, link, displayed link and snippet. Use for local SEO audits, POI enrichment, lead generation, competitor mapping, and building location-aware agents.
| Name | Required | Description | Default |
|---|---|---|---|
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| domain | No | Google domain to use. Default is google.com. Provide one exact documented value (195 allowed), e.g. `google.ac`, `google.ad`. | |
| placeId | Yes | A unique identifier for the place. This ID can be obtained from Google Maps search results. | |
| fetchWebResults | No | Also collect the place panel's "Web results" section (the business's website and its pages on Instagram, Facebook, delivery services, etc.) and return it as `webResults`. This takes an extra request to Google and costs 5 credits on top of the base. Default is false. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true, openWorldHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuine behavioral context beyond that: the return payload composition and the fetchWebResults side effect ('extra request to Google and costs 5 credits on top of the base'), which an agent needs for cost-aware planning.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the core action, followed by return contents and the fetchWebResults caveat. The long enumeration of returned fields is informative rather than padded, though it could be trimmed slightly; overall it is efficient and well-ordered.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, and the description compensates by enumerating the returned fields in detail, including the webResults sub-shape, so an agent knows what comes back. Safety is covered by annotations; the only mild gap is that it does not state where placeId originates beyond the schema note.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so hl, domain, placeId and fetchWebResults are all documented in the schema itself. The description restates placeId-based lookup and localization and elaborates on what fetchWebResults yields, but adds no syntax or format detail beyond the schema, warranting the baseline 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource ('Fetches full Google Maps place data by placeId') and enumerates the returned fields, so the agent knows exactly what it retrieves. It does not explicitly contrast itself with the other *getPlaceDetails siblings (yelp, yellowpages, booking) or with performMapSearch, but the 'Google Maps place' scope is unambiguous from the name and text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It offers a list of use cases (local SEO audits, POI enrichment, lead generation, competitor mapping), which implies when it is useful, but gives no explicit when-to-use vs alternatives and no exclusions. It never says to obtain placeId from performMapSearch first or to route review queries to getMapReviews, leaving sibling selection to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
hasdata_google_maps_posts_getMapPostsgoogle_maps_posts: GET /ARead-onlyInspect
Get Map Posts
Fetches the latest Google Maps Posts (timeline-style updates such as offers, events, announcements, and notices) for a place by dataId or placeId, with language targeting. Returns per-post title, description, image, posted_at, link, and source/business name. Use for small-business intelligence, local-marketing monitoring, competitor activity tracking, and surfacing current promotions and events from local merchants.
| Name | Required | Description | Default |
|---|---|---|---|
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| dataId | No | Google Maps data ID. | |
| placeId | No | Unique reference to a place on a Google Map. Either dataId or placeId should be set. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so safety is covered. The description adds real value beyond that by disclosing the return shape (per-post title, description, image, posted_at, link, source/business name) in the absence of an output schema, and noting the dataId/placeId input flexibility, though it omits pagination or rate-limit behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with the core action and followed by the return fields and use cases. The use-case list is somewhat padded but each clause remains relevant; no significant waste.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description compensates by naming the per-post return fields, and it clarifies the input identifiers and language targeting. Complete enough for an agent to invoke it correctly, missing only finer operational details like limits or pagination.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so all three parameters (hl, dataId, placeId) are already documented in the schema, including the 'either dataId or placeId' rule. The description merely restates 'by dataId or placeId, with language targeting' and adds no syntax or format detail, matching the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb (Fetches) plus the resource (Google Maps Posts) and even enumerates the content type (offers, events, announcements, notices) fetched by dataId or placeId. It is clear enough to distinguish from most siblings, though it never explicitly contrasts itself with near-namesakes like google_maps_reviews or google_maps_place.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It gives intended scenarios ('small-business intelligence, local-marketing monitoring, competitor activity tracking'), which is genuine when-to-use guidance. However, it offers no exclusions and does not route the agent to an alternative (e.g., reviews tool for reviews), so the guidance remains implied rather than decisive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
hasdata_google_maps_reviews_getMapReviewsgoogle_maps_reviews: GET /ARead-onlyInspect
Get Map Reviews
Paginated fetch of Google Maps reviews for a place by dataId or placeId, with sort (mostRelevant, newestFirst, ratingHigh, ratingLow), topicId filter, and language. Returns per-review author name and profile link, star rating, text, published/relative date, likes count, owner response, attached photos, and local-guide flag. Use for reputation management, sentiment and topic mining, competitor review benchmarking, and feeding review data into summarization or trust-score LLMs.
| Name | Required | Description | Default |
|---|---|---|---|
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| dataId | No | Google Maps data ID. | |
| sortBy | No | Parameter used for sorting and refining results. | |
| placeId | No | Unique reference to a place on a Google Map. Either dataId or placeId should be set. | |
| topicId | No | Defines the ID of the topic you want to use for filtering reviews. | |
| nextPageToken | No | Defines the next page token. It is used for retrieving the next page results. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, non-destructive, and openWorld, so safety is covered. The description adds genuine behavioral context beyond that: it discloses pagination, the available sort modes, a topicId filter, and the per-review fields returned. It omits auth requirements and rate-limit behavior, keeping it short of a 5.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Front-loaded with the verb and scope, then structured into retrieval behavior, returned fields, and use cases. The trailing list of use cases is somewhat long but each clause carries a distinct application, so waste is limited.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description usefully enumerates the returned per-review fields (author, rating, text, dates, likes, owner response, photos, local-guide flag), which compensates for the missing output schema. The main gap is the absence of guidance on the dataId/placeId choice and pagination flow, but overall it is complete enough to invoke correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents every parameter, including the sort enum and the dataId/placeId duality. The description restates the sort values, topicId, and language but adds no format, precedence, or pagination-token guidance beyond what the schema provides, so baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource ('Paginated fetch of Google Maps reviews for a place by dataId or placeId') and names the scoping input keys. It implies a place-level scope that separates it from the contributor-reviews sibling, but never names that sibling or any other alternative explicitly, so differentiation relies on inference.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives clear usage contexts ('reputation management, sentiment and topic mining, competitor review benchmarking, feeding review data into summarization or trust-score LLMs'), which tells an agent when this tool fits. However it offers no when-not conditions and does not route to sibling tools like the contributor-reviews or place-details endpoints.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
hasdata_google_maps_search_performMapSearchgoogle_maps_search: GET /ARead-onlyInspect
Get Google Maps Search Results
Runs a Google Maps search by keyword plus optional GPS coordinates (@lat,lng,zoomz via ll) with language, country, domain, and offset-based pagination (start). Returns the local pack list with placeId, name, address, coordinates, rating, review count, price level, categories, phone, website, hours, and thumbnail. Use for local lead generation, competitor density mapping, market expansion research, hyperlocal directories, and feeding placeIds into the Maps Place, Reviews, or Photos endpoints.
| Name | Required | Description | Default |
|---|---|---|---|
| q | Yes | Search query term or phrase. | |
| gl | No | The two-letter country code for the country you want to limit the search to. Provide one exact documented value (245 allowed), e.g. `ac`, `af`. | |
| hl | No | The two-letter language code for the language you want to use for the search. Provide one exact documented value (159 allowed), e.g. `af`, `ak`. | |
| ll | No | GPS coordinates of the location where the search query is to be performed. This parameter is required if the 'start' parameter is present. The format for the `ll` parameter is `@` followed by latitude, longitude, and zoom level, separated by commas. The latitude and longitude should be in decimal degrees, and the zoom level is an integer. Example: `@40.7455096,-74.0083012,14z`. | |
| start | No | Specifies the result offset for pagination purposes. The offset dictates the number of rows to skip from the beginning of the results. This is useful for accessing subsequent pages of search results. For example, an offset of 0 (the default value) returns the first page of results, 20 returns the second page, 40 returns the third page, and so on. This parameter is especially relevant when used in conjunction with the 'll' parameter for location-based searches. | |
| domain | No | Google domain to use. Default is google.com. Provide one exact documented value (195 allowed), e.g. `google.ac`, `google.ad`. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds value by enumerating the exact result fields (placeId, rating, review count, price level, hours, etc.) and by noting that ll is required when start is present, though it says nothing about quotas, cost, or error behavior for what is an open-world scrape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences, front-loaded with what the tool does before the field list and use cases. The long middle list of return fields is dense but each item is informative rather than filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description correctly compensates by listing the returned fields, and it covers the required query plus the optional location, language, domain, and pagination controls. It is slightly thin on the ll/start interaction detail (only partially echoed from the schema) and on rate-limit or auth expectations, but an agent has enough to invoke it correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents q, gl, hl, ll, start, and domain in detail. The description only summarizes them ('language, country, domain, and offset-based pagination'), adding no format or constraint detail beyond the schema, which matches the baseline of 3.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb and resource (runs a Google Maps search by keyword plus optional coordinates) and enumerates the returned local-pack fields. It also distinguishes itself from the Maps Place, Reviews, and Photos siblings by naming them as downstream consumers of the placeIds it returns.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Gives concrete usage contexts (local lead generation, competitor density mapping, hyperlocal directories) and explains that placeIds feed the Maps Place/Reviews/Photos endpoints, which is genuine routing guidance. It never states when NOT to use this tool or how it compares to sibling search tools such as yelp_search or google_serp_serp, so it falls short of a 5.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
2 tool updates
- Changed
hasdata_google_maps_place_getPlaceDetails1 field changed- added
Input schema / properties / fetchWebResultsAdded value: +{ + "description": "Also collect the place panel's \"Web results\" section (the business's website and its pages on Instagram, Facebook, delivery services, etc.) and return it as `webResults`. This takes an extra request to Google and costs 5 credits on top of the base. Default is false.", + "type": "boolean" +}
- Changed
hasdata_google_maps_posts_getMapPosts1 field changed- removed
Input schema / properties / nextPageTokenRemoved value: -{ - "description": "Defines the next page token. It is used for retrieving the next page results.", - "type": "string" -}
6 tool updates
- First observed
hasdata_google_maps_contributor_reviews_getMapReviews - First observed
hasdata_google_maps_photos_getMapPhotos - First observed
hasdata_google_maps_place_getPlaceDetails - First observed
hasdata_google_maps_posts_getMapPosts - First observed
hasdata_google_maps_reviews_getMapReviews - First observed
hasdata_google_maps_search_performMapSearch
Publisher details
- Operator
- HasData · Publisher source
- Operator website
- https://hasdata.com · Publisher source
- Vendor relationship
- Independent · Publisher source
- Documentation
- https://docs.hasdata.com/mcp-server · Publisher source
- Trust center
- Not available
- Restrictions
- A free HasData account covers 1,000 credits a month with no card. Heavier use needs a paid plan. No admin approval, no regional limits and no custom OAuth app. · Publisher source
Related MCP Connectors
Scrape Google Maps business leads, reviews, and photos via hosted Remote MCP.
Live Google Maps business search, review, and photo data for AI agents over MCP.
Search Google Maps businesses via MCP - name, address, phone, rating, hours, GPS.
Google Maps places with emails, phones and the tech stack of their websites. Runs on Apify.
Related MCP Servers
- FlicenseNot gradedqualityBmaintenanceEnables fetching a Google Maps contributor's review history as structured JSON, including reviewer profile and place details, for reputation research, reviewer vetting, and fraud detection.-
- AlicenseAqualityBmaintenanceEnables AI assistants to search places, retrieve place details, reviews, photos, business posts, and contributor review histories from Google Maps through natural language, with no API keys or paid billing required.6MIT
- AlicenseNot gradedqualityBmaintenanceEnables AI clients to search Google Maps places and retrieve reviews, photos, scrape jobs, results, and exports through a hosted MCP API.MIT
- AlicenseAqualityBmaintenanceProvides AI agents with structured search results, place details, ratings, and contact info from Google Maps without requiring any API keys.2MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.