Connect UserTesting to ChatGPT: Analyze Studies and UX Score Data

UserTesting is a goldmine of qualitative and quantitative UX intelligence. From full-length video transcripts and Net Promoter Scores to complex QXscore metric breakdowns, it holds the exact data product teams need to make decisions. Giving a Large Language Model (LLM) direct access to this repository changes how you extract insights. Instead of manually reviewing hours of video, an AI agent can instantly retrieve transcripts, summarize pain points, and aggregate scores via natural language.

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

Connecting UserTesting to ChatGPT requires a Model Context Protocol (MCP) server. This server acts as a translation layer, securely taking JSON-RPC tool calls from ChatGPT and executing the corresponding REST API requests against UserTesting. You can either spend weeks writing, hosting, and maintaining a custom MCP server, or you can use a managed infrastructure layer to dynamically generate a secure, authenticated MCP server URL.

This guide breaks down exactly how to use Truto to generate a managed MCP server for UserTesting, connect it natively to ChatGPT, and execute complex UX 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 vendor APIs is painful. If you decide to build a custom MCP server for UserTesting, you own the entire API lifecycle. Here are the specific integration challenges you will face:

The WebVTT Transcript Challenge

Extracting text from a usability study is not a matter of downloading a simple text file. UserTesting returns transcripts in WebVTT format, which includes timestamped cue entries (e.g., 00:00:00.000 --> 00:00:02.000 followed by the spoken text). Furthermore, transcripts are only available for specific product types, such as LIVE_CONVERSATION and THINK_OUT_LOUD. If your MCP server blindly passes the raw WebVTT payload to an LLM without proper context, the context window fills with garbage timing metadata, causing the agent to lose the thread of the actual conversation.

Pre-Signed Video URL Expirations

LLMs and agents cannot just stream proprietary video files via a standard GET request. You have to request pre-signed video download URLs. These URLs have a strict time-to-live (TTL). If your AI agent requests a URL, gets distracted by another task, and attempts to use the URL later, it will fail. Your MCP server architecture must ensure LLMs understand the temporal nature of these assets.

Deeply Nested QXscore Metrics

The UserTesting interaction endpoints return heavily nested JSON objects. A QXscore result does not just return a flat integer. It returns task groups containing behavioral components, attitudinal components, usability scores, trust metrics, and appearance values. Mapping this nested architecture to a flat JSON Schema that an LLM can reliably query via function calling requires extensive schema engineering.

Handling 429 Rate Limits

UserTesting enforces API rate limits. When integrating via Truto, it is critical to understand that Truto does not absorb or automatically retry requests that hit rate limits. When the upstream UserTesting API returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your AI agent framework or calling application is entirely responsible for implementing the necessary exponential backoff and retry logic.

How to Generate a Managed UserTesting MCP Server

Instead of building custom schema mappers and handling JSON-RPC protocol handshakes from scratch, you can use Truto to generate a fully managed MCP server. The server derives its tool definitions dynamically from the underlying UserTesting API documentation, ensuring tools are always up to date.

Step 1: Create the MCP Server

You can create an MCP server either through the Truto dashboard or programmatically via the API.

Method A: Via the Truto UI

1. Navigate to the integrated account page for your UserTesting connection in the Truto dashboard.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration (e.g., allow read-only methods, filter by specific tags).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3...).

Method B: Via the API You can programmatically generate a server URL for any authenticated UserTesting tenant by making a POST request to Truto.

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 Agent",
    "config": {
      "methods": ["read"]
    }
  }'

The API returns a secure, ready-to-use URL containing a cryptographic token that routes requests directly to that specific UserTesting instance.

Step 2: Connect the Server to ChatGPT

Once you have the URL, you must register it with your LLM client.

Method A: Via the ChatGPT UI

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode (MCP custom connector support requires this flag).
3. Under MCP servers / Custom connectors, click to add a new server.
4. Enter a name (e.g., "UserTesting API").
5. Paste the Truto MCP server URL into the Server URL field and click Save.

ChatGPT will immediately connect, perform an initialization handshake, and load all available UserTesting tools.

Method B: Via Manual Config File (Claude Desktop / Cursor) If you are using a standard desktop MCP client, you can connect Truto by editing the client's configuration file (e.g., claude_desktop_config.json) to use the official SSE client proxy.

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

UserTesting Hero Tools for AI Agents

When connected, Truto exposes UserTesting API endpoints as discrete, LLM-callable tools. Here are five of the highest-leverage tools available for UX research workflows.

1. List Workspace Studies

Tool name: list_all_user_testing_workspace_studies

This tool retrieves a paginated list of all studies within a specific UserTesting workspace. It returns essential metadata like study title, product type, and creation date. Truto automatically injects cursor pagination instructions into the JSON schema, explicitly telling the LLM to pass the cursor value back unchanged if it needs to fetch subsequent pages.

"Fetch the first 50 studies from our main UserTesting workspace and list all studies that involve mobile app testing."

2. Get Study Details and NPS

Tool name: get_single_user_testing_study_by_id

