---
title: "Connect 360learning to Claude: Manage users, groups, and skills"
slug: connect-360learning-to-claude-manage-users-groups-and-skills
date: 2026-09-04
author: Nachi Raman
categories: ["AI & Agents"]
excerpt: "Learn how to build and deploy a managed MCP server to connect 360learning to Claude. Automate LMS user onboarding, group management, and skill tracking."
tldr: "Connect 360learning to Claude using Truto's managed MCP server. This guide details how to generate MCP tools from the 360learning API, configure Claude Desktop, and automate LMS workflows."
canonical: https://truto.one/blog/connect-360learning-to-claude-manage-users-groups-and-skills/
---

# Connect 360learning to Claude: Manage users, groups, and skills


If your team needs to connect 360learning to Claude to automate employee onboarding, manage learning paths, track skill acquisitions, or orchestrate group permissions, 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 Claude's LLM function calls and 360learning'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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/). 

If your team uses ChatGPT, check out our guide on [connecting 360learning to ChatGPT](https://truto.one/connect-360learning-to-chatgpt-build-courses-and-track-learners/) or explore our broader architectural overview on [connecting 360learning to AI Agents](https://truto.one/connect-360learning-to-ai-agents-automate-enrollment-and-certs/).

Giving a Large Language Model (LLM) read and write access to an enterprise Learning Management System (LMS) like 360learning requires handling intricate domain hierarchies. You have to navigate the relationship between users, groups, skills, and path sessions while managing strict API rate limits and asynchronous bulk processing jobs. Every time 360learning deprecates a V1 resource or introduces a new external ID mapping schema, you have to update your custom integration code.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for 360learning, connect it natively to Claude Desktop, and execute complex LMS management workflows using natural language.

> Want to give your AI agents secure, authenticated access to 360learning and 100+ other SaaS APIs? Let's talk about [managed MCP architecture](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/).
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the 360learning API

A custom MCP server is a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover and execute tools, the reality of implementing it against specialized B2B APIs is painful. 360learning is built to manage massive distributed teams, external training catalogs, and complex skill matrices. Its API architecture reflects this scale.

If you decide to build a custom MCP server for 360learning, here are the specific integration challenges you will face:

**Asynchronous Bulk Operations and Polling**
360learning handles massive data updates - like importing 10,000 user jobs or syncing thousands of group catalogs - using asynchronous bulk endpoints. When you call an endpoint like `POST /skills/jobs/bulk`, the API does not return a synchronous success. It returns an HTTP 202 Accepted response containing a `Location` header URL. To know if the operation succeeded, your integration must parse that header, extract the bulk operation ID, and continuously poll the `/bulk-operations/{id}` endpoint. A standard LLM does not inherently understand this pattern. Your MCP server must expose specific tools to initiate the job and distinct tools to check the job status, while instructing the agent on how to chain them together.

**Hierarchical Group Roles and Visibility**
In 360learning, permissions are intrinsically tied to Group hierarchies. Adding a user to a group is not a simple boolean flag. You must assign them a specific role (e.g., `admin`, `analyst`, `coach`, `learner`). Furthermore, removing the `learner` role from a user in a parent group automatically triggers a cascading deletion down to all public subgroups until it hits a private excluded group. If your AI agent arbitrarily adds or removes roles without understanding this cascade, it can accidentally revoke access to hundreds of courses across an entire organizational tree.

**Rate Limits and 429 Handling**
360learning enforces specific rate limits depending on the resource. For example, updating native courses might have higher throughput allowances, while updating eLearning standards (SCORM, AICC) is strictly limited to 1 request per second. **Factual note on rate limits:** Truto does not retry, throttle, or apply backoff on rate limit errors. When 360learning returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes upstream rate limit info into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF spec. The AI agent or calling framework is strictly responsible for implementing its own retry and backoff logic when these headers are encountered.

## Creating the 360learning MCP Server

Instead of writing custom JSON-RPC middleware, building authentication state machines, and manually mapping 360learning's API documentation into JSON Schema for Claude, you can use Truto to generate a [hosted MCP server URL](https://truto.one/what-is-mcp-and-mcp-servers-and-how-do-they-work/).

[Truto derives MCP tools dynamically](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) from the 360learning integration's API resources and documentation records. A tool only appears in the MCP server if it has a corresponding documentation entry, ensuring the LLM receives high-quality descriptions and accurate property schemas. You can generate the server in two ways.

### Method 1: Via the Truto UI

1. Navigate to the **Integrated Accounts** page in your Truto dashboard.
2. Select your connected 360learning account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select the desired configuration. For example, you can restrict the server to only `read` methods if you want Claude to function strictly as a reporting assistant.
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the Truto API

For platform teams looking to automate infrastructure provisioning, you can generate MCP servers programmatically using the Truto REST API.

```bash
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": "360learning Claude Server",
    "config": {
      "methods": ["read", "write", "custom"]
    }
  }'
```

The Truto API will validate that the 360learning connection is active, generate a cryptographically secure token, hash it for storage, and return a payload containing your server URL:

```json
{
  "id": "abc-123",
  "name": "360learning Claude Server",
  "config": { "methods": ["read", "write", "custom"] },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

## Connecting the MCP Server to Claude

Once you have your Truto MCP URL, you can connect it to Claude. Because Truto handles the OAuth token lifecycle and normalizes the 360learning API schema, the URL is entirely self-contained.

### Method 1: Via the Claude UI

If you are using Claude's enterprise or team web interfaces, you can add the server directly through the UI settings.

1. Open Claude and navigate to **Settings**.
2. Select **Integrations** (or **Connectors** depending on your plan tier).
3. Click **Add MCP Server**.
4. Provide a descriptive name (e.g., "360learning LMS").
5. Paste the Truto MCP URL into the connection field.
6. Click **Add**.

Claude will immediately ping the server's `initialize` endpoint, verify protocol compatibility, and fetch the available 360learning tools via the `tools/list` RPC method.

### Method 2: Via Manual Config File

If you are using Claude Desktop for local AI agent development, you can register the MCP server by modifying the application's JSON configuration file. Truto provides an NPM package (`@modelcontextprotocol/server-sse`) that acts as a proxy transport to handle Server-Sent Events (SSE) connections to remote MCP URLs.

Open your Claude Desktop configuration file:
- macOS: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Windows: `%APPDATA%\Claude\claude_desktop_config.json`

Add the Truto server configuration under the `mcpServers` object:

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

Restart Claude Desktop. The application will execute the proxy, connect to Truto, and load the 360learning tools.

## Hero Tools for 360learning

Truto exposes over 100 specific endpoints from the 360learning API as MCP tools. Below are 7 high-leverage hero tools that transform how AI agents interact with your LMS. 

### `list_all_360_learning_users`
Retrieves a paginated list of users in the platform. You can filter this list by email, username, or status to locate specific employees before taking administrative action on their accounts.

> "Find the user record for jane.doe@company.com and tell me her current status and primary group ID."

### `create_a_360_learning_user`
Provisions a new invited user in 360learning. If an employee with the provided email previously existed but was deleted, this tool restores their account back to an invited state.

> "Onboard john.smith@company.com into the engineering team group as a new user."

### `360_learning_groups_add_user_role`
Assigns a specific RBAC role to a user within a target group. Acceptable roles include `admin`, `analyst`, `coach`, `contributor`, `editor`, `learner`, and `user-admin`.

> "Grant the 'coach' role to Jane Doe in the Sales Enablement group (group ID: 5f9b3b...)."

### `create_a_360_learning_path_session`
Creates a new session for a learning path, defining start and end dates. This is a prerequisite before you can enroll users (via `create_a_360_learning_classroom_slot_registration`) into structured curriculum delivery.

> "Create a new path session for the 'Q3 Compliance Training' path starting next Monday and ending in 30 days."

### `list_all_360_learning_skills`
Retrieves all defined skills in your 360learning platform. This tool allows the AI agent to audit your taxonomy, searching for specific tags or competencies before associating them with jobs or users.

> "List the available skills in the platform. Are there any existing skills tagged for 'Cybersecurity' or 'Data Privacy'?"

### `create_a_360_learning_courses_generate_from_prompt`
Triggers 360learning's internal asynchronous course generation engine. You pass a text prompt outlining the course topic, and the API begins building an LMS course in the background, sending an email when complete.

> "Generate a new 360learning course from the following prompt: 'A comprehensive guide to handling customer escalations in B2B SaaS support environments.' Assign it to my user ID."

### `get_single_360_learning_bulk_operation_by_id`
Checks the status of a queued bulk operation (e.g., bulk skill updates, bulk enrollment). Because 360learning processes large payloads asynchronously, agents use this tool to poll the API until the job resolves to a success or error state.

> "Check the status of bulk operation ID 60a1f2b3... Let me know if the job is still processing or if it encountered errors."

For a complete list of available resources, property schemas, and required parameters, review the [Truto 360learning Integration Page](https://truto.one/integrations/detail/360learning).

## Workflows in Action

When Claude has direct access to 360learning through Truto, you can orchestrate complex, multi-step administrative workflows using natural language. Here are two examples of how this architecture behaves in production.

### Scenario 1: Automated Employee Onboarding & Path Assignment

IT and HR administrators spend hours provisioning new hires in the LMS and ensuring they are assigned the correct compliance training based on their department.

> "We just hired Alex Chen as a new software engineer. Create a 360learning user for alex.chen@example.com, add him to the 'Engineering' group as a learner, and enroll him in the mandatory 'Information Security V2' path session."

**How the agent executes this:**
1.  **`list_all_360_learning_groups`**: The agent searches the group directory to find the ID for the "Engineering" group.
2.  **`list_all_360_learning_paths_sessions`**: The agent searches for the active session ID associated with the "Information Security V2" path.
3.  **`create_a_360_learning_user`**: The agent provisions Alex's account and retrieves his newly generated `userId`.
4.  **`360_learning_groups_add_user_role`**: The agent assigns Alex's `userId` to the Engineering group with the `learner` role.
5.  **`create_a_360_learning_classroom_slot_registration`**: The agent registers Alex into the required path session.

**What the user gets back:** Claude responds confirming the user was created, listing the specific Group ID and Session ID used, and confirming that the enrollment was successful.

### Scenario 2: Async Bulk Operations & Polling

When organizations update their internal job matrices, they often need to bulk-update hundreds of users' job roles and associated skills. This requires navigating 360learning's asynchronous bulk endpoints.

> "We need to update the job mappings for our sales team. Push this list of 50 external job IDs to the 360learning bulk jobs update endpoint, and wait to confirm the operation succeeds before proceeding."

```mermaid
sequenceDiagram
  participant Claude as Claude Desktop
  participant Truto as Truto MCP Router
  participant Upstream as 360learning API

  Claude->>Truto: Call 360_learning_users_jobs_bulk_update
  Truto->>Upstream: POST /users/jobs/bulk
  Upstream-->>Truto: HTTP 202 Accepted (Location Header)
  Truto-->>Claude: Bulk Operation Queued (ID: 8a7b6c)

  Claude->>Truto: Call get_single_360_learning_bulk_operation_by_id
  Truto->>Upstream: GET /bulk-operations/8a7b6c
  Upstream-->>Truto: HTTP 200 (Status: Processing)
  Truto-->>Claude: Status: Processing
  
  Note over Claude, Truto: Agent waits and retries...
  
  Claude->>Truto: Call get_single_360_learning_bulk_operation_by_id
  Truto->>Upstream: GET /bulk-operations/8a7b6c
  Upstream-->>Truto: HTTP 200 (Status: Completed)
  Truto-->>Claude: Status: Completed
```

**How the agent executes this:**
1.  **`360_learning_users_jobs_bulk_update`**: The agent sends the payload. Truto proxies this to 360learning, receives a 202 response, extracts the operation ID from the Location header, and returns it to Claude.
2.  **`get_single_360_learning_bulk_operation_by_id`**: Claude calls this tool to poll the status. If it returns "processing", the agent autonomously waits.
3.  **`get_single_360_learning_bulk_operation_by_id`**: Claude polls again until it receives a success confirmation.

**What the user gets back:** Claude confirms that the bulk job was successfully submitted, tracked, and completed, providing a summary of the operation execution time.

## [Security and Access Control](https://truto.one/how-do-mcp-servers-handle-data-retention-and-security-for-ai-agents/)

Giving AI models access to corporate LMS environments requires strict governance. Truto's MCP architecture enforces security at the infrastructure layer, preventing prompt injection attacks from exfiltrating or destroying learning data.

*   **Zero Data Retention:** Truto's proxy layer never stores the payload data from 360learning. Data flows directly from the integrated account to the MCP client (e.g., Claude) in memory. No LMS training records or user PII touch a database.
*   **Method Filtering:** When generating the MCP server URL, administrators can define a `config.methods` array (e.g., `["read"]`). This filters out write operations at the source. If Claude attempts to delete a course, the MCP router rejects the call before it ever reaches 360learning.
*   **Tag Filtering:** Integrations in Truto support conceptual tagging. You can configure an MCP server with `config.tags` set to `["users"]` or `["skills"]`, restricting the available tools to specific domain areas and ignoring administrative routing resources.
*   **Token Expiration:** You can provision temporary server URLs by passing an `expires_at` timestamp. Once the expiration is hit, Truto's durable objects automatically purge the server routing logic, rendering the URL inert.
*   **Additional API Authentication:** For enterprise environments, administrators can set `require_api_token_auth: true`. This forces the MCP client to pass a valid Truto API token in the Authorization header. Without it, possessing the URL alone is insufficient to execute tool calls.

## Next Steps for LMS Automation

Integrating AI agents with 360learning unlocks powerful capabilities for HR, L&D, and IT teams. Instead of manually traversing complex LMS interfaces to assign roles, enroll users, or audit skill gaps, your team can orchestrate the entire platform conversationally.

Truto handles the heavy lifting of the MCP architecture. We manage the OAuth lifecycle, map the dynamic schemas, normalize the 360learning bulk polling mechanics, and expose everything as clean, AI-ready tools over a secure JSON-RPC interface.

If you need to connect Claude, ChatGPT, or custom AI agents to 360learning alongside other critical B2B systems like Salesforce, Workday, or ServiceNow, you need a managed integration strategy.

> Ready to give your AI agents secure, authenticated access to 360learning? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)