---
title: "Connect UserTesting to Claude: Track UX Metrics & Session Results"
slug: connect-usertesting-to-claude-track-ux-metrics-session-results
date: 2026-07-16
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: "Learn how to connect UserTesting to Claude using a managed MCP server. Execute UX workflows, analyze transcripts, and extract QX scores using AI agents."
tldr: "Connect UserTesting to Claude via a managed MCP server to automate UX research analysis. This guide covers MCP configuration, connection steps, and tool-calling workflows for WebVTT transcripts and QX scores."
canonical: https://truto.one/blog/connect-usertesting-to-claude-track-ux-metrics-session-results/
---

# Connect UserTesting to Claude: Track UX Metrics & Session Results


If your team uses ChatGPT, check out our guide on [connecting UserTesting to ChatGPT](https://truto.one/connect-usertesting-to-chatgpt-analyze-studies-and-ux-score-data/) or explore our broader architectural overview on [connecting UserTesting to AI Agents](https://truto.one/connect-usertesting-to-claude-process-session-media-and-transcripts/).

User research generates a massive volume of unstructured data. Between 60-minute recorded sessions, WebVTT transcripts, behavioral QX scores, and post-session Net Promoter Scores (NPS), UX researchers spend hours manually extracting insights. By connecting UserTesting directly to Claude, you can feed raw session data into a large context window and instantly extract themes, timestamped quotes, and usability bottlenecks.

To make this work securely, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). The MCP server translates Claude's natural language tool calls into standard REST API requests that UserTesting understands. 

You can spend weeks building a custom MCP server, managing OAuth flows, and writing JSON schemas for every UserTesting endpoint, or you can use a [managed platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). This guide explains exactly how to generate a secure, authenticated UserTesting MCP server with Truto and connect it to Claude to automate your UX research workflows.

## The Engineering Reality of the UserTesting API

Building a custom integration for UserTesting exposes you to several domain-specific API constraints. If you try to expose UserTesting directly to Claude without an abstraction layer, your AI agent will frequently fail.

Here are the specific engineering hurdles you face when integrating UserTesting:

**Complex Nested Data Models**
UserTesting endpoints do not return flat records. When you fetch a study, the API returns a deeply nested object containing `netPromoterScores` (broken down by detractor, passive, and promoter percentages), `testPlan` arrays, and `tasks` with positional data and scale settings. LLMs struggle to navigate deeply nested JSON to find the fields they need. Truto handles the schema parsing, mapping the UserTesting documentation directly into clean JSON Schema definitions that Claude can easily comprehend.

**WebVTT Transcript Formatting**
The UserTesting API returns session transcripts in WebVTT format (e.g., `00:00:00.000 --> 00:00:02.000` followed by spoken text). Retrieving this requires specific session IDs tied to specific product types (`LIVE_CONVERSATION` and `THINK_OUT_LOUD`). If an LLM calls the transcript endpoint for the wrong test type, it will receive a cryptic error. Truto's MCP tools explicitly define these constraints in the tool description, ensuring Claude only attempts to fetch transcripts for valid session types.

**Strict Rate Limiting and Backoff Requirements**
UserTesting enforces API rate limits, especially when pulling heavy data like session lists and transcripts in bulk. When an AI agent loops through 50 sessions to pull transcripts, it will hit an HTTP 429 error. Truto does not retry, throttle, or apply backoff on rate limit errors. Instead, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification and passes the 429 error directly to the caller. Your agent framework is responsible for implementing the retry and backoff logic using these standard headers.

## How to Generate a UserTesting MCP Server with Truto

Truto creates MCP servers dynamically based on your connected UserTesting account using an [auto-generated tool architecture](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/). Every endpoint defined in the UserTesting integration is evaluated against its documentation record. If a documentation record exists, Truto generates a standardized JSON-RPC 2.0 tool for it. 

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

### Method 1: Via the Truto UI

If you prefer a click-ops approach, you can generate an MCP URL directly from your dashboard:

1. Navigate to the **Integrated Accounts** page and select your connected UserTesting instance.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Select your configuration options (Name, allowed methods, allowed tags, and expiration).
5. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

