Connect 360learning to ChatGPT: Build courses and track learners

If you need to connect 360learning to ChatGPT to automate headless learning management workflows, orchestrate user training paths, or extract skills analytics, you need a Model Context Protocol (MCP) server. This infrastructure layer translates ChatGPT's native LLM tool calls into 360learning's specific REST API payloads. You can either build, host, and maintain this translation layer yourself, 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 /connect-360learning-to-claude-manage-users-groups-and-skills/, or explore our broader architectural overview on /connect-360learning-to-ai-agents-automate-enrollment-and-certs/.

Giving a Large Language Model (LLM) direct read and write access to a complex Learning Management System (LMS) like 360learning is an engineering hurdle. The platform relies heavily on asynchronous processing for bulk data, strict identifier formatting, and complex pagination. Hardcoding these rules into a custom MCP server means you inherit the maintenance debt every time the API evolves.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for 360learning, connect it natively to ChatGPT, and execute complex Learning and Development (L&D) workflows using natural language.

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::

The Engineering Reality of the 360learning API

A custom MCP server is essentially a self-hosted integration layer. While the open MCP standard provides a predictable way for models to discover tools, implementing it against 360learning's highly specific API architecture is painful.

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

Asynchronous Bulk Operations and the 202 Polling Trap

Unlike simple REST APIs where a POST returns the created object, 360learning relies heavily on asynchronous processing for scale. Operations like 360_learning_groups_memberships_bulk_create or 360_learning_skills_jobs_bulk_update (which handle up to 20,000 objects at once) do not return data immediately. Instead, they return an HTTP 202 Accepted response with no body. The only tracking mechanism is a Location header containing a URL to poll for the operation's status.

LLMs are inherently synchronous in their tool execution loops. If you map a bulk tool directly, ChatGPT will assume the task is finished the moment it receives the 202. Your MCP server must expose both the trigger endpoint and the specific list_all_360_learning_operation_results endpoint, and you must explicitly prompt the LLM to extract the bulk_operation_id from the headers and enter a polling loop.

Strict ObjectId Validations

Most SaaS APIs use integers or simple UUIDs for primary keys. 360learning relies strictly on 24-character hexadecimal ObjectId strings (e.g., 507f1f77bcf86cd799439011). If an LLM hallucinates a standard integer ID for a course_id or group_id, the API will immediately reject it with a 400 Bad Request rather than a standard 404 Not Found. Your tool schemas must rigidly define the required string format to guide the LLM's parameter generation.

LHS Bracket Notation Filtering

Many 360learning listing endpoints use Left-Hand Side (LHS) bracket notation for advanced filtering (e.g., ?createdAt [gt]=2025-01-01 or ?status [in]=active,pending). This is not a standard OpenAPI query parameter structure. If your MCP server cannot parse and map standard LLM JSON arguments into deeply nested bracket-notation query strings, your agent will be unable to filter results, forcing it to fetch maximum page sizes and burn through your token limits.

Generating a 360learning MCP Server

Truto dynamically generates MCP tools based on 360learning's API documentation and your environment's specific configurations. You can spin up an MCP server scoped to a single 360learning account in seconds.

Method 1: Creating the MCP Server via the Truto UI

For quick prototyping or manual deployment, you can generate the server directly from the dashboard.

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 your desired configuration (e.g., name the server "ChatGPT 360learning L&D", filter to specific methods or tags).
6. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4e5f6...). Treat this URL as a secure credential.

Method 2: Creating the MCP Server via the API

For production workflows, you should dynamically provision MCP servers for your end-users programmatically. This ensures you can scope access precisely when an agent session begins.

