Connect UserTesting to Claude: Process Session Media and Transcripts

If you need to connect UserTesting to Claude to automate UX research analysis, transcribe user sessions, or extract QX scores, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and UserTesting's REST 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 UserTesting to ChatGPT or explore our broader architectural overview on connecting UserTesting to AI Agents.

Giving a Large Language Model (LLM) read access to a heavy media ecosystem like UserTesting is an engineering challenge. You have to handle expiring video URLs, parse WebVTT transcripts, map nested quantitative UX score schemas to MCP tool definitions, and deal with strict rate limits. Every time an endpoint changes or a new test type is introduced, 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 UserTesting, connect it natively to Claude, and execute complex research workflows using natural language.

The Engineering Reality of the UserTesting 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 UserTesting's APIs is painful.

If you decide to build a custom MCP server for UserTesting, you own the entire API lifecycle. Here are the specific challenges you will face:

Product-Type Dependency Constraints UserTesting endpoints behave differently based on the type of study conducted. For example, video transcripts are only available for sessions belonging to LIVE_CONVERSATION and THINK_OUT_LOUD product types. Video download URLs add NON_THINK_OUT_LOUD to that list. If you expose raw endpoints to Claude without context, the LLM will repeatedly try to fetch transcripts for incompatible test types and fail. Truto maps these constraints into the tool schemas, so Claude knows exactly when it can and cannot invoke a tool.

Ephemeral Media and Pre-Signed URLs You cannot fetch raw video binaries directly through standard API GET requests. The UserTesting API utilizes expiring pre-signed URLs for media assets like full sessions, clips, and highlight reels. If Claude attempts to cache these URLs or use them after the expiresAt window, the workflow breaks. Your MCP server must explicitly guide the model to fetch fresh URLs immediately before handing them off to downstream downloading scripts.

Deeply Nested Quantitative Score Models UserTesting provides sophisticated metrics like Net Promoter Scores (NPS) and QXscores. These are not flat integers. A QXscore response contains nested objects for components (behavioral and attitudinal) and values (usability, trust, appearance, loyalty). An LLM struggles to consistently map unstructured prompts to these deeply nested parameters. Truto auto-generates JSON schemas from the underlying API documentation, forcing Claude to format its requests and interpret responses exactly as the API intended.

Rate Limits and 429 Handling When scraping bulk transcripts or analyzing dozens of clips, you will hit UserTesting's API limits. Truto does not absorb, retry, or apply exponential backoff on these errors. Instead, Truto passes the HTTP 429 Too Many Requests error directly back to Claude. However, Truto normalizes the upstream rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). This allows your Claude client or multi-agent orchestration framework to intelligently implement its own retry logic based on accurate reset timestamps.

Generating a UserTesting MCP Server

To connect UserTesting to Claude, you first need to generate an MCP server tied to a specific UserTesting account. Truto allows you to do this via the UI or the API.

Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server in just a few clicks:

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected UserTesting account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your configuration - optionally restrict the server to specific tags or read-only methods.
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/abc123def456).

Method 2: Via the Truto API

For platform engineers embedding this into a broader product, you can programmatically generate the server. Make a POST request to /integrated-account/:id/mcp with your desired configuration.

// Example: Generating a read-only UserTesting MCP Server
const response = await fetch('https://api.truto.one/integrated-account/usr_test_789/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "UX Research Analysis Server",
    config: { 
      methods: ["read", "list", "get"] 
    }
  })
});
 
const data = await response.json();
console.log(data.url); // The URL you will pass to Claude

This API call validates the integrated account, provisions a securely hashed token in Cloudflare KV, and returns the endpoint. The returned URL is fully self-contained and acts as the entry point for Claude.

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you need to register it with your Claude environment.

Method 1: Via the Claude Desktop UI

The easiest way for individuals and researchers to connect is directly through the Claude Desktop application.

1. Open Claude Desktop and navigate to Settings.
2. Click on Integrations (or Connectors depending on your version).
3. Select Add MCP Server.
4. Paste the Truto MCP URL into the connection field.
5. Click Add.

