Connect Judge.me to Claude: Analyze Ratings and Customize Widgets

If you need to connect Judge.me to Claude to automate review moderation, analyze product ratings, reply to customer feedback, or configure storefront widgets, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Judge.me's REST API. 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 /connect-judge-me-to-chatgpt-manage-reviews-and-customer-responses/ or explore our broader architectural overview on /connect-judge-me-to-ai-agents-automate-webhooks-and-review-workflows/.

Giving a Large Language Model (LLM) read and write access to a product review ecosystem like Judge.me is an engineering challenge. You have to handle API token lifecycles, map Judge.me's fragmented JSON schemas to strict MCP tool definitions, and deal with complex entity relationships (like internal IDs versus external product handles). Every time an endpoint changes, 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 Judge.me, connect it natively to Claude Desktop, and execute complex review moderation workflows using natural language.

The Engineering Reality of the Judge.me API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable JSON-RPC 2.0 interface for models to discover tools, the reality of implementing it against specific e-commerce SaaS APIs is painful.

If you decide to build a custom Judge.me MCP server, here are the specific integration challenges you will face:

Asymmetrical Schema Documentation Many of Judge.me's endpoints - especially those dealing with widgets (e.g., list_all_judge_me_widgets_preview_badges) or review creation (e.g., create_a_judge_me_review) - do not clearly document their response bodies in the upstream spec. For an LLM to successfully execute a tool, it needs exact, deterministic JSON schemas for both the request and the response. Without them, Claude will hallucinate the expected data shape and fail the tool call. A managed MCP server dynamically resolves and injects these missing schema definitions based on actual proxy API responses.

Fragmented Identifier Spaces When dealing with reviews, an AI agent must navigate a complex identifier space. A single product might be referenced by its product_external_id (the ID in Shopify/BigCommerce), its product_handle (the URL slug), or its internal Judge.me product_id. If you just hand an LLM raw access to the API, it will frequently pass the wrong ID type to the wrong parameter. Managed MCP tools use strictly typed query schemas with enriched descriptions (e.g., "The internal Judge.me ID of the review, not the Shopify ID") to keep the LLM on track.

Rate Limits and 429 Handling Judge.me enforces strict rate limits to protect store performance. When an LLM executes a loop to analyze hundreds of reviews, it will inevitably hit a 429 Too Many Requests response. Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Judge.me API returns an HTTP 429, Truto passes that error directly back to the caller. However, Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - in this case, the script wrapping Claude - is responsible for reading these headers and executing the retry/backoff logic.

Generating the Judge.me MCP Server

To bridge Claude and Judge.me, you need an MCP server URL. Truto generates this dynamically based on the API documentation and resources available for the specific Judge.me tenant account.

There are two ways to generate this server URL: via the Truto UI for manual configuration, or via the API for programmatic agent deployments.

Method 1: Via the Truto UI

If you are manually setting up an agent in Claude Desktop, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in the Truto dashboard.
2. Select the connected Judge.me account you want to grant Claude access to.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (e.g., limiting the server to read operations or specific tool tags).
6. Copy the generated MCP server URL (it will look like https://api.truto.one/mcp/a1b2c3d4e5f6...).

Method 2: Via the REST API

For production deployments where you spin up multi-tenant AI agents programmatically, use the API. This issues a POST request to create an MCP token backed by a distributed key-value store, returning a ready-to-use endpoint.

const response = await fetch('https://api.truto.one/integrated-account/<JUDGE_ME_ACCOUNT_ID>/mcp', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${TRUTO_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Judge.me Review Analyzer",
    config: {
      methods: ["read", "write"], // Optional: filter to specific operation types
      tags: ["reviews", "widgets"] // Optional: filter by business domain
    }
  })
});
 
const { url } = await response.json();
console.log("MCP Server URL:", url);

This URL is fully self-contained. It contains a cryptographic token that securely maps to the integrated Judge.me account.

Connecting the MCP Server to Claude

Once you have the MCP URL, connecting it to Claude is a matter of configuration. Again, there are two approaches depending on your environment.

Method A: Via the Claude UI (or ChatGPT)

If you are using Claude Desktop or ChatGPT's custom connectors, you can add the URL directly in the settings.

1. In Claude Desktop, go to Settings -> Integrations -> Add MCP Server.
2. In ChatGPT, navigate to Settings -> Apps -> Advanced settings -> Developer mode -> Custom connectors.
3. Give the server a descriptive name (e.g., "Judge.me Production Store").
4. Paste the Truto MCP URL into the Server URL field.
5. Click Add or Save.

The framework will perform a JSON-RPC 2.0 handshake, call the tools/list protocol method, and instantly populate the LLM's context window with the available Judge.me tools.

Method B: Via the Configuration File

If you are running Claude Desktop and prefer file-based configuration (or are building a custom LangChain/LangGraph agent), you can add the server via claude_desktop_config.json using the SSE transport.

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

Restart Claude Desktop, and the Judge.me tools will be active.

Judge.me Hero Tools for Claude

Truto exposes the entirety of the Judge.me API as MCP tools. However, for AI-driven review moderation and store management, a specific subset of operations provides the highest leverage.

Here are the hero tools your agent will rely on:

list_all_judge_me_reviews

This is the core retrieval tool. It fetches reviews across the store. If a product_id is provided in the query schema, it filters to that specific product; otherwise, it returns all store and product reviews. The response schema maps fields like rating, body, reviewer, and hidden status.

"Fetch the last 50 reviews across the store and summarize the most common complaints mentioned in 1-star and 2-star ratings."

create_a_judge_me_reply

Allows the LLM to draft and publish a public reply to a specific review. The reply is displayed natively on the public review widget. The tool requires a review_id and a strictly formatted reply payload.