If you are provisioning infrastructure dynamically for multiple tenants, use the Truto API. Make a POST request to `/integrated-account/:id/mcp` with your desired configuration.

```bash
curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "UserTesting UX Research MCP",
    "config": {
      "methods": ["read", "list", "get"]
    }
  }'
```

The API returns a database record and a unique, cryptographically hashed URL:

```json
{
  "id": "ut-mcp-892",
  "name": "UserTesting UX Research MCP",
  "config": { "methods": ["read", "list", "get"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

This URL is self-contained. It encodes the tenant account, the configuration filters, and the target API. 

## How to Connect the MCP Server to Claude

Once you have your Truto MCP URL, you can plug it into Claude. You can do this visually using the Claude Desktop application or manually using the configuration file.

### Method 1: Via the Claude UI

1. Open Claude Desktop.
2. Navigate to **Settings** -> **Integrations**.
3. Click **Add MCP Server** (or "Add custom connector" depending on your tier).
4. Paste your Truto MCP URL into the Server URL field.
5. Click **Add**. 

Claude will perform a JSON-RPC handshake (`initialize`) with Truto, fetch the tool capabilities (`tools/list`), and instantly make the UserTesting tools available in your chat interface.

### Method 2: Via Manual Configuration File

For advanced users, you can configure Claude Desktop manually by editing the `claude_desktop_config.json` file. Truto provides an SSE (Server-Sent Events) wrapper to handle the remote connection.

Open your config file and add the server configuration:

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

Save the file and restart Claude Desktop. The tools will load automatically.

## Hero Tools for UserTesting

Truto automatically translates UserTesting endpoints into well-documented MCP tools. Here are 6 high-leverage hero tools your AI agents can use to automate research analysis.

### list_all_user_testing_workspace_studies

Lists all studies available within a specific UserTesting workspace. This is typically the entry point for an agent to discover which tests have recently run. It returns the `uuid`, `title`, `productType`, and ordering metadata.

> "List all the recent studies in our core product workspace. Filter down to only the tests created in the last 7 days."

### get_single_user_testing_study_by_id

Fetches the complete, deeply nested metadata for a specific study. This tool is critical because it returns the `netPromoterScores` (detractor vs promoter percentages) and the exact `testPlan` (the specific tasks the user was asked to complete). 

> "Get the full study details for the 'Mobile Navigation Redesign' test. Show me the exact tasks the participants were asked to perform, and give me the overall Net Promoter Score breakdown."

### list_all_user_testing_session_transcripts

Retrieves the full video transcript for a specific UserTesting session in WebVTT format. Because Claude has a massive context window, you can feed it multiple transcripts at once. The WebVTT format includes timestamps, allowing Claude to cite exactly when a user encountered a specific issue.

> "Fetch the transcript for session ID 98234. Read through the text and extract any quotes where the user expressed frustration with the checkout process. Include the exact timestamps for each quote."

### list_all_user_testing_test_qx_scores

Retrieves the QXscore results for an interaction test. QX scores are a composite metric measuring behavioral and attitudinal success. This tool returns the `qxScore` along with sub-components like usability, trust, appearance, and loyalty.

> "Pull the QX scores for our recent onboarding test. Compare the usability score to the trust score, and tell me which area requires more immediate engineering attention."

### list_all_user_testing_session_video_download_urls

Generates a pre-signed, temporary URL to download the raw video file of a session. If your agent is building a summary report in a markdown file, it can embed or link to these URLs so stakeholders can watch the actual session.

> "Get the video download URL for the session where the user struggled with the password reset. I want to include the link in my final report."

### list_all_user_testing_session_clips

Lists the video clips and highlight reels that researchers have already generated for a session. Returns the `timeStartMs`, `timeEndMs`, and descriptions of the clipped moments.

> "List all the highlight clips associated with session ID 11223. Summarize the descriptions of these clips so I can understand the key takeaways without watching the full video."

For the complete list of UserTesting tools, schemas, and required parameters, visit the [UserTesting integration page](https://truto.one/integrations/detail/usertesting).

## Workflows in Action

Exposing individual tools to Claude is useful, but the real power comes from chaining these operations together to automate multi-step research synthesis.

### Workflow 1: UX Research Synthesis and Quote Extraction

Instead of watching hours of video and manually typing out quotes, an AI agent can synthesize the data and build a categorized report based on the WebVTT transcripts.

> "Find the recent 'Checkout Flow' study. Look at the session results, pull the transcripts for all completed sessions, and list out the exact pain points users experienced during payment input. Include timestamped quotes to prove each point."

**Execution Steps:**
1. Claude calls `list_all_user_testing_workspace_studies` to locate the study ID for "Checkout Flow".
2. Claude calls `list_all_user_testing_session_results` passing the test ID to get the list of completed session IDs.
3. Claude loops through the sessions, calling `list_all_user_testing_session_transcripts` for each one.
4. Claude processes the WebVTT text, extracting negative sentiment regarding the payment input.
5. Claude returns a summarized markdown list of pain points, matched with exact `00:00:00.000` WebVTT timestamps.

### Workflow 2: QX Score Analysis & Benchmarking

QX scores give you a quantitative baseline. You can ask Claude to pull these metrics, combine them with the test plan tasks, and generate an executive summary.

> "Pull the QX scores for our mobile nav test. Compare the usability vs trust components. Then, map those scores to the exact tasks the users were asked to perform, and generate a markdown table for the leadership team."

```mermaid
sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant UT as UserTesting API

    User->>Claude: "Pull QX scores for mobile nav test..."
    Claude->>MCP: Call list_all_user_testing_workspace_studies
    MCP->>UT: GET /v1/studies
    UT-->>MCP: Return studies list
    MCP-->>Claude: Return study UUID
    
    Claude->>MCP: Call list_all_user_testing_test_qx_scores
    MCP->>UT: GET /v1/tests/{id}/qx_scores
    UT-->>MCP: Return QX behavioral/attitudinal data
    MCP-->>Claude: Return QX JSON
    
    Claude->>MCP: Call get_single_user_testing_study_by_id
    MCP->>UT: GET /v1/studies/{id}
    UT-->>MCP: Return test plan and task array
    MCP-->>Claude: Return full study JSON
    
    Claude->>User: Render Markdown table comparing scores to tasks
