Connect Google Reviews to Claude: Automate Feedback and Listings

If your team needs to connect Google Reviews to Claude to automate feedback analysis, orchestrate local SEO strategies, or provision new business listings, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and the Google Business Profile APIs. You can either build and maintain this infrastructure yourself, or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on connecting Google Reviews to ChatGPT or explore our broader architectural overview on connecting Google Reviews to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling ecosystem like Google Business Profiles is an engineering challenge. You have to handle strict OAuth 2.0 lifecycles, map massive JSON schemas to MCP tool definitions, and deal with Google's rigid location hierarchies. Every time Google updates a field mask or deprecates an endpoint, you have to update your server code, redeploy, and test the integration.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Google Reviews, connect it natively to Claude, and execute complex listing management workflows using natural language.

The Engineering Reality of the Google Reviews API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, the reality of implementing it against Google's enterprise APIs is painful. You are not just hitting a single /reviews endpoint - you are navigating an interconnected graph of accounts, locations, and localized business data.

If you decide to build a custom Google Reviews MCP server, here are the specific integration challenges you will face:

Account and Location Hierarchies Google Business Profile does not allow you to query reviews globally across a brand. Every operation is strictly scoped. To fetch a review, you first need the account_id representing the business entity, then the location_id representing the specific storefront or service area. Your MCP tools must enforce this sequence, otherwise Claude will hallucinate location IDs and fail. A managed MCP server forces the model to fetch accounts, list locations, and then target reviews - enforcing the correct state machine.

Strict Field Masks for Reads and Updates Google heavily utilizes read_mask and update_mask parameters to save bandwidth and prevent accidental overwrites. If you want to update a location's regular hours, you cannot simply PUT the entire location object. You must pass an update_mask explicitly naming the fields being modified. Translating LLM intent into exact, comma-separated field mask strings requires precise tool schema descriptions.

Verification Gates for Write Operations The Google Reviews API enforces strict state validation. You cannot use the google_reviews_reviews_create_reply endpoint if the target location is not verified. If an LLM attempts to reply to a review for an unverified location, the API will reject the request. Your agent workflows must be designed to either check verificationState first or gracefully handle the specific 400-level HTTP exceptions Google throws.

Rate Limits and Standardized Headers Google strictly rate-limits API requests based on project quotas. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Google API returns an HTTP 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller (or the Claude client) is strictly responsible for implementing retry and backoff logic using these normalized headers.

Generating the Google Reviews MCP Server

Truto creates MCP servers dynamically based on API documentation and integration configurations. When you connect a Google account, Truto's MCP Router maps the underlying proxy APIs into JSON-RPC 2.0 endpoints.

There are two ways to generate an MCP server in Truto: via the UI or programmatically via the REST API.

Method 1: Via the Truto UI

If you are setting this up for a single workspace or internal testing, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected Google Reviews account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., restrict methods to read only, or set an expiration date).
6. Copy the generated MCP server URL. It will look like https://api.truto.one/mcp/a1b2c3d4....

Method 2: Via the Truto API

For production use cases where you need to provision MCP servers dynamically for your own customers, you can use Truto's REST API.

Make a POST request to /integrated-account/:id/mcp with your desired configuration:

curl -X POST https://api.truto.one/admin/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "CX Team Claude Server",
    "config": {
      "methods": ["read", "write"]
    }
  }'

The API responds with a secure, hashed token URL. This URL contains the cryptographic token that encodes the integrated account and the tool filters. No additional authentication is required by default when passing this URL to an MCP client.

Connecting the MCP Server to Claude

Once you have the MCP server URL, you need to register it with your Claude client. You can do this visually through the Claude UI or via a configuration file for Claude Desktop.

Method 1: Via the Claude UI

If you are using the Claude web interface or enterprise admin panel:

1. Navigate to Settings -> Integrations -> Add MCP Server.
2. Paste the Truto MCP URL into the connection string field.
3. Click Add.
4. Claude will immediately send an initialize JSON-RPC handshake to the Truto server to fetch the available Google Reviews capabilities.

Method 2: Via Manual Configuration File

If you are running Claude Desktop locally or orchestrating headless agents, you can inject the MCP server using the claude_desktop_config.json file.

Because the Truto MCP URL is an HTTP endpoint (using Server-Sent Events), you configure it using the official @modelcontextprotocol/server-sse package as the command.

{
  "mcpServers": {
    "google-reviews-truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "https://api.truto.one/mcp/YOUR_TRUTO_TOKEN_HERE"
      ]
    }
  }
}

Restart Claude Desktop. The client will automatically connect, and the model will have immediate access to the Google Business Profile infrastructure.

Google Reviews Hero Tools

When Claude lists the tools available on the Truto MCP server, it processes dynamically generated JSON schemas. Truto utilizes a flat input namespace, meaning the LLM passes a single arguments object, and Truto automatically routes parameters to the query string or JSON body based on the API requirements.

Here are the highest-leverage hero tools for Google Reviews automation.

list_all_google_reviews_accounts

Before you can do anything with locations or reviews, you must discover the accounts the authenticated user has access to. This tool returns the account_id required by almost all subsequent operations.

Contextual usage notes: The numeric part of the returned name field (e.g., accounts/12345) is the account_id. The LLM uses this to traverse the hierarchy.

"Find the primary organization account ID for my Google Business Profile so we can look up its associated locations."

list_all_google_reviews_locations

Lists all business locations under a specific account. This provides metadata like store codes, categories, latitude/longitude, and verification state.