Make a POST request to the /integrated-account/:id/mcp endpoint:

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": "ChatGPT L&D Agent Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["users", "courses", "paths", "skills"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API responds with a secure URL carrying an encrypted token that routes traffic directly to that specific 360learning instance.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT. You can do this natively in the ChatGPT interface or via a manual configuration file if you are running a custom agent framework.

Method A: Via the ChatGPT UI

If you are on a ChatGPT Pro, Plus, Business, Enterprise, or Education plan with Developer mode enabled:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode on.
3. Under MCP servers / Custom connectors, click to add a new server.
4. Name: "360learning L&D"
5. Server URL: Paste your Truto MCP URL.
6. Click Add.

ChatGPT will immediately handshake with the Truto MCP server, run a tools/list protocol command, and populate its context window with the available 360learning endpoints.

Method B: Via Manual Config File (SSE Transport)

If you are wrapping ChatGPT in a custom environment (like an orchestration layer or a desktop client supporting MCP), you can configure it using the standard Server-Sent Events (SSE) proxy command. Truto provides an official NPM package to handle the SSE bridge.

Create a configuration JSON file:

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

360learning Hero Tools for ChatGPT

Truto provides comprehensive coverage of the 360learning API. For this guide, we will focus on six high-leverage "hero" tools that unlock complex L&D workflows.

create_a_360_learning_user

Provisions a new learner in the LMS. If a previously deleted user with the same email exists, this tool automatically restores their account to an invited status.

Contextual note: You must provide at least an email or a username. The API expects standard string formats.

"Onboard our new engineering hire, Jane Doe (jane.doe@example.com), into 360learning. Please return her unique user ID once the account is created."

list_all_360_learning_courses

Retrieves the catalog of available courses. It supports filtering by status, type, author, tags, and source language.

Contextual note: This endpoint returns up to 500 courses per page. Instruct ChatGPT to look out for next_cursor in the response if a broader search is required.

"Search the 360learning catalog for all active courses tagged with 'compliance' and 'security'. List their IDs and creation dates."

create_a_360_learning_path_session

Deploys a specific learning path to a group by creating a session with defined start and end dates.

Contextual note: Requires the path_id as a 24-character ObjectId.

"Create a new path session for the '2026 Q1 Security Training' path (ID: 507f1f77bcf86cd799439011). Set the start date for tomorrow and the end date for exactly 30 days from now."

create_a_360_learning_classroom_slot_registration

Enrolls a specific user into a live, synchronous classroom slot.

Contextual note: The user must already be enrolled in the path session that houses this classroom slot, and the slot cannot be full. Requires both classroom_slot_id and user_id.

"Register Jane Doe (User ID: 612f1f77bcf86cd799439abc) into the morning classroom slot (Slot ID: 812f1f77bcf86cd799439def) for the upcoming leadership workshop."

360_learning_skills_reviews_bulk_create

Submits an asynchronous batch of skill assessments. This is critical for bulk-updating learner progress after an external performance review cycle.

Contextual note: This is an asynchronous endpoint. It returns a 202 Accepted response. The LLM must be instructed to catch the response and follow up.

"Submit a bulk skill review marking the 'Advanced React' skill as validated for the following five user IDs... Once submitted, tell me you have initiated the background job."

list_all_360_learning_operation_results

Retrieves the success and error logs for an asynchronous bulk operation, such as bulk skill reviews or mass enrollments.

Contextual note: Requires the bulk_operation_id. If called too early, it will return a 400 error indicating the operation hasn't run yet. The agent should be prompted to wait and retry.

"Check the operation results for bulk job ID '999f1f77bcf86cd799439xyz'. If it's done, list any users whose skill assessments failed."

For the complete inventory of available 360learning endpoints, schemas, and required parameters, visit the 360learning integration page.

Workflows in Action

By chaining these tools together, ChatGPT can execute multi-step L&D workflows autonomously.

Scenario 1: Automated Employee Onboarding & Compliance Training

When HR signals a new hire, an IT administrator can ask ChatGPT to handle the entire 360learning provisioning lifecycle in a single prompt.

"We just hired Alex Smith (alex.smith@example.com). Create a 360learning user account for him. Then, search the course catalog for the mandatory '2026 InfoSec Basics' course. Finally, enroll him in the next available path session for that course and confirm when he is ready to start."

Execution Steps:

1. create_a_360_learning_user: The agent generates the user profile and extracts Alex's newly minted 24-character user_id.
2. list_all_360_learning_courses: The agent searches for the keyword 'InfoSec Basics' to locate the exact course_id.
3. list_all_360_learning_paths_sessions: The agent queries active sessions associated with that course/path to find an open timeframe.
4. create_a_360_learning_classroom_slot_registration: Using the user_id and the identified session_id/slot_id, the agent registers Alex and reports back to the administrator with confirmation.

Scenario 2: Orchestrating Asynchronous Skills Assessment

Because 360learning handles bulk data asynchronously, you must instruct the LLM on how to navigate the polling loop.

"I have a list of 50 user IDs who just passed their external AWS certification. Submit a bulk skill review to validate the 'AWS Cloud Practitioner' skill for all of them. Poll the operation results until it finishes, and let me know if any assessments failed."

Execution Steps:

sequenceDiagram
    participant Admin as User (Admin)
    participant LLM as ChatGPT
    participant Truto as Truto MCP
    participant Upstream as 360learning API

    Admin->>LLM: Prompt: Bulk validate AWS skills & poll results
    LLM->>Truto: Call 360_learning_skills_reviews_bulk_create (50 users)
    Truto->>Upstream: POST /api/v2/skills/reviews
    Upstream-->>Truto: 202 Accepted (Location: /bulkOperations/123ab/results)
    Truto-->>LLM: Response containing bulk_operation_id: 123ab
    
    loop Polling
        LLM->>Truto: Call list_all_360_learning_operation_results (123ab)
        Truto->>Upstream: GET /api/v2/bulkOperations/123ab/results
        Upstream-->>Truto: 400 Bad Request (Not finished yet)
        Truto-->>LLM: Error: Operation pending
        Note over LLM: LLM waits (backoff) and retries
    end
    
    LLM->>Truto: Call list_all_360_learning_operation_results (123ab)
    Truto->>Upstream: GET /api/v2/bulkOperations/123ab/results
    Upstream-->>Truto: 200 OK (Array of successes/errors)
    Truto-->>LLM: JSON array of operation results
    LLM-->>Admin: Natural language summary of failures

1. 360_learning_skills_reviews_bulk_create: The agent submits the batch payload. It reads the resulting 202 payload to extract the operation ID.
2. list_all_360_learning_operation_results: The agent queries the results endpoint. If it receives an error indicating the job is pending, its internal logic dictates a brief pause before retrying.
3. Result Analysis: Once a 200 OK is returned, the agent parses the array of success/error objects and formats a human-readable summary for the user.

Security and Access Control

Handing an LLM keys to your learning management system requires strict governance. Truto's MCP servers provide infrastructure-level controls to limit what the agent can do:

• Method Filtering: When generating the server, specify config.methods: ["read"] to instantly strip all POST, PUT, and DELETE tools. The LLM will only be aware of reporting and listing tools.
• Tag Filtering: Restrict the agent's scope to specific functional areas using config.tags: ["users", "skills"]. Tools related to billing, external integrations, or global platform settings simply won't exist in the context window.
• Required API Authentication: Set require_api_token_auth: true to enforce secondary authentication. Even if someone intercepts the MCP URL, they cannot use it without a valid Truto session or API token.
• Automatic Expiration: Use expires_at to grant temporary access. If you are hiring a contractor to audit your courses using ChatGPT, generate a server that self-destructs at the end of the week.

A Note on Rate Limits

When connecting highly autonomous agents to 360learning, it is easy to trigger API rate limits. It is important to know that Truto does not automatically retry, throttle, or apply backoff to rate-limited requests.

When the 360learning API returns an HTTP 429 (Too Many Requests), Truto passes that error directly back to the calling agent. Truto strictly normalizes the upstream rate limit information into standard IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller - in this case, ChatGPT or your custom agent orchestration framework - is entirely responsible for reading these headers, waiting for the reset window, and implementing its own retry and backoff logic.

Stop Building Boilerplate L&D Integrations

Connecting ChatGPT to 360learning opens up massive operational efficiencies for HR and L&D teams - from automated onboarding and skill tracking to dynamic course deployments. But building and maintaining the bespoke middleware to translate LLM intent into strict 360learning ObjectIds and async polling loops is a waste of engineering cycles.

By leveraging Truto's auto-generated MCP servers, you can connect your AI agents to 360learning natively, securely, and within minutes.

Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds. :::