Claude will immediately ping the server using the initialize protocol method, discover all available UserTesting tools, and load their descriptions into its context window.

Method 2: Via the Configuration File

If you are deploying Claude in a headless environment, using the Claude CLI, or prefer infrastructure-as-code, you can modify the configuration file. For Claude Desktop, edit claude_desktop_config.json.

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

Restart Claude after saving this file. The @modelcontextprotocol/server-sse package acts as a transport bridge, converting the local standard I/O commands into HTTP Server-Sent Events expected by Truto's JSON-RPC 2.0 endpoint.

UserTesting Hero Tools for Claude

Once connected, Truto exposes your UserTesting endpoints as callable tools. Because Truto dynamically derives these from the integration's schemas, Claude inherently understands the required parameters. Here are the highest-leverage operations for automating UX research.

1. list_all_user_testing_session_transcripts

This tool retrieves the full video transcript for a specific UserTesting session. The text is returned in WebVTT format (timestamped cue entries). Because Claude is highly capable of parsing WebVTT, you can ask it to correlate specific spoken quotes with exact video timestamps.

"Fetch the transcript for session ID 'sess_98765' and extract all quotes where the user mentions 'confusing navigation'. Format the output as a bulleted list with the exact WebVTT timestamps next to each quote."

2. get_single_user_testing_study_by_id

Use this to pull the complete metadata for a study, including the test plan, the tasks assigned to the users, and Net Promoter Scores (NPS). It returns the percentages for detractors, passives, and promoters, giving Claude the context needed to summarize the overall success of the study.

"Get the details for study 'stdy_444'. Summarize the tasks the users were asked to perform, and then report the final Net Promoter Score breakdown (detractors vs. promoters)."

3. list_all_user_testing_test_qx_scores

QXscores measure the holistic user experience. This tool retrieves the interaction test results, breaking down both behavioral components (task success rates, time on task) and attitudinal components (usability, trust, appearance).

"Retrieve the QX scores for test ID 'test_222'. Compare the behavioral score against the attitudinal score. If the usability metric is below 70, suggest three potential areas of friction in the UI."

4. list_all_user_testing_session_results

This is your foundational listing tool. It returns summaries of all sessions under a specific test, including the sessionId, status, startTime, and finishTime. Claude uses this to discover which sessions are actually finished and ready for deep transcript analysis.

"List all session results for test ID 'test_222'. Filter out any sessions that are not marked as 'completed', and give me a list of the valid session IDs."

5. list_all_user_testing_test_highlight_reels

UserTesting allows researchers to manually or automatically compile highlight reels. This tool lists the available reels for a test result, providing duration metadata and checking if all clips have been processed.

"Find all highlight reels associated with test ID 'test_222'. Tell me the duration of the longest reel and provide its exact reel ID so I can fetch the download link."

6. get_single_user_testing_test_highlight_reel_by_id

Once you have a reel ID, this tool fetches the actual download link. The link returned is a pre-signed URL with an expiration window.

"Get the download link for highlight reel ID 'reel_555' from test 'test_222'. Output the raw URL and note its expiration time so I can pass it to our video archiving script."

7. list_all_user_testing_session_video_download_urls

Similar to the highlight reel tool, but for raw, uncut session videos. This returns the videoUrl, the associated sessionId, and the expiresAt timestamp. Note that this is only available for specific product types like THINK_OUT_LOUD.

"Fetch the video download URLs for session ID 'sess_98765'. Ensure you give me the exact expiration timestamp for the URL so I know how long the link is valid."

For the complete inventory of available UserTesting tools, including detailed JSON schemas for every query and body parameter, visit the UserTesting integration page.

Workflows in Action

With the MCP server connected, Claude transitions from a simple chat interface into an autonomous UX research assistant. Here are practical workflows demonstrating how Claude orchestrates multiple API calls to synthesize insights.

Scenario 1: Automated Sentiment and Friction Analysis

A UX Researcher needs to quickly understand the primary complaints from a newly completed usability test without watching 10 hours of video.

