Connect UserTesting to ChatGPT: Analyze Study Data & Transcripts

If your UX research team sits on a mountain of qualitative data, connecting UserTesting to ChatGPT allows your AI agents to analyze session transcripts, extract QXscores, and summarize participant feedback automatically. If your team uses Claude instead, check out our guide on connecting UserTesting to Claude or explore our architectural overview on connecting UserTesting to AI Agents.

Giving a Large Language Model (LLM) access to your user research repository is an engineering challenge. You must translate an LLM's natural language tool calls into structured REST API requests. You can either build and maintain this translation layer - a custom Model Context Protocol (MCP) server - from scratch, 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 research analysis workflows using natural language.

The Engineering Reality of the UserTesting API

A custom MCP server is a self-hosted integration layer. While Anthropic's open standard provides a predictable way for models to discover tools via JSON-RPC 2.0, implementing it against vendor APIs is painful. If you 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 Parsing Challenge UserTesting does not simply return a flat text block of what a user said. Transcripts are returned in WebVTT format - a time-indexed caption format containing cues, timestamps (e.g., 00:00:00.000 --> 00:00:02.000), and metadata. If your MCP server blindly dumps massive WebVTT files into the LLM context window, you will rapidly exhaust your token limits and degrade model reasoning. Your integration layer needs to understand how to retrieve these transcripts and instruct the LLM on how to parse or summarize them effectively.

Time-Bound Media URLs When an LLM wants to retrieve a session video to share with a product manager, it cannot just grab a static MP4 link. UserTesting generates pre-signed video download URLs that expire. If your custom server does not handle this ephemeral state, the LLM will hallucinate invalid links, or hand the user a URL that throws a 403 Forbidden error by the time they click it.

Nested Interaction Data Models UserTesting's data model is deeply nested. A study contains multiple sessions, which contain participant metadata, which contain task groups, which contain individual tasks (categorized into behavioral and attitudinal metrics). Extracting a Net Promoter Score (NPS) or QXscore requires traversing multiple array levels. If you do not construct precise JSON schemas for every endpoint, the LLM will fail to structure its API requests correctly.

Rate Limits and 429 Errors UserTesting enforces strict API quotas. When you hit these limits, the API returns an HTTP 429 status code. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream API rejects a request, Truto passes that 429 error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. Your client implementation is entirely responsible for reading these headers and executing exponential backoff. If you ignore them, the LLM will assume the tool call succeeded and hallucinate the response.

Generating the UserTesting MCP Server

Truto derives tool definitions dynamically from the integration's resource configurations and documentation records. Rather than hand-coding schemas, Truto generates them on the fly. You can create a UserTesting MCP server via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

For teams who want a zero-code setup, you can generate the server directly from your dashboard:

1. Navigate to the Integrated Accounts page in your Truto environment.
2. Select your connected UserTesting account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (name, allowed methods, tags, and expiration).
6. Click Create and copy the generated secure MCP server URL.

Method 2: Via the Truto API

For platform engineers building multi-tenant AI products, you can generate MCP servers programmatically. This endpoint validates that the integration is AI-ready, generates a cryptographically hashed token, stores it in a distributed key-value store, and returns a ready-to-use URL.

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 Research Assistant",
    "config": {
      "methods": ["read"],
      "tags": ["research", "analytics"]
    }
  }'

Response:

