---
title: "Connect Hotjar to ChatGPT: Analyze Surveys and User Feedback"
slug: connect-hotjar-to-chatgpt-analyze-surveys-and-user-feedback
date: 2026-11-04
author: Roopendra Talekar
categories: ["AI & Agents"]
excerpt: "Learn how to connect Hotjar to ChatGPT using a managed MCP server. Execute survey analysis, retrieve responses, and automate GDPR data subject lookups with AI."
tldr: "Connect Hotjar to ChatGPT using Truto's managed MCP server. This guide covers generating your MCP server URL, configuring ChatGPT for tool calling, and orchestrating survey data and privacy workflows."
canonical: https://truto.one/blog/connect-hotjar-to-chatgpt-analyze-surveys-and-user-feedback/
---

# Connect Hotjar to ChatGPT: Analyze Surveys and User Feedback


If you need to connect Hotjar to ChatGPT to automate user feedback analysis, extract survey insights, or orchestrate GDPR privacy requests, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/). This server acts as the translation layer between ChatGPT's tool calls and Hotjar's REST APIs. You can either [build and maintain this infrastructure yourself](https://truto.one/build-vs-buy-the-hidden-costs-of-custom-mcp-servers/), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL.

If your team uses Claude, check out our guide on [connecting Hotjar to Claude](https://truto.one/connect-hotjar-to-claude-manage-survey-designs-and-responses/) or explore our broader architectural overview on [connecting Hotjar to AI Agents](https://truto.one/connect-hotjar-to-ai-agents-automate-survey-data-and-privacy/).

Giving a Large Language Model (LLM) read and write access to a feedback and analytics platform like Hotjar is a massive engineering challenge. You have to handle complex relational data payloads, map survey questions to their corresponding answers, and navigate strict privacy compliance endpoints. Every time Hotjar updates an endpoint or paginates a new response object, your custom server code must be updated, redeployed, and tested.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Hotjar, connect it natively to ChatGPT, and execute complex workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Hotjar 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, implementing it against Hotjar's specific API quirks is exceptionally painful.

If you decide to build a custom MCP server for Hotjar, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with Hotjar:

### Dual Hierarchy: Site vs. Organization Scoping
Unlike standard SaaS platforms that scope all operations to a single tenant or workspace ID, Hotjar uses a dual hierarchy. Survey data, feedback, and user responses are scoped to a `site_id`. However, privacy operations - like looking up a user for a GDPR Data Subject Access Request (DSAR) - are scoped to an `organization_id`. If you build a custom MCP server, you must write custom logic to ensure the LLM understands which ID to use for which tool. Truto handles this by exposing the required parameters clearly in the generated JSON schemas, preventing the LLM from hallucinating IDs across endpoints.

### Dynamic Survey Schemas and Orphaned Answers
When an LLM asks "What did users say about the new checkout flow?", a standard request to Hotjar's survey response endpoint returns answers tied to arbitrary question IDs, not human-readable text. To make sense of the data, your custom server must first fetch the survey definition, extract the question schema, and map the answers back to the original text before returning the context to the LLM. If you skip this orchestration, the model receives raw IDs and fails to generate a coherent analysis.

### High-Risk Asynchronous Privacy Endpoints
Hotjar's User Lookup API is not a simple read endpoint. It initiates an asynchronous process to find or delete data subjects. Crucially, the behavior of this endpoint changes based on the request body. If you pass `delete_all_hits: false`, Hotjar automatically sends a report-link email to the data subject. If an AI agent hallucinates this payload during an automated workflow, it could accidentally email thousands of users instead of just deleting their data. Your MCP server must enforce strict schema constraints to prevent catastrophic compliance failures.

## Step 1: Generate a Hotjar MCP Server

To connect ChatGPT to Hotjar, you first need an MCP server. [Truto dynamically generates these servers](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) based on the actual Hotjar API documentation and your connected account credentials. You can create this server via the Truto UI or programmatically via the API.

### Method 1: Via the Truto UI
This is the fastest method for internal teams and administrators.

1. Log into your Truto dashboard and navigate to **Integrated Accounts**.
2. Click on your connected Hotjar account (or connect a new one using the standard OAuth flow).
3. Click the **MCP Servers** tab on the account detail page.
4. Click **Create MCP Server**.
5. Configure your server: set a name, select allowed methods (e.g., `read`, `write`), and specify tags if you want to restrict access to specific resources (e.g., `surveys`, `privacy`).
6. Click Save and **copy the generated MCP server URL**. It will look like `https://api.truto.one/mcp/<token>`.

### Method 2: Via the Truto API
If you are building an application and need to programmatically provision MCP servers for your own users, use the Truto API. This single POST request scopes an MCP endpoint to a specific integrated account.

```bash
curl -X POST https://api.truto.one/integrated-account/$INTEGRATED_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Hotjar for ChatGPT",
    "config": {
      "methods": ["read", "write"],
      "tags": ["surveys", "privacy"]
    }
  }'
```

The response contains the exact same secure URL:

```json
{
  "id": "mcp_abc123",
  "name": "Hotjar for ChatGPT",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}
```

This single URL carries routing and authentication. Treat it like a secret credential.

## Step 2: Connect the MCP Server to ChatGPT

Now that you have your managed MCP server URL, you need to register it with your ChatGPT environment. You can do this through the ChatGPT interface or via a manual configuration file for local development.

### Method 1: Via the ChatGPT UI
If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add custom connectors directly.

1. In ChatGPT, navigate to **Settings -> Apps -> Advanced settings**.
2. Enable **Developer mode** (MCP support is gated behind this toggle).
3. Under the **MCP servers / Custom connectors** section, click to add a new server.
4. Enter a name (e.g., "Hotjar (Truto)").
5. Paste the Truto MCP URL (`https://api.truto.one/mcp/<token>`) into the Server URL field.
6. Click **Save**.

ChatGPT will immediately ping the endpoint, initialize the JSON-RPC 2.0 handshake, and load the available Hotjar tools.

### Method 2: Via Manual Config File
If you are running a local agent environment, an IDE like Cursor, or testing via the Claude Desktop app, you can map the URL using the standard MCP configuration file (`mcp_config.json` or `glama.json`).

Since Truto's endpoints operate over HTTP/SSE, use the `@modelcontextprotocol/server-sse` proxy package to bridge the connection:

```json
{
  "mcpServers": {
    "hotjar_truto": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-sse",
        "--url",
        "https://api.truto.one/mcp/<your-token-here>"
      ]
    }
  }
}
```

Restart your client, and the tools will be instantly available to your model.

## Hero Tools for Hotjar

Truto [automatically generates precise, JSON-schema-backed tools](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) for every documented Hotjar endpoint. Here are the core "hero" tools you will use most frequently when automating survey analysis and privacy workflows with ChatGPT.

### List All Hotjar Surveys
This tool retrieves all surveys associated with a specific Hotjar site. It returns critical metadata, including whether sentiment analysis is enabled, the survey URL, and the array of configured questions.

**Contextual usage notes:** The LLM should call this tool first to discover the `survey_id` and the question schemas before attempting to fetch or analyze actual user responses. Max 100 surveys per page.

> "Fetch all active surveys for site ID 123456 and list the questions configured for the onboarding feedback survey."

### Get Single Hotjar Survey by ID
Fetches a specific survey object. This is identical to the list endpoint but targeted at a known ID, ensuring the question array is always included.

**Contextual usage notes:** When the LLM already knows the `survey_id` from a previous step or external prompt, it uses this tool to grab the exact schema needed to map incoming answers.

> "Get the details for survey ID 98765 on site 123456 and format the questions into a markdown table."

### List All Hotjar Survey Responses
Retrieves the actual user submissions for a specific survey, sorted newest first. The response payload includes the raw answers, browser details, device type, OS, and any associated user attributes.

**Contextual usage notes:** This tool returns answers mapped by question ID. The LLM must intelligently cross-reference these answers with the question schema obtained from the survey details tool. It also returns the `recording_url` if session recordings are tied to the feedback.

> "Pull the latest 50 responses for the pricing page survey. Group the answers by question and summarize any negative sentiment from mobile users."

### Create a Hotjar User Lookup
Executes a privacy-compliant user lookup for a specific data subject. This is the core mechanism for handling GDPR and CCPA requests.

**Contextual usage notes:** This tool requires the `organization_id`. The payload must contain either a `data_subject_email` or a `data_subject_site_id_to_user_id_map`. If the LLM sets `delete_all_hits: false`, Hotjar sends a data report email to the user. If set to `true`, Hotjar wipes the user's data and returns an empty 202 Accepted response.

> "Initiate a data deletion request for user email privacy@example.com under organization ID 555888. Ensure that delete_all_hits is explicitly set to true so their data is completely removed without sending a report."

For a complete list of all available tools, endpoints, and schemas, visit the [Hotjar integration page](https://truto.one/integrations/detail/hotjar).

## Workflows in Action

Connecting an LLM to Hotjar unlocks massive operational leverage. Instead of manually exporting CSVs and fighting with spreadsheets, you can orchestrate multi-step data pipelines through conversation.

### Scenario 1: The UX Researcher Analyzing Feature Feedback
Product teams frequently launch surveys inside their web app to gather feedback on new features. A UX Researcher wants to analyze the sentiment of recent responses without manually reading hundreds of entries.

> "Look up the 'New Dashboard Beta' survey on site 444333. Pull the latest responses, map the answers to the actual questions, and summarize the top 3 friction points users are experiencing on desktop vs. mobile devices."

**Step-by-step execution:**
1. The agent calls `list_all_hotjar_surveys` with `site_id: "444333"` to find the ID of the "New Dashboard Beta" survey.
2. The agent identifies the `survey_id` (e.g., 999111) and extracts the `questions` array to understand what was asked.
3. The agent calls `list_all_hotjar_survey_responses` using `site_id: "444333"` and `survey_id: "999111"`.
4. The agent processes the raw JSON, matches the answer IDs to the question schemas, groups the data by the `device` attribute, and generates a formatted markdown summary of the top friction points.

### Scenario 2: The DPO Handling a GDPR Deletion Request
A Data Protection Officer (DPO) receives an automated Zendesk ticket regarding a right-to-be-forgotten request. They need to instantly wipe the user's data from Hotjar without logging into the platform.

> "We received a GDPR deletion request for customer@example.com. Please execute a complete data deletion for this user across our Hotjar organization (ID: 777222). Do not send them an email report."

**Step-by-step execution:**
1. The agent parses the prompt and identifies the target operation (user deletion) and the required parameters.
2. The agent constructs the payload, explicitly setting `delete_all_hits: true` and `data_subject_email: "customer@example.com"`.
3. The agent calls `create_a_hotjar_user_lookup` with `organization_id: "777222"` and the constructed body.
4. Truto proxies the request to Hotjar. Hotjar accepts the request and returns a 202 Accepted status.
5. The agent informs the DPO that the deletion request has been successfully queued in the Hotjar system.

```mermaid
sequenceDiagram
  participant User as DPO (ChatGPT)
  participant MCP as Truto MCP Server
  participant Hotjar as Hotjar API

  User->>MCP: Call create_a_hotjar_user_lookup<br>with delete_all_hits: true
  MCP->>Hotjar: POST /v1/organizations/777222/user-lookup
  Hotjar-->>MCP: 202 Accepted (Empty Body)
  MCP-->>User: Success Confirmation
```

## Security and Access Control

Exposing enterprise analytics and privacy data to AI models requires strict boundaries. Truto provides multiple layers of security at the MCP token level, ensuring your agents only access what they explicitly need.

*   **Method Filtering:** Restrict an MCP server to specific HTTP methods. You can limit a server to `methods: ["read"]` to ensure an AI agent can analyze survey responses but cannot accidentally trigger a GDPR deletion via a `write` operation.
*   **Tag Filtering:** Limit the available tools to specific domains. By passing `tags: ["surveys"]`, the server will completely hide the privacy and user lookup tools from the LLM.
*   **API Token Authentication:** For internal team usage, you can enforce `require_api_token_auth: true`. This forces the ChatGPT client to pass a valid Truto API token in the headers, meaning possession of the MCP URL alone is not enough to execute tools.
*   **Time-to-Live (TTL):** Set an `expires_at` timestamp when creating the server. Once expired, Truto automatically cleans up the token from the database and edge KV storage, immediately revoking the LLM's access. Ideal for temporary contractor access or limited-time audit bots.

## Architecting for Hotjar Rate Limits

When writing automated scripts against APIs, engineers rely on SDKs to handle rate limits. In an AI agent context, the LLM is driving the execution, which changes how rate limits must be managed.

*Factual note on rate limits:* Truto does not automatically retry, throttle, or absorb rate limit errors on your behalf. When the upstream Hotjar API hits its limit and returns an HTTP 429 status code, Truto passes that 429 error directly back to the caller (your MCP client/agent).

To help your agents understand and recover from these errors, Truto normalizes the upstream rate limit information into standard IETF headers:
*   `ratelimit-limit`: The total requests allowed in the current window.
*   `ratelimit-remaining`: The number of requests left.
*   `ratelimit-reset`: The timestamp when the limit resets.

Because the MCP protocol returns errors directly to the model as text, an advanced LLM like ChatGPT or Claude will actually read the error message, notice the `ratelimit-reset` window, and can be prompted to wait and retry its tool call automatically. The responsibility for retry and backoff logic remains firmly with the caller.

## Moving Forward

Connecting Hotjar to ChatGPT via MCP transforms static user feedback into an interactive, conversational dataset. Instead of forcing product managers and researchers to manually compile CSVs and run complex VLOOKUPs, you can empower them to query user sentiment and execute privacy tasks using natural language.

By leveraging Truto to generate and manage your MCP servers, you eliminate the need to write custom integration code, handle OAuth refreshes, or manually map paginated JSON schemas. You get secure, documented tools delivered directly to your AI agents.

Ready to give your AI agents direct access to Hotjar data? Connect your accounts and generate an MCP server in minutes.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)