"I need an analysis of test ID 'test_888'. First, find all completed sessions. Then, for each completed session, fetch the transcript. Read through the transcripts and compile a summary of every time a user expressed frustration or confusion. Group these pain points by feature, and include the exact timestamp from the transcript where the issue occurred."

How Claude executes this:

1. Calls list_all_user_testing_session_results passing testId: 'test_888'. It parses the response to find all session IDs where status is completed.
2. Iterates through the valid session IDs, calling list_all_user_testing_session_transcripts for each one.
3. Claude reads the resulting WebVTT strings, applying its natural language understanding to detect sentiment (frustration, confusion).
4. Claude synthesizes the data into a structured markdown report, mapping specific pain points to the WebVTT timestamps.

Scenario 2: Executive UX Score Reporting

A Product Manager needs to compile a high-level summary of a recent product launch's UX performance, correlating hard metrics with video evidence.

"Compile an executive summary for test ID 'test_999'. Start by getting the overall QX scores and breaking down the usability vs. trust metrics. Next, pull the study details to get the NPS score. Finally, find the available highlight reels and provide the expiring download links so I can share the video evidence with the engineering team."

How Claude executes this:

1. Calls list_all_user_testing_test_qx_scores with the test ID to extract the behavioral and attitudinal metrics.
2. Calls get_single_user_testing_study_by_id to retrieve the Net Promoter Score percentages.
3. Calls list_all_user_testing_test_highlight_reels to get the list of reel IDs.
4. Iterates through the reel IDs, calling get_single_user_testing_test_highlight_reel_by_id to generate the expiring download URLs.
5. Presents a consolidated executive report with metrics, NPS breakdown, and clickable video links.

sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant UT as Upstream API (UserTesting)

    Claude->>MCP: Call list_all_user_testing_test_qx_scores
    MCP->>UT: GET /v1/tests/{test_id}/qx_scores
    UT-->>MCP: Raw QX data
    MCP-->>Claude: Normalized JSON schema
    Claude->>MCP: Call list_all_user_testing_test_highlight_reels
    MCP->>UT: GET /v1/tests/{test_id}/highlight_reels
    UT-->>MCP: Pre-signed URL payload
    MCP-->>Claude: JSON with expiring URLs

Security and Access Control

When granting an LLM access to proprietary product research and unreleased feature testing, security is paramount. Truto's managed MCP architecture provides strict guardrails to ensure Claude only accesses what it should.

• Method Filtering: When generating the MCP server, use config.methods to enforce read-only access (e.g., ["read"]). This ensures the model can fetch transcripts and scores but cannot accidentally modify test plans or delete sessions.
• Tag Filtering: Use config.tags to limit the server's scope to specific resource groups. For example, you can expose session data without exposing organizational billing endpoints.
• Dual-Layer Authentication: Enable require_api_token_auth: true. This forces the Claude client to pass a valid Truto API token in addition to possessing the unique MCP URL. Even if the URL is leaked in a log file, the server remains secure.
• Ephemeral Servers: Set an expires_at ISO datetime when creating the MCP server. Truto will automatically destroy the token and clean up the database records at that exact time. This is perfect for giving contractors temporary access to UX research data.
• Zero Data Retention: Truto's proxy architecture means your UserTesting transcripts and QX scores pass through the system in memory. They are formatted for Claude and immediately discarded. Truto never stores your research data.

Moving Past Manual Integration Maintenance

Connecting UserTesting to Claude transforms how product teams interact with UX research. Instead of manually downloading WebVTT files, cross-referencing timestamps, and pasting data into prompt windows, engineers can deploy agentic workflows that extract and synthesize user feedback automatically.

Building an MCP server from scratch requires deep knowledge of UserTesting's product types, pre-signed URL behaviors, and nested metrics schemas. By using Truto to dynamically generate the server, you offload the authentication, schema mapping, and endpoint maintenance. Your team can focus on writing better prompts and analyzing the research, rather than debugging API pagination loops.