Connect Google Reviews to ChatGPT: Manage Locations and Replies

If you need to connect Google Reviews to ChatGPT to automate reputation management, analyze customer sentiment across dozens of storefronts, or dynamically draft and post owner replies, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and the Google Business Profile REST APIs.

If your team uses Claude, check out our guide on connecting Google Reviews to Claude or explore our broader architectural overview on connecting Google Reviews to AI Agents.

Giving a Large Language Model (LLM) access to a fragmented, highly hierarchical enterprise API like Google Business Profile is a massive engineering challenge. You must map Google's fully qualified resource names to flat JSON-RPC tool definitions, orchestrate multi-step queries (Accounts -> Locations -> Reviews), and handle strict API quotas. Every time you onboard a new franchise location, your custom integration code must dynamically discover it.

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

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

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, implementing it against the Google Business Profile (GBP) API is exceptionally painful.

If you decide to build a custom Google Reviews ChatGPT integration in-house, you own the entire API lifecycle. Here are the specific integration challenges you will encounter:

The Strict Resource Hierarchy

Unlike modern SaaS APIs that provide flat endpoints (e.g., GET /reviews?brand=acme), Google forces a strict relational hierarchy. Every operation requires traversing from the Account to the Location to the Resource. A review ID is not just a UUID; it is a fully qualified string path: accounts/{account_id}/locations/{location_id}/reviews/{review_id}.

If an LLM needs to query reviews, your custom MCP server must somehow know the target account_id and location_id. Building static MCP schemas for this means forcing the LLM to execute multi-step discovery chains (list accounts -> list locations -> list reviews) before it can actually analyze sentiment. If your server does not explicitly guide the LLM on this sequence, it will hallucinate missing path parameters.

flowchart TD
    A["Account<br>(accounts/123)"] -->|"Has many"| B["Location<br>(locations/456)"]
    B -->|"Has many"| C["Review<br>(reviews/789)"]
    C -->|"Has one"| D["Owner Reply"]

Bulk Fetching Limitations

Fetching reviews one location at a time is incredibly slow and burns through LLM context windows. Google provides a batchGetReviews endpoint that allows you to fetch reviews for up to 50 locations simultaneously, but the payload structure is entirely different from the single-location endpoint. Your MCP server must maintain separate JSON Schema definitions for single vs. bulk operations, and train the LLM on when to use which tool.

Handling Google API Rate Limits

Google Business Profile APIs enforce strict quotas per project and per user. When these quotas are exceeded, the API returns an HTTP 429 Too Many Requests error.

Factual note on rate limits: Truto does not retry, throttle, or apply automatic 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 (ChatGPT or your custom agent framework) is entirely responsible for implementing the retry and backoff logic. Do not assume your infrastructure layer will magically absorb 429s.

How to Create the Google Reviews MCP Server

Instead of building a custom Node.js or Python server to map Google's schemas to JSON-RPC, you can use Truto to dynamically generate an MCP server. Truto builds tool definitions dynamically from the integration's resource configurations and documentation schemas, ensuring that the AI tools always match the live API surface.

You can create the MCP server in two ways: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For ad-hoc tasks or internal ChatGPT testing, generating a server via the dashboard takes about 30 seconds.

1. Log into your Truto environment and navigate to the Integrated Accounts page.
2. Click on your connected Google Reviews account (ensure the OAuth connection is active).
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., name it "Google Reviews AI", restrict methods to "read" and "write").
6. Click Save and copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

For production workflows, you should generate MCP endpoints dynamically so you can programmatically inject them into your application's ChatGPT sessions or backend agents.

Make a POST request to /integrated-account/:id/mcp. You can filter the generated tools by methods (e.g., restricting the LLM to only read operations) or tags.

curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "ChatGPT Production Reviews MCP",
    "config": {
      "methods": ["read", "write"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The Truto API will respond with the server metadata and the critical url field:

{
  "id": "mcp_8a9b0c1d",
  "name": "ChatGPT Production Reviews MCP",
  "config": {
    "methods": ["read", "write"]
  },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/f8e7d6c5b4a3..."
}

This single URL encodes the routing, the account linkage, and the cryptographic authentication token. Treat it as a highly sensitive secret.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT. You can do this natively in the ChatGPT Desktop app, or via a standard manual configuration file for open-source clients.

Method A: Via the ChatGPT UI

If you have a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add custom connectors directly in the app.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the MCP servers / Custom connectors section, click Add new server.
4. Name: Enter a descriptive name (e.g., "Google Reviews API").
5. Server URL: Paste the Truto MCP URL (https://api.truto.one/mcp/...).
6. Click Save.

ChatGPT will perform a handshake (initialize and tools/list via JSON-RPC) and automatically ingest the Google Reviews API schemas.

Method B: Via Manual Config File (SSE Transport)

If you are running a custom multi-agent framework or testing via a CLI tool that uses standard MCP configuration files (similar to Claude Desktop's claude_desktop_config.json), you can connect via Server-Sent Events (SSE).

Create or update your configuration JSON file:

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

This instructs the MCP client to use the official SSE transport adapter to stream JSON-RPC messages to the Truto HTTP endpoint.

Google Reviews Hero Tools

When ChatGPT hits the Truto MCP server, it dynamically derives tool definitions from the integration's resources and documentation schemas. Instead of manually writing OpenAPI specs, you get fully typed tools immediately.

Here are 6 high-leverage hero tools your AI agents can use to manipulate Google Reviews data.

list_all_google_reviews_accounts

Because the Google API requires an account_id for almost every operation, your LLM must fetch this first. This tool lists all Google Business Profile accounts accessible to the authenticated user.

Usage Note: The numerical ID extracted from the name field in the response is the account_id required by downstream location and review tools.

"Fetch my Google Business Profile account details and tell me my primary account ID."

list_all_google_reviews_locations

This tool retrieves all business locations under a specific Google Business Profile account. It returns critical metadata including name (which contains the location_id), title, storefrontAddress, phoneNumbers, and regularHours.

Usage Note: Pass the account_id retrieved from the previous tool. Max 100 locations are returned per page.

"List all business locations under account ID 1093849. I need the location IDs and their corresponding street addresses."

list_all_google_reviews_reviews

Fetches paginated reviews for a specific location. It returns the reviewer's name, star rating, text comment, update timestamps, and any existing owner replies.

Usage Note: Required parameters are account_id and location_id. This is best used when you are auditing a single specific storefront.

"Get the 50 most recent reviews for the downtown Chicago location. Flag any reviews that have a 1-star or 2-star rating."

google_reviews_reviews_bulk_get

This is a massive optimization tool. It allows you to batch retrieve reviews across up to 50 verified locations in a single API request, drastically reducing the number of tool calls the LLM has to make.

Usage Note: You must pass the account_id and an array of locationNames.

"Perform a bulk fetch of all reviews across our 12 Texas locations. Give me a summary of the most common complaints mentioned over the last 30 days."

google_reviews_reviews_create_reply

This tool allows the LLM to write back to the API. It creates or updates the owner reply to a specific Google Business Profile review. If a reply already exists, it overwrites it.

Usage Note: Requires account_id, location_id, review_id, and the comment payload. Always use a human-in-the-loop approval step before allowing an agent to execute this tool in production.

"Draft a polite, professional reply to review ID abc-123 apologizing for the long wait time, and post it to the profile."

create_a_google_reviews_location

For ops and expansion teams, this tool automates storefront onboarding. It creates a new business location under a specific account, configuring the title, categories, and physical address.

Usage Note: Requires account_id, title, categories.primaryCategory, and a valid storefrontAddress or serviceArea.

"Create a new Google Business location for 'Acme Coffee Seattle' at 123 Pine St, category 'Coffee Shop'."

(Note: This is a curated list of high-impact tools. For the complete inventory, required parameters, and JSON schemas, view the Truto Google Reviews Integration Page.)

Workflows in Action

Connecting tools to ChatGPT is only valuable if you can execute multi-step logic. Because all tools share a flat input namespace managed by Truto's MCP router, ChatGPT can seamlessly chain responses from one tool into the parameters of the next.

Here are two concrete examples of how this looks in practice.

Scenario 1: Automated Reputation Management (Multi-Location)

A regional manager needs to audit all negative reviews from the past week across three locations and prepare contextual replies.

"Find all reviews from the last 7 days across our New York, Boston, and Philly locations. Filter for any reviews 3 stars or below. Draft a custom reply for each one addressing their specific complaint, but do NOT post them yet - just show me the drafts."

Execution flow:

1. list_all_google_reviews_accounts: ChatGPT gets the root account_id.
2. list_all_google_reviews_locations: ChatGPT maps "New York", "Boston", and "Philly" to their specific location_id strings.
3. google_reviews_reviews_bulk_get: Instead of making three separate calls, ChatGPT batches the three locations into a single bulk fetch request.
4. Data Processing: The LLM parses the returned JSON, filters by starRating <= 3, and generates the draft text locally in the chat window.

Scenario 2: Escalating and Replying to Support

A customer success team wants to automatically post follow-up replies to resolved issues.

"Look up the review from 'John Smith' at the Miami location. We just refunded his order. Post a reply saying 'Hi John, we have processed your refund. Thank you for your patience!'"

Execution flow:

1. list_all_google_reviews_locations: Identifies the Miami location_id.
2. list_all_google_reviews_reviews: Searches the Miami location for the reviewer name "John Smith" to extract the specific reviewId.
3. google_reviews_reviews_create_reply: Executes the POST request using the extracted account_id, location_id, reviewId, and the generated comment string. The user sees a confirmation that the reply is live.

sequenceDiagram
    participant User as ChatGPT
    participant TrutoServer as Truto MCP Server
    participant GoogleAPI as "Google Reviews API"

    User->>TrutoServer: Call list_all_google_reviews_reviews
    TrutoServer->>GoogleAPI: GET /v1/accounts/123/locations/456/reviews
    GoogleAPI-->>TrutoServer: Array of reviews
    TrutoServer-->>User: Returns Review ID '789'
    User->>TrutoServer: Call google_reviews_reviews_create_reply
    TrutoServer->>GoogleAPI: PUT /v1/accounts/123/.../reviews/789/reply
    GoogleAPI-->>TrutoServer: 200 OK
    TrutoServer-->>User: Success response

Security and Access Control

Exposing an enterprise Google Business Profile account to an LLM introduces significant risk. If you just pass an unfiltered OAuth token to a custom script, a hallucinating model could accidentally delete a location or post inappropriate replies.

Truto MCP servers mitigate this by allowing strict configurations at the token level:

• Method Filtering: Configure the MCP token with config: { methods: ["read"] }. Truto's generation logic will instantly strip create_a_google_reviews_location, google_reviews_reviews_create_reply, and all other write operations from the server. The LLM simply won't know those tools exist.
• Tag Filtering: Limit the server to specific resource tags. If you only want the LLM to access reviews and not location metadata, you can filter by tags: ["reviews"].
• Require API Token Auth: By setting require_api_token_auth: true, possession of the MCP URL is no longer enough to execute a tool. The client must also inject a valid Truto API token into the HTTP Authorization header, enforcing a secondary layer of enterprise authentication.
• Expiration Scheduling: Use the expires_at field to create temporary MCP servers. Once the timestamp is reached, the underlying Key-Value store and database records are completely wiped by a scheduled cleanup alarm. This is perfect for giving temporary agent access to a contractor or temporary workflow.

Rethinking Agentic Integration

Writing custom parsers to translate the Google Business Profile API into an LLM-friendly format is a waste of engineering bandwidth. The hierarchy is complex, the rate limits are punishing, and the bulk fetching logic requires constant maintenance.

By leveraging Truto's dynamically generated MCP servers, you eliminate the entire middle tier of integration code. Your application generates a secure, filtered URL; ChatGPT discovers the tools through standard JSON-RPC; and your developers can focus on building the actual agent logic rather than debugging 429 errors and undocumented Google schema changes.

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::