{
  "id": "mcp_abc123",
  "name": "UserTesting Research Assistant",
  "config": { "methods": ["read"], "tags": ["research", "analytics"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you must register it with your client. Because Truto bakes the authentication directly into the tokenized URL, there is no complex OAuth handshake required on the client side.

Method A: Via the ChatGPT UI

If you are using ChatGPT Enterprise or ChatGPT Plus with Developer Mode enabled:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to the ON position.
3. Under MCP servers / Custom connectors, click Add new server.
4. Name: UserTesting (Truto)
5. Server URL: Paste the URL generated in the previous step.
6. Click Save.

ChatGPT will immediately send an initialize JSON-RPC request to the Truto router, discover the available tools, and make them available to your current chat session.

Method B: Via CLI or Config File

If you are running a custom headless agent, a LangChain application, or using a local inspector, you connect using the standard server-sent events (SSE) transport configuration.

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

Hero Tools for UserTesting

Truto automatically generates precise tools based on the underlying UserTesting API schemas. Here are the highest-leverage tools available for your AI agents.

List All Workspace Studies

list_all_user_testing_workspace_studies

This tool retrieves a paginated list of studies within a specific UserTesting workspace. It returns critical metadata including the study UUID, title, product type, and creation date. The LLM uses this as the discovery mechanism to find specific tests before drilling down into session details.

"Fetch all recent studies from our primary research workspace. Find the study titled 'Checkout Flow Redesign Q3'."

Get Single Study by ID

get_single_user_testing_study_by_id

Once the LLM identifies a study, this tool retrieves the full, deeply nested study object. It returns the session count, Net Promoter Scores (split into detractor, passive, and promoter percentages), and the full array of tasks configured for the test plan.

"Get the full details for the 'Checkout Flow Redesign Q3' study. What was the overall NPS, and what specific tasks were the participants asked to complete?"

List All Session Results

list_all_user_testing_session_results

This tool queries the individual participant sessions tied to a specific test. It returns a summary array containing session IDs, status, audience targeting IDs, and completion timestamps. The LLM needs these session IDs to retrieve transcripts or videos.

"List all completed session results for the Checkout Flow study. Give me the session IDs for the first 5 participants who finished the test."

Get Single Session Result by ID

get_single_user_testing_session_result_by_id

For a specific participant, this tool retrieves the granular session data. It returns the exact interaction flow, mapping the participant's actions to specific task groups and task definitions.

"Pull the detailed session result for participant session ID 98765. Did they successfully complete the 'Add to Cart' task group?"

List All Session Transcripts

list_all_user_testing_session_transcripts

This is the core qualitative data tool. It retrieves the full video transcript for a session in WebVTT format. Because WebVTT contains timestamps and cues, the LLM can analyze exactly what the user said and when they said it. Note that this is only available for LIVE_CONVERSATION and THINK_OUT_LOUD product types.

"Retrieve the transcript for session ID 98765. Read through the WebVTT data and summarize any moments where the user expressed frustration or confusion."

List All Session Video Download URLs

list_all_user_testing_session_video_download_urls

This tool generates a pre-signed, time-limited video download URL for a specific session. The LLM uses this to provide actionable assets back to the user, allowing product managers to download the raw video file before the link expires.

"Generate the video download URL for session ID 98765 so I can share it with the design team."

List All Test QX Scores

list_all_user_testing_test_qx_scores

This tool extracts quantitative QXscore results for interaction tests. It returns granular scoring components, breaking down the behavioral and attitudinal metrics (usability, trust, appearance, loyalty) for each task group.

"Extract the QXscores for the recent onboarding test. Break down the behavioral versus attitudinal scores for the final registration task."

For the complete inventory of available tools and their explicit JSON schemas, review the UserTesting integration page.

Workflows in Action

When you connect UserTesting to ChatGPT via an MCP server, you upgrade the LLM from a static text generator into an autonomous research assistant. Here is how complex multi-step workflows execute in practice.

Workflow 1: UX Sentiment and Transcript Analysis

Product teams rarely have time to watch dozens of hours of user testing videos. You can instruct the agent to locate a test, find the sessions, pull the transcripts, and summarize the friction points.

"Find the 'Mobile App Navigation' study in workspace UUID 12345. Get the session results, pull the transcripts for the first 3 sessions, and summarize the main areas where users got confused."

1. The agent calls list_all_user_testing_workspace_studies to find the study ID based on the title.
2. The agent calls list_all_user_testing_session_results to extract the first 3 completed session IDs.
3. The agent iterates through the sessions, calling list_all_user_testing_session_transcripts for each.
4. The LLM parses the WebVTT data in its context window, identifies negative sentiment cues, and synthesizes a bulleted report of UX friction points.

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

  User->>ChatGPT: "Summarize confusion in the Mobile App Navigation study."
  ChatGPT->>MCP: Call list_all_user_testing_workspace_studies
  MCP->>API: GET /v1/workspaces/12345/studies
  API-->>MCP: Returns study list
  MCP-->>ChatGPT: Returns tool result
  
  ChatGPT->>MCP: Call list_all_user_testing_session_results (test_id)
  MCP->>API: GET /v1/tests/{id}/sessions
  API-->>MCP: Returns session array
  MCP-->>ChatGPT: Returns session IDs
  
  ChatGPT->>MCP: Call list_all_user_testing_session_transcripts (session_id)
  MCP->>API: GET /v1/sessions/{id}/transcript
  API-->>MCP: Returns WebVTT payload
  MCP-->>ChatGPT: Returns transcript data
  
  ChatGPT->>User: Synthesizes WebVTT and outputs UX summary.

Workflow 2: Quantitative UX Scorecard Generation

Leadership needs hard numbers on product usability. The AI agent can extract the heavily nested QXscores and NPS data, format it into a table, and present it instantly.

"Generate a UX scorecard for the 'New Checkout Flow' test. I need the overall NPS breakdown and the detailed QXscores for usability and trust."

1. The agent calls get_single_user_testing_study_by_id to retrieve the test object and parses the netPromoterScores array (extracting detractor, passive, and promoter percentages).
2. The agent calls list_all_user_testing_test_qx_scores to fetch the behavioral and attitudinal metrics for that specific test.
3. The LLM formats the raw JSON into a clean, readable markdown table for the user.

Workflow 3: Compiling Video Assets for Stakeholders

When a specific user encounters a critical bug, engineering needs to see the video. The agent can locate the specific user session and generate the expiring video URLs on command.

"Find the session for participant 'John Doe' in the latest test and give me the pre-signed video download URL so I can send it to engineering."

1. The agent calls list_all_user_testing_session_results to map the participant name to a sessionId.
2. The agent calls list_all_user_testing_session_video_download_urls using that session ID.
3. The LLM provides the secure, time-bound URL to the user, ensuring they have immediate access to the raw MP4 file.

Security and Access Control

Exposing enterprise research data to an LLM requires strict security boundaries. Truto MCP servers are stateless - they do not cache or store your UserTesting data. Furthermore, Truto provides four distinct access control mechanisms baked directly into the MCP token:

• Method Filtering: You can restrict a server to specific operations. By passing config.methods: ["read"], you guarantee the LLM can only execute get and list operations, preventing it from accidentally deleting a study or modifying test parameters.
• Tag Filtering: You can scope tools by functional area. Applying config.tags: ["research"] ensures the server only exposes endpoints relevant to session data and transcripts, hiding administrative or billing endpoints.
• Token Expiration: You can set an expires_at ISO datetime when generating the server. Once the timestamp passes, a durable scheduled alarm triggers, instantly invalidating the token in the distributed KV store and tearing down the server.
• Extra Authentication: By enabling require_api_token_auth: true, possession of the MCP URL is no longer enough. The client must also pass a valid Truto API token in the Authorization header, ensuring only verified internal systems can interact with the server.

Strategic Wrap-Up

Forcing engineers to build custom integration infrastructure for AI agents is a massive waste of resources. Dealing with WebVTT parsing, pagination cursors, OAuth token lifecycles, and nested JSON schemas pulls your team away from your core product.

By leveraging Truto's dynamically generated MCP servers, you can connect UserTesting to ChatGPT in minutes. Your AI agents gain immediate, secure access to transcripts, QXscores, and video media, allowing your UX team to automate qualitative research analysis without writing a single line of integration code.