Contextual usage notes: You must pass the account_id. Use the optional read_mask parameter if you only need specific fields (e.g., name,title,storeCode) to save token context limits when querying dozens of locations.

"List all verified retail locations under account ID 10293847, returning only their titles and store codes."

google_reviews_reviews_bulk_get

Batch retrieves reviews across up to 50 verified locations in a single API call. This is vastly more efficient than paginating through individual location review endpoints when analyzing brand sentiment.

Contextual usage notes: Requires the account_id and an array of locationNames. Returns the full review object including star rating, text, media, and any existing replies.

"Pull the latest reviews for our locations in Chicago, Austin, and Seattle simultaneously to check for recent 1-star feedback."

google_reviews_reviews_create_reply

Creates or updates the owner's response to a specific customer review. If a reply already exists, this operation overwrites it.

Contextual usage notes: Requires account_id, location_id, review_id, and the actual comment text. The location must be verified for this request to succeed.

"Draft and publish a polite, empathetic apology to review ID xyz-987 for the Austin location, addressing their concern about the wait time."

list_all_google_reviews_reviews

Retrieves paginated reviews for a single specified location.

Contextual usage notes: Returns a maximum of 50 reviews per page. Truto automatically injects limit and next_cursor schema properties, explicitly instructing the LLM to pass the exact cursor back unchanged to fetch subsequent pages.

"Fetch the first 50 reviews for the Seattle location so I can summarize the overall customer sentiment this month."

For a complete list of all available operations, detailed JSON schemas, and required parameters, view the full inventory on the Google Reviews integration page.

Workflows in Action

Integrating the Google Reviews MCP server into Claude transforms conversational AI into a programmatic local SEO engine. Here is how specific personas use these capabilities in production.

Scenario 1: Automated Brand Sentiment and Response Triage

Persona: CX Manager managing dozens of retail locations.

"Audit all of our locations. Find any 1 or 2-star reviews from the past week that haven't been replied to, draft a context-aware apology, and publish the replies."

Execution Steps:

1. Claude calls list_all_google_reviews_accounts to discover the root organization ID.
2. It calls list_all_google_reviews_locations using the account ID to get a list of active storefronts.
3. Instead of looping slowly, Claude optimizes by calling google_reviews_reviews_bulk_get, passing batches of location names to fetch recent reviews in bulk.
4. Claude analyzes the results locally, identifying low-rating reviews where the reviewReply object is missing.
5. For each flagged review, it drafts a response and calls google_reviews_reviews_create_reply to publish the apology directly to Google.

sequenceDiagram
    participant CX as CX Manager
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant API as Google Reviews API

    CX->>Claude: "Audit recent negative reviews and reply..."
    Claude->>MCP: Call list_all_google_reviews_accounts
    MCP->>API: GET /v1/accounts
    API-->>MCP: Returns Account ID
    MCP-->>Claude: Account ID
    
    Claude->>MCP: Call list_all_google_reviews_locations
    MCP->>API: GET /v1/accounts/{id}/locations
    API-->>MCP: Returns Location list
    MCP-->>Claude: Location list
    
    Claude->>MCP: Call google_reviews_reviews_bulk_get
    MCP->>API: POST /v1/accounts/{id}/locations:batchGetReviews
    API-->>MCP: Returns bulk reviews
    MCP-->>Claude: Bulk reviews data
    
    note over Claude: Analyzes missing replies<br>and drafts responses
    
    Claude->>MCP: Call google_reviews_reviews_create_reply (xN)
    MCP->>API: PUT /v1/accounts/{id}/locations/{id}/reviews/{id}/reply
    API-->>MCP: HTTP 200 OK
    MCP-->>Claude: Reply confirmed
    Claude-->>CX: "All negative reviews have been addressed."

Scenario 2: Provisioning New Franchise Locations

Persona: Operations Administrator scaling physical storefronts.

"We just opened a new franchise in Denver. Create the new Google Business Profile location using the primary account, set the category to 'Coffee Shop', and apply our standard store hours."

Execution Steps:

1. Claude calls list_all_google_reviews_accounts to fetch the root entity ID.
2. It calls create_a_google_reviews_location, providing the account ID, the required title ("Denver Branch"), the primaryCategory ("Coffee Shop"), and the storefrontAddress in the JSON body.
3. Claude parses the returned location object and provides the operations team with the new location ID and verification state.

Security and Access Control

When connecting AI agents to public-facing company data like Google Reviews, strict boundary controls are necessary. Truto provides four critical security parameters at the MCP token level:

• Method Filtering (methods): Restrict an MCP server to read-only operations. Setting methods: ["read"] ensures the LLM can fetch reviews but cannot create replies or delete locations, protecting brand reputation.
• Tag Filtering (tags): Group tools logically. If your integration defines custom tags, you can restrict the MCP server to only expose tools tagged with reporting, excluding administrative endpoints.
• Expiration (expires_at): Set a strict time-to-live for the MCP server. When the token expires, Truto's Durable Objects automatically clean up the KV store, instantly revoking Claude's access.
• Secondary Authentication (require_api_token_auth): For shared environments, you can force the client to pass a valid Truto API token in the Authorization header alongside the MCP URL, ensuring only verified internal systems can execute tools.

The Advantage of Managed Infrastructure

Connecting Google Reviews to Claude requires more than just formatting a JSON-RPC response. You need an architecture that handles deep hierarchical routing, strict field masking, and complex error passthrough.

By leveraging Truto's managed MCP servers, you eliminate the need to write custom REST wrappers or monitor Google's endpoint deprecations. You configure your integration, dynamically generate the token, and let Claude seamlessly manage your local SEO and customer feedback loops at scale.