Once an agent identifies a target study, this tool fetches the comprehensive study object. Crucially, this returns the test plan details and the aggregate Net Promoter Scores, detailing the exact percentages of detractors, passives, and promoters.

"Retrieve the full details for study ID 98765. Summarize the test plan tasks and tell me the overall Net Promoter Score breakdown."

3. Extract Session Transcripts

Tool name: list_all_user_testing_session_transcripts

This is the most critical tool for qualitative analysis. It retrieves the full video transcript for a session in WebVTT format. Agents can ingest this text payload to perform sentiment analysis, extract quotes, or identify points where the user struggled.

"Get the transcript for session ID 12345. Read through the text and extract all direct quotes where the participant mentions frustration with the checkout button."

4. Retrieve Video Download Links

Tool name: list_all_user_testing_session_video_download_urls

For workflows that require downstream media processing or sharing clips with stakeholders, this tool fetches a pre-signed video download URL. The payload includes the expiresAt timestamp, allowing the agent to understand exactly how long the URL is valid.

"Fetch the pre-signed video download URL for session ID 12345. Provide the link to me and note exactly when the link will expire."

5. Fetch QXscore Metrics

Tool name: list_all_user_testing_test_qx_scores

For quantitative analysis, this tool pulls the QXscore results for an interaction test. It returns the granular task group data, including behavioral metrics (time on task, success rate) and attitudinal metrics (usability, trust, appearance, loyalty).

"Pull the QXscore results for test ID 54321. Compare the behavioral success rate against the attitudinal trust metric and summarize the findings."

To view the complete inventory of available endpoints, parameter requirements, and schema mappings, visit the UserTesting integration page.

Workflows in Action

Connecting tools to an LLM is only the first step. The real value comes from autonomous orchestration. Here is how AI agents string these tools together to execute complex UX workflows.

Scenario 1: Automated Usability Study Synthesis

Instead of a researcher spending three hours watching session playbacks, they ask the AI agent to synthesize the study.

"Look up the recent 'Cart Redesign' study in our workspace. Find all completed sessions, pull their transcripts, and generate a summary of the top three usability issues users encountered during checkout."

1. The agent calls list_all_user_testing_workspace_studies to find the UUID for the 'Cart Redesign' study.
2. It calls list_all_user_testing_session_results using the test ID to retrieve all associated session IDs.
3. It loops through the sessions, calling list_all_user_testing_session_transcripts for each.
4. It ingests the WebVTT data, identifies the core pain points, and outputs a formatted markdown summary to the user.

sequenceDiagram
    participant User as User
    participant LLM as ChatGPT
    participant MCP as Truto MCP Server
    participant UT as UserTesting API

    User->>LLM: "Summarize the Cart Redesign study..."
    LLM->>MCP: Call list_all_user_testing_workspace_studies
    MCP->>UT: GET /v1/workspaces/{id}/studies
    UT-->>MCP: Return studies list
    MCP-->>LLM: Return tool response
    LLM->>MCP: Call list_all_user_testing_session_transcripts
    MCP->>UT: GET /v1/sessions/{id}/transcripts
    UT-->>MCP: Return WebVTT text
    MCP-->>LLM: Return transcript data
    LLM-->>User: Present synthesized markdown report

Scenario 2: Executive QXscore Reporting

Product managers need hard numbers for stakeholder meetings. They can prompt the agent to aggregate scores dynamically.

"Fetch the QXscores for the 'Q3 Mobile Nav' test. Break down the usability versus trust scores. Then, get the video download link for the lowest scoring session so I can share it with the engineering team."

1. The agent calls list_all_user_testing_test_qx_scores for the specified test.
2. It analyzes the returned JSON array, comparing the usability and trust values across all task groups.
3. It cross-references the session IDs and identifies the lowest performer.
4. It calls list_all_user_testing_session_video_download_urls for that specific session.
5. It returns the metric breakdown along with the pre-signed video URL.

Security and Access Control

Exposing an enterprise UX database to an autonomous agent requires strict governance. Truto MCP servers provide multiple layers of access control configured at the token level:

• Method Filtering: Limit the MCP server to read-only operations. By setting "methods": ["read"], you guarantee the LLM cannot accidentally modify test plans or delete sessions.
• Tag Filtering: Restrict access to specific functional areas of the API. If you only want the LLM to access transcripts and media, you can filter by media-specific tags, completely hiding workspace administrative endpoints.
• Require API Token Auth: By enabling require_api_token_auth, possession of the MCP server URL is not enough. The client must also pass a valid Truto API token in the Authorization header, adding a strict secondary identity check.
• Expiration (TTL): Set an expires_at timestamp when creating the server. Once the time is reached, Cloudflare KV automatically invalidates the token and a Durable Object alarm cleans up the database record, ensuring no stale access remains.

Stop Building Infrastructure

Connecting UserTesting to ChatGPT gives your product teams an entirely new way to interface with qualitative data. But forcing your engineering team to build a custom MCP server, handle OAuth token refreshes, map nested QXscore schemas, and manage rate limit passthrough is a massive waste of resources.

Managed MCP servers abstract the protocol translation away. By treating your integrations as infrastructure, you can give your AI agents secure, fully documented access to UserTesting in minutes, not months.