```

**Execution Steps:**
1. Claude calls `list_all_user_testing_workspace_studies` to find the correct test.
2. Claude calls `list_all_user_testing_test_qx_scores` to fetch the behavioral, usability, and trust components.
3. Claude calls `get_single_user_testing_study_by_id` to retrieve the `testPlan` and `tasks` array to understand what actions resulted in those scores.
4. Claude generates a structured markdown table correlating the tasks with the quantitative QX data.

## Security and Access Control

Giving an AI agent access to your enterprise UserTesting data requires strict security controls. Truto provides four layers of configuration to ensure your MCP servers adhere to the principle of least privilege:

*   **Method Filtering (`config.methods`)**: You can restrict an MCP server to strictly read-only operations by passing `["read"]` during server creation. This prevents the LLM from accidentally mutating data or triggering new studies.
*   **Tag Filtering (`config.tags`)**: Integration resources in Truto are tagged by domain. You can restrict the MCP server to only expose tools tagged for specific workflows, keeping the context window small and focused.
*   **Extra Authentication (`require_api_token_auth`)**: By default, the cryptographically hashed MCP URL acts as the authentication vector. If you enable `require_api_token_auth`, clients must also pass a valid Truto API token in the `Authorization` header. This prevents unauthorized access even if the URL is leaked in a log file.
*   **Ephemeral Access (`expires_at`)**: You can assign an ISO datetime to `expires_at`. Truto sets a TTL on the underlying KV store and schedules a durable cleanup alarm. Once the timestamp passes, the server self-destructs automatically. 

## Stop Manually Scraping UX Insights

UX research is only valuable if the product team actually consumes the insights. Forcing product managers and engineers to watch hours of UserTesting footage guarantees that data will go ignored. 

By deploying a Truto MCP server, you turn your entire UserTesting repository into an interactive, queryable database. Claude can instantly analyze WebVTT transcripts, extract quantitative QX scores, and summarize Net Promoter feedback without writing point-to-point integration code.

> Stop wrestling with OAuth, pagination, and WebVTT parsers. Generate a managed UserTesting MCP server in minutes with Truto.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)