"Draft a polite, empathetic apology to the customer who left review ID 89123 about late shipping, and publish it as a public reply."

get_single_judge_me_reviewer_by_id

Fetches detailed information about a specific reviewer, including their name, email, and historical review data. This is critical for customer support agents who need context before resolving a negative review ticket.

"Look up reviewer ID 45192. What other reviews have they left on our store, and what is their average rating given?"

update_a_judge_me_review_by_id

While the API does not allow arbitrary editing of a customer's review text for authenticity reasons, this tool allows the LLM to toggle the visibility of a review (publish or hide).

"Hide review ID 99281, as it violates our community guidelines by containing profanity."

list_all_judge_me_widgets_settings

Returns the store's widget settings in HTML format (containing script and style tags). This carries customization values like text and colors. An agent can read this to audit if the widget matches current brand guidelines.

"Fetch the current Judge.me widget settings for the store. Are the primary star colors set to hex code #FFD700?"

create_a_judge_me_reviewers_data_request

An administrative tool for GDPR compliance. Submits a data request for a reviewer, asking for the data held about a customer and the orders it relates to. Requires a customer email.

"Submit a GDPR data request for the reviewer associated with the email customer@example.com."

To see the complete inventory of available Judge.me tools, including webhooks, metadata management, and product catalog syncs, view the Judge.me integration page.

Workflows in Action

Exposing individual endpoints as tools is step one. The real power of MCP comes from chaining these tools into multi-step workflows. Because the LLM receives a flat input namespace for query and body parameters, it can intuitively map outputs from one tool to inputs of the next.

1. Automated Triage of Negative Reviews

Persona: E-Commerce Customer Success Manager

"Find all 1-star and 2-star reviews left in the last 24 hours. For each negative review, draft a personalized public reply apologizing for their specific issue. Show me the drafted replies. If I approve, publish them all."

sequenceDiagram
    participant User as "User"
    participant Claude as "Claude (MCP Client)"
    participant MCP as "Judge.me MCP Server"

    User->>Claude: "Find negative reviews, draft replies..."
    Claude->>MCP: Call list_all_judge_me_reviews (rating <= 2)
    MCP-->>Claude: Return array of reviews (IDs, body, product_title)
    Claude->>User: Present drafted replies for review
    User->>Claude: "Approved, publish them."
    
    loop For each review
        Claude->>MCP: Call create_a_judge_me_reply (review_id, reply_text)
        MCP-->>Claude: Success 200
    end
    Claude->>User: Confirmation of published replies

What happens: Claude queries the reviews endpoint filtering by rating. It parses the natural language body of each review to contextually draft a reply. Once approved by the human in the loop, Claude executes a loop over create_a_judge_me_reply to finalize the workflow.

2. GDPR Data Request Fulfillment

Persona: Compliance & Operations Admin

"A customer with the email sarah.smith@example.com requested their data under GDPR. Find their reviewer ID and submit a formal data request via Judge.me."

flowchart TD
    A["User Prompt:<br>Process GDPR request for sarah.smith@example.com"] --> B["Claude executes:<br>list_all_judge_me_reviews<br>(search by email)"]
    B --> C{"Found reviewer?"}
    C -->|Yes| D["Extract reviewer_id"]
    D --> E["Claude executes:<br>create_a_judge_me_reviewers_data_request<br>(email: sarah.smith@example.com)"]
    E --> F["Return confirmation to user"]
    C -->|No| G["Alert user: No records found"]

What happens: Claude uses search logic to find the reviewer's profile, extracts the necessary identifiers, and executes the highly specific create_a_judge_me_reviewers_data_request tool, ensuring the company complies with data regulations without manual portal navigation.

3. Widget Style Auditing

Persona: Frontend Developer / Store Manager

"Check the current Judge.me widget settings on the production store. Extract the CSS styles and verify if the floating review tab is utilizing our brand's rounded border radius (8px)."

What happens:

1. Claude calls list_all_judge_me_widgets_settings.
2. The MCP server returns the raw HTML/CSS script injection blob.
3. Claude's LLM engine parses the CSS styles block within the response.
4. Claude reports back on the specific border-radius values applied to the .jdgm-floating-tab class, letting the developer know if a style update is required.

Security and Access Control

Handing an LLM write access to a live e-commerce store requires strict governance. Truto's MCP architecture provides four layers of security to restrict what Claude can do:

• Method Filtering: When generating the MCP server, use config.methods: ["read"] to entirely disable operations like create_a_judge_me_reply or judge_me_shops_bulk_delete. This ensures the agent is strictly read-only.
• Tag Filtering: Restrict tools by domain using config.tags: ["reviews"]. This prevents Claude from accessing administrative endpoints (like webhooks or shop settings) while still allowing review moderation.
• Time-to-Live (TTL): Set an expires_at ISO datetime when creating the MCP server. Truto uses scheduled alarms to automatically tear down the server and its distributed key-value entries when the time expires, perfect for temporary agent sessions.
• Enforced API Token Auth: Enable require_api_token_auth: true. This forces Claude (or your custom script) to pass a valid Truto API token in the Authorization header alongside the secure URL, ensuring the URL alone is not enough to execute tools.

Take Control of Your Review Workflows

Integrating Judge.me with Claude via an MCP server turns a static review platform into an autonomous customer success engine. Instead of manually triaging negative reviews, writing responses, and managing GDPR requests, you can interact with your store's reputation data using conversational logic.

By leveraging Truto's dynamically generated MCP tools, you sidestep the tedious work of reading Judge.me documentation, mapping JSON schemas, and managing OAuth tokens. Your agent gets instant, deterministic access to the exact endpoints it needs to get the job done.