Connect Judge.me to ChatGPT: Manage Reviews and Customer Responses

If you want to connect Judge.me to ChatGPT so your AI agents can read customer reviews, draft public replies, audit widget settings, and manage GDPR requests, you need a Model Context Protocol (MCP) server. This server acts as the translation layer, converting ChatGPT's natural language tool calls into structured, authenticated Judge.me API requests.

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

Giving a Large Language Model (LLM) read and write access to a product review platform is a serious engineering challenge. You must handle complex payload schemas, enforce strict visibility controls on reviews, and parse mixed-format responses (JSON vs. raw HTML). You can either spend weeks building and maintaining custom integration code, or you can use a managed infrastructure layer to generate an authenticated MCP endpoint dynamically.

This guide breaks down exactly how to use Truto to generate a secure, authenticated MCP server for Judge.me, connect it natively to ChatGPT, and execute complex review moderation 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 Judge.me API

Building a custom MCP server means owning the lifecycle of every endpoint your LLM needs to call. While the MCP standard provides a predictable interface for tool discovery, implementing it against Judge.me's specific API surface introduces several strict constraints.

If you decide to self-host this integration, here are the primary challenges you will face:

Immutability of Review Content

Unlike a CRM or CMS where records are fully editable, Judge.me enforces strict authenticity rules on review data. You cannot update the title, body, or rating of an existing review via the API. The endpoint to update a review only allows you to toggle its visibility (publishing or hiding it) via the hidden boolean. If your LLM attempts to rewrite a customer's review to fix a typo, the request will fail. Your MCP server must explicitly guide the model through parameter descriptions to prevent hallucinations about modifying review text.

Mixed Response Formats and Undocumented Schemas

Judge.me's API surface blends standard REST conventions with frontend-specific endpoints. Operations like querying widget settings or preview badges often return undocumented JSON structures or raw HTML payloads consisting of <script> and <style> tags intended for direct browser injection. Building static MCP schemas for these endpoints means writing a dynamic parser to handle responses that do not fit a clean relational model.

Rate Limits and Header Normalization

Judge.me enforces rate limits to protect its infrastructure. When building an integration, you must handle these HTTP 429 Too Many Requests responses accurately. Truto does not automatically retry, throttle, or apply exponential backoff on rate limit errors. Instead, when the upstream Judge.me API returns a 429, Truto passes that error directly to the caller (ChatGPT) and normalizes the rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - or the agent orchestration framework - is entirely responsible for reading these headers and executing retry logic.

Step 1: Create the Judge.me MCP Server

Truto dynamically generates MCP tools based on the resources and documentation available for an integration. Each server is scoped to a single integrated account and secured via a cryptographic token URL.

You can generate this server via the Truto UI or programmatically via the API.

Option A: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server URL directly from your dashboard:

1. Log into your Truto account and navigate to Integrated Accounts.
2. Click on your active Judge.me connection to open the account details page.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. In the configuration modal, specify a name (e.g., "Judge.me Review Manager"). Optionally, apply filters to restrict access. For example, check only the read method box if you want a read-only server, or type reviews into the tag filter.
6. Click Save. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4e5f6...). Treat this URL as a secret.

Option B: Via the Truto API

For teams automating infrastructure provisioning, you can generate the server programmatically. You need your $TRUTO_API_TOKEN and the $INTEGRATED_ACCOUNT_ID for the specific Judge.me connection.

Make a POST request to the /mcp endpoint:

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 Review Moderator",
    "config": {
      "methods": ["read", "write"],
      "tags": ["reviews", "webhooks"]
    }
  }'

The Truto API will validate that tools exist for this configuration and return the secure token URL:

{
  "id": "c83b1234-abcd-5678-efgh",
  "name": "ChatGPT Review Moderator",
  "config": {
    "methods": ["read", "write"],
    "tags": ["reviews", "webhooks"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Step 2: Connect the MCP Server to ChatGPT

Once you have the url from the previous step, you must register it with ChatGPT. ChatGPT will perform an MCP handshake, requesting the tools/list to understand what operations it can perform against Judge.me.

Option A: Via the ChatGPT UI (Custom Connectors)

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the server directly in the client:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to the enabled state (MCP support requires this flag).
3. Under the MCP servers or Custom connectors section, click to add a new server.
4. Enter a descriptive name, such as "Judge.me (Truto)".
5. Paste the Truto MCP URL into the Server URL field.
6. Click Save. ChatGPT will immediately connect to the server and populate the available tools.

Option B: Via Manual Config File (SSE Transport)

If you are running local agents or using desktop clients that rely on JSON configuration files for MCP (such as Cursor or Claude Desktop, which share the same file-based config pattern), you can use the @modelcontextprotocol/server-sse wrapper to connect to Truto's remote endpoint via Server-Sent Events.

Add the following entry to your MCP config file:

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

Upon startup, the client executes the npx command, which establishes a persistent connection to the Truto MCP URL and streams JSON-RPC tool calls.

Security and Access Control

Giving an AI agent access to a production review platform carries inherent risk. Truto provides several mechanisms to lock down what the MCP server can execute:

• Method Filtering: By defining config.methods: ["read"], the server drops all create, update, and delete operations during the dynamic tool generation phase. The LLM simply will not see write tools in its capabilities list.
• Tag Filtering: By passing config.tags: ["webhooks"], the server only exposes endpoints specifically tagged for webhook management, hiding core review moderation tools.
• Extra Authentication: Setting require_api_token_auth: true means possession of the tokenized URL is not enough. The client must also pass a valid Truto API token in the Authorization header to execute a tool.
• Ephemeral Servers: By supplying an expires_at ISO datetime during creation, the server is automatically destroyed by a scheduled infrastructure alarm at the specified time, cleaning up all cryptographic keys and storage entries.

Judge.me Hero Tools for ChatGPT

Truto automatically translates Judge.me endpoints into heavily typed, documented MCP tools. Below are the highest-leverage tools your AI agent can use to orchestrate review management workflows.

1. list_all_judge_me_reviews

This tool fetches an array of product and store reviews. It returns comprehensive metadata including id, title, body, rating, reviewer info, and whether the review is currently hidden or published. This is the primary operation for auditing customer sentiment.

"Fetch the last 10 reviews for our store. Summarize the main complaints from any reviews with a 3-star rating or lower."

2. create_a_judge_me_reply

Allows the AI agent to draft and publish a public reply to a specific review. The reply will be displayed on the public review widget. It requires the review_id and a JSON body matching the Judge.me RequestCreateReply schema.

"Draft a polite, empathetic public reply to review ID 49102 acknowledging their shipping delay, and post it to Judge.me."

3. update_a_judge_me_review_by_id

This tool toggles the visibility of a review. Because Judge.me enforces strict authenticity rules, you cannot alter the text of a review via the API. You can only use this tool to publish a hidden review or hide an inappropriate published review.

"Review ID 88310 contains profanity. Hide this review immediately."

4. get_single_judge_me_reviewer_by_id

Fetches detailed information about a specific reviewer, such as their name and email address. This is critical when you need to trigger an automated flow for customer success agents to follow up directly via email.

"Get the email address for the reviewer with ID 9921, so I can pass it to our ticketing system for a manual follow-up."

5. create_a_judge_me_reviewers_data_request

Submits a GDPR-style data request for a specific reviewer in Judge.me. It asks the system to package up all data held about a customer and the orders related to them.

"A user with the email 'jane.doe@example.com' requested a GDPR data export. Submit a data request to Judge.me for this customer."

6. list_all_judge_me_webhooks

Retrieves all active webhooks registered for the shop. This is useful for auditing event subscriptions to ensure your downstream analytics or moderation pipelines are correctly receiving review updates.

"List all active webhooks in Judge.me and tell me if there are any subscriptions listening for the 'review_created' event."

For the full list of available tools, query schemas, and response shapes, check out the Judge.me integration page.

Workflows in Action

Once connected, ChatGPT can sequence these tools together to execute complex moderation and compliance workflows autonomously.

Workflow 1: Autonomous Review Moderation and Reply Drafting

Customer support teams spend hours reading product reviews and drafting boilerplate responses. You can instruct ChatGPT to automate the triage and response phase entirely.

"Check Judge.me for the latest negative product reviews. For any review under 3 stars, if it mentions 'shipping' or 'damaged', hide the review pending manual inspection and log the action. If it mentions a 'sizing issue', draft a polite public reply apologizing and explaining our return policy, then publish the reply."

How the agent executes this:

1. The agent calls list_all_judge_me_reviews and filters the response in memory for ratings less than 3.
2. It analyzes the body of the returned reviews using its natural language capabilities.
3. For a review mentioning a damaged box, it calls update_a_judge_me_review_by_id passing hidden: true.
4. For a review complaining about sizing, it calls create_a_judge_me_reply with the specific review_id and the generated apology text.

sequenceDiagram
    participant Agent as ChatGPT Agent
    participant Truto as Truto MCP
    participant Judge as "Judge.me API"
    
    Agent->>Truto: call list_all_judge_me_reviews
    Truto->>Judge: GET /api/v1/reviews
    Judge-->>Truto: Return review list
    Truto-->>Agent: JSON ToolResult
    
    opt If sizing issue
        Agent->>Truto: call create_a_judge_me_reply (review_id: 123)
        Truto->>Judge: POST /api/v1/reviews/reply
        Judge-->>Truto: 200 OK
        Truto-->>Agent: Success Result
    end
    
    opt If damaged goods
        Agent->>Truto: call update_a_judge_me_review_by_id (hidden: true)
        Truto->>Judge: POST /api/v1/reviews/124
        Judge-->>Truto: 200 OK
        Truto-->>Agent: Success Result
    end

Workflow 2: Automated GDPR Compliance Fulfillment

Handling Data Subject Access Requests (DSARs) is a tedious manual process that requires admins to log into multiple SaaS dashboards. ChatGPT can execute this via natural language.

"We received a right-to-be-forgotten request for customer email 'alex.smith@example.com'. Find their reviewer ID and submit a data request to process this."

How the agent executes this:

1. The agent cannot query directly by email via the review endpoint, so it must first determine how to locate the user. It might search reviews or call get_single_judge_me_reviewer_by_id if the ID is known through context.
2. Once the target is verified, the agent calls create_a_judge_me_reviewers_data_request passing the required customer email object.
3. Judge.me receives the payload and initiates the internal GDPR data compilation process.
4. The agent reports back to the user that the request was successfully initiated.

Moving Beyond Boilerplate Integrations

Writing custom integration code to handle Judge.me's strict authenticity rules and undocumented payload structures is a waste of engineering bandwidth. By utilizing Truto's dynamically generated MCP servers, you can connect ChatGPT to Judge.me in minutes, complete with enterprise-grade access controls and standardized rate limit handling.

Stop wrangling API docs and let your AI agents do the heavy lifting.