---
title: "Connect LearnWorlds to ChatGPT: Manage Users and Group Activity"
slug: connect-learnworlds-to-chatgpt-manage-users-and-group-activity
date: 2026-06-09
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to build a managed MCP server to connect LearnWorlds to ChatGPT. Automate user auditing, group enrollment tracking, and role management with AI."
tldr: "Connect LearnWorlds to ChatGPT using Truto's managed MCP server. This guide covers how to bypass LearnWorlds API quirks, configure an MCP server via UI or API, and execute complex workflows like tracking group managers and user NPS scores using natural language."
canonical: https://truto.one/blog/connect-learnworlds-to-chatgpt-manage-users-and-group-activity/
---

# Connect LearnWorlds to ChatGPT: Manage Users and Group Activity


If you are managing an educational platform, tracking user progress, auditing cohort enrollments, and checking customer sentiment across groups is a manually intensive process. You want to connect LearnWorlds to ChatGPT so your AI agents can read user data, audit access roles, and summarize group activity using natural language. If your team uses Claude instead, check out our guide on [connecting LearnWorlds to Claude](https://truto.one/connect-learnworlds-to-claude-administer-user-roles-and-groups/) or explore our broader architectural overview on [connecting LearnWorlds to AI Agents](https://truto.one/connect-learnworlds-to-ai-agents-automate-user-and-group-data/).

Giving a Large Language Model (LLM) read and write access to your LearnWorlds instance is an engineering challenge. You either spend weeks building, hosting, and maintaining a custom [Model Context Protocol (MCP) server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/), or you use a managed infrastructure layer that handles the boilerplate for you. This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for LearnWorlds, connect it natively to ChatGPT, and execute complex workflows.

## The Engineering Reality of the LearnWorlds API

A custom MCP server is a self-hosted integration layer that translates an LLM's tool calls into REST API requests. While the open [MCP standard](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/) 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 LearnWorlds, you are responsible for the entire API lifecycle.

Here are the specific integration challenges that break standard REST assumptions when working with the LearnWorlds API:

### The Meta Pagination Object
When an LLM requests a list of users or groups, it cannot ingest 10,000 records at once. LearnWorlds handles pagination by returning a nested `meta` object containing `totalPages`, `currentPage`, `itemsPerPage`, and `totalItems`. An LLM does not inherently know how to increment a numeric page counter correctly across large datasets. Your MCP server has to inject strict descriptions into the JSON schema, explicitly instructing the LLM to read the `meta.currentPage` value from the previous response, increment it, and pass it back in the subsequent query payload. If your schema does not define this strictly, the model will hallucinate offsets and skip records.

### Deeply Nested Group Architectures
LearnWorlds groups are complex entities. When querying groups, the API returns deeply nested arrays for `group_managers` (which includes internal user IDs, usernames, and role details) and `products` (which maps to enrolled courses). If you expose the raw LearnWorlds group endpoint to ChatGPT without explicitly mapped JSON schemas, the LLM will struggle to distinguish between a group manager and a standard user enrolled in the group's courses. Your MCP server must derive and enforce highly structured schemas for these nested resources so the LLM knows exactly what fields to extract.

### Strict Rate Limits and 429 Handling
LearnWorlds enforces strict rate limiting. If an AI agent attempts to run a heavy data extraction workflow - like iterating over every user in a 5,000 - member cohort - it will quickly exhaust the API quota. Truto does not retry, throttle, or apply backoff on rate limit errors. When the LearnWorlds API returns an HTTP 429 Too Many Requests error, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized HTTP headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. Your client (ChatGPT or your custom AI agent) is fully responsible for reading these headers and executing the appropriate retry or exponential backoff logic.

## Creating the LearnWorlds MCP Server

Instead of building a proxy layer from scratch, Truto dynamically derives tool definitions from LearnWorlds API documentation and your connected tenant account. A single URL serves as the fully authenticated JSON-RPC 2.0 endpoint.

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

### Method 1: Via the Truto UI

This is the fastest method for internal operational teams.

1. Navigate to the integrated account page for your LearnWorlds connection in the Truto dashboard.
2. Click the **MCP Servers** tab.
3. Click **Create MCP Server**.
4. Define your configuration. You can filter the server to only allow `read` operations or restrict it to specific tags (e.g., `users`, `groups`).
5. Click Save and copy the generated MCP server URL (it will look like `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For platform engineering teams deploying AI agents dynamically, you can generate an MCP server programmatically. Truto validates the configuration, generates a cryptographically hashed token, stores it in distributed state, and returns a ready-to-use URL.

**Endpoint:** `POST /integrated-account/:id/mcp`

```typescript
// Example: Creating a Read-Only LearnWorlds MCP Server
const response = await fetch('https://api.truto.one/integrated-account/lw_acc_88493/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_TOKEN',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "LearnWorlds User Audit MCP",
    config: {
      methods: ["read"], // Restricts the LLM to GET/LIST requests
      tags: ["users", "groups"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const mcpServer = await response.json();
console.log(mcpServer.url); 
// "https://api.truto.one/mcp/a1b2c3d4e5f6..."
```

This URL is entirely self-contained. It encodes the tenant routing, the LearnWorlds authentication tokens, and the JSON schemas for the exposed tools.

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you need to register it as a [tool provider for your LLM](https://truto.one/bring-100-custom-connectors-to-chatgpt-with-superai-by-truto/). ChatGPT and other agents use this URL to discover the available LearnWorlds endpoints during the initialization handshake.

### Method A: Via the ChatGPT UI

If you are using ChatGPT Plus, Team, or Enterprise, you can connect the server directly in the client.

1. Open ChatGPT and navigate to **Settings → Apps → Advanced settings**.
2. Enable **Developer mode**.
3. Under MCP servers / Custom connectors, click **Add new server**.
4. **Name:** "LearnWorlds Admin"
5. **Server URL:** Paste the Truto MCP URL.
6. Save the configuration. ChatGPT will immediately connect, perform the JSON-RPC initialization, and load the LearnWorlds tools.

### Method B: Via Manual Config File (SSE Transport)

If you are running a local agent, Claude Desktop, or a custom LangChain/LangGraph architecture, you can define the MCP server using a standard JSON configuration file. Truto's MCP servers communicate over HTTP POST (Server-Sent Events proxying JSON-RPC).

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

## LearnWorlds Hero Tools

Truto exposes integration endpoints as highly structured tools. Instead of forcing the LLM to construct complex REST queries, Truto provides precise query and body schemas derived from the LearnWorlds documentation. Here are the highest-leverage tools available for LearnWorlds management.

### list_all_learn_worlds_users

This tool retrieves the complete directory of users in your LearnWorlds instance. It returns an array of user objects containing fields like `id`, `email`, `username`, `created`, `last_login`, `role`, `tags`, and `status`. Crucially, it handles the metadata required for iterating through large student populations.

> "Fetch the first page of users in LearnWorlds. I need to see their email addresses, tags, and account status to determine who has logged in recently."

### get_single_learn_worlds_user_by_id

When you need granular details about a specific student or administrator, this tool extracts the complete profile based on the user's `id`. The response includes account status booleans (`is_admin`, `is_instructor`, `is_suspended`), `billing_info`, `utms`, tracking `tags`, and customer sentiment metrics like `nps_score` and `nps_comment`.

> "Look up the user profile for ID 'usr_5592'. Check their billing info, verify if they are suspended, and summarize their latest NPS comment."

### list_all_learn_worlds_roles

This tool retrieves all configured user roles within the platform. It returns the `id`, `title`, `description`, `access_level`, and `custom_role` boolean for each role. This is critical for security audits, allowing the LLM to cross-reference a user's assigned role against the actual permissions that role grants.

> "List all the user roles currently active in LearnWorlds. Highlight any custom roles and explain their access levels."

### list_all_learn_worlds_groups

Groups in LearnWorlds map to cohorts, B2B clients, or internal teams. This tool lists every group, returning the `id`, `title`, `description`, course `products`, `enroll_users_on_courses` flags, `group_managers`, and modification timestamps.

> "Show me all the user groups in our LearnWorlds instance. I want to see which groups automatically enroll users into courses when they join."

### get_single_learn_worlds_group_by_id

To audit a specific cohort, this tool pulls the deep nested schema of a single group. It extracts the `products` array (the courses the group has access to) and the `group_managers` array (detailing the ID, username, email, and role_id of the staff managing the cohort).

> "Retrieve the full details for the group with ID 'grp_104'. List the exact courses assigned to this group and tell me the email addresses of the group managers."

For the complete inventory of available operations, including write methods and custom resources, visit the [LearnWorlds integration page](https://truto.one/integrations/detail/learnworlds).

## Workflows in Action

By connecting these tools to ChatGPT, IT administrators and Customer Success Managers can execute complex, multi-step queries that would normally require manual CSV exports and VLOOKUPs.

### Scenario 1: Auditing Group Managers and Enrolled Courses
**Persona:** EdTech IT Administrator

> "Find the 'Enterprise Cohort Q3' group in LearnWorlds. Tell me who manages it, and list the specific courses they are automatically enrolled in."

1. **`list_all_learn_worlds_groups`:** ChatGPT calls this tool to retrieve the directory of groups. It scans the response to locate the ID for the group titled "Enterprise Cohort Q3".
2. **`get_single_learn_worlds_group_by_id`:** Using the discovered group ID, ChatGPT fetches the deep profile of the cohort. It parses the nested `group_managers` array to extract the administrative emails, and maps the `products` array to list the active courses.
3. **Result:** The LLM outputs a clean summary: *"The 'Enterprise Cohort Q3' group (ID: grp_882) is managed by admin@example.com. Members are automatically enrolled in 'Advanced System Design' and 'Security Fundamentals'."*

### Scenario 2: VIP User Sentiment & Role Audit
**Persona:** Customer Success Manager

> "Look up LearnWorlds user ID 'usr_90210'. I need their NPS score, billing info, and current system role to see if they qualify for the admin upgrade."

1. **`get_single_learn_worlds_user_by_id`:** ChatGPT queries the specific user ID. It extracts the `nps_score`, `billing_info`, and `role` fields from the extensive JSON response.
2. **`list_all_learn_worlds_roles`:** If the user's role ID is opaque (e.g., 'rl_44'), ChatGPT proactively calls the roles tool to match the ID against the human-readable title and `access_level`.
3. **Result:** The LLM responds: *"User usr_90210 has an NPS score of 9 ('Great platform!'). They are currently on the 'Pro Annual' billing tier. Their current role is 'Standard Student' (access_level: 1). To qualify for the admin upgrade, their role must be changed to 'Instructor'."*

## Security and Access Control

Exposing an educational platform to an AI model requires strict governance. Truto's [MCP architecture](https://truto.one/mcp-buyers-checklist-and-quick-start-guide-for-b2b-saas-2026/) provides several layers of access control out of the box:

*   **Method Filtering:** You can restrict the MCP server config to `methods: ["read"]`. This prevents ChatGPT from accidentally deleting courses, suspending users, or modifying cohort settings, limiting it to GET and LIST requests.
*   **Tag Filtering:** By configuring `tags: ["users", "groups"]`, the server will completely hide unrelated integration endpoints (like webhooks or site settings) from the LLM's context window, reducing hallucination risk.
*   **`require_api_token_auth`:** For high-security environments, you can enable this flag. It forces the connecting MCP client to provide a valid Truto API token in the Authorization header, ensuring that simply possessing the MCP URL is not enough to access the LearnWorlds tools.
*   **`expires_at`:** You can assign an ISO datetime to the server. Truto's distributed cleanup system will automatically revoke the token and destroy the MCP endpoint at the specified time, perfect for granting temporary auditing access to external contractors.

## Wrapping Up

Automating LearnWorlds operations through ChatGPT eliminates the manual overhead of traversing nested menus to audit student roles and cohort managers. However, building the necessary MCP infrastructure to handle LearnWorlds's specific pagination logic, nested group architectures, and rate limits is a massive engineering distraction.

Truto abstracts this away. By normalizing the documentation into strict JSON schemas and providing a managed JSON-RPC layer, you can give your AI agents safe, structured access to LearnWorlds in minutes instead of months.

> Stop burning engineering cycles on custom MCP servers and rate limit handling. Partner with Truto to instantly connect your AI agents to LearnWorlds and 100+ other B2B platforms.
>
> [Talk to us](https://cal.com/truto/partner-with-truto)