Connect Articulate 360 to Claude: Manage User Groups and Invitations

If you need to connect Articulate 360 to Claude to automate user provisioning, group management, or learner onboarding, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's tool calls and Articulate 360'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. If your team uses ChatGPT, check out our guide on connecting Articulate 360 to ChatGPT or explore our broader architectural overview on connecting Articulate 360 to AI Agents.

Giving a Large Language Model (LLM) read and write access to an enterprise Learning Management System (LMS) like Articulate Reach 360 is an engineering challenge. You have to handle API authentication lifecycles, map complex JSON schemas to MCP tool definitions, and deal with specific pagination models. Every time you need to expose a new endpoint, you have to update your server code, redeploy, and test the integration.

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

The Engineering Reality of the Articulate 360 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, the reality of implementing it against Articulate 360's API introduces several specific integration hurdles.

If you decide to build a custom MCP server for Articulate 360, you own the entire API lifecycle. Here are the specific challenges you will face:

Implicit Resource Creation and State Management The Articulate 360 API handles some entity creation implicitly. For example, when creating a pending invitation via the API, you can specify groups for the user. If those groups do not exist in the LMS, Articulate 360 will automatically create them when the user accepts the invitation. An LLM needs explicit instructions in its tool descriptions to understand this behavior, otherwise it may hallucinate prerequisite "create group" calls that fail or create duplicate structures. Truto handles this by injecting clear, documentation-driven schema descriptions directly into the MCP tools.

Handling Empty Success Responses Many Articulate 360 write operations - such as adding a user to a group, removing a user, or deleting an invitation - return an empty 204 No Content HTTP response on success. If an MCP server is not explicitly designed to catch and wrap this empty body into a valid JSON-RPC 2.0 success payload, Claude will interpret the empty response as an integration failure or crash. Truto's proxy architecture normalizes these empty responses into successful MCP protocol confirmations so your AI agents can proceed to the next step in their workflow.

Rate Limits and 429 Handling Articulate 360 enforces rate limits to ensure system stability. A critical architectural detail to understand when using Truto: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Articulate 360 API returns an HTTP 429 Too Many Requests, Truto passes that exact error directly to the caller. Truto normalizes the upstream rate limit information into standardized HTTP headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF specification. The caller - whether that is Claude Desktop, a custom LangGraph agent, or an orchestration layer - is entirely responsible for reading these headers and implementing the appropriate retry and backoff logic.

Instead of building custom middleware to handle authentication, flat input namespace mapping, and tool generation, you can use Truto. Truto derives tool definitions dynamically from the integration's documentation and resources, generating a self-contained MCP server URL.

How to Generate an Articulate 360 MCP Server with Truto

Truto creates MCP servers dynamically. You do not need to write server code or deploy infrastructure. You just need to connect an Articulate 360 account and generate a tokenized URL.

There are two ways to generate this server: via the Truto UI or programmatically via the Truto API.

Method 1: Via the Truto UI

If you are setting this up for internal use or testing, the Truto dashboard is the fastest method.

1. Log into your Truto environment and navigate to the integrated account page for your Articulate 360 connection.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can assign a human-readable name, filter by specific methods (e.g., only read or write operations), restrict access using tool tags, and optionally set an expiration date for the server.
5. Click generate and copy the resulting MCP server URL (e.g., https://api.truto.one/mcp/abc123def456...).

Method 2: Via the Truto API

If you are building a product where your end-users connect their own Articulate 360 accounts, you should generate MCP servers programmatically.

When you make a POST request to the MCP endpoint, Truto validates that the integration has tools available, generates a secure token, hashes it for storage, and returns a ready-to-use URL.

Request:

curl -X POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp \
  -H "Authorization: Bearer YOUR_TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Articulate 360 Admin Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["users", "groups"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

Response:

{
  "id": "mcp_srv_987654321",
  "name": "Articulate 360 Admin Agent",
  "config": {
    "methods": ["read", "write"],
    "tags": ["users", "groups"]
  },
  "expires_at": "2026-12-31T23:59:59Z",
  "url": "https://api.truto.one/mcp/abc123def4567890"
}

This URL contains a cryptographic token that encodes the account routing and tool configuration. It is fully self-contained. Keep it secure.

How to Connect the MCP Server to Claude

Once you have the Truto MCP URL, you can connect it to your AI client. You can do this through the client's visual interface or by editing its configuration file.

Method A: Via the Claude UI

If you are using a client that supports visual MCP configuration (like ChatGPT or the Claude web interface for enterprise setups):

1. In your AI client, navigate to Settings -> Integrations (or Connectors).
2. Click Add MCP Server or Add custom connector.
3. Paste the Truto MCP server URL you generated in the previous step.
4. Click Add. The client will perform an MCP handshake, discover the Articulate 360 tools dynamically, and make them available to the model.

Method B: Via Manual Configuration File

If you are using Claude Desktop (or Cursor), you must configure the MCP server by editing the claude_desktop_config.json file.

Truto MCP servers communicate over HTTP using Server-Sent Events (SSE). To bridge Claude Desktop's standard stdio transport to Truto's remote HTTP endpoint, you use the official @modelcontextprotocol/server-sse proxy.

Add the following block to your configuration file:

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

Restart Claude Desktop. When you open a new chat, you will see the Articulate 360 tools listed as available actions.

Articulate 360 Hero Tools for User & Group Management

Truto automatically generates tools from Articulate 360's API definitions. We map the nested schemas into a flat input namespace, allowing Claude to seamlessly pass arguments without worrying about underlying REST routing.

Here are the critical tools for automating user and group management in Reach 360.

1. create_a_articulate_360_group

This tool creates a new functional group in Articulate Reach 360. Groups are fundamental for managing course enrollments at scale.

• Required Parameters: name
• Context: Use this to programmatically set up departments, onboarding cohorts, or regional teams before assigning users.

"I need to set up a new training cohort. Create a new group in Articulate 360 called 'Q4 Sales Bootcamp'."

2. create_a_articulate_360_invitation

This tool generates a pending invitation, triggering an email invite to the specified user.

• Required Parameters: email
• Context: You can optionally pass a list of groups. If the groups don't exist, the Articulate 360 API will automatically create them once the user accepts the invitation.

"Send an Articulate 360 invitation to j.smith@example.com and ensure they are added to the 'Engineering Security Compliance' group when they join."

3. list_all_articulate_360_invitations

Retrieves a list of all pending (unaccepted) invitations in your Reach 360 account.

• Context: Highly useful for auditing onboarding pipelines or finding stagnant invites that need to be revoked to free up licenses.

"List all pending invitations in Articulate 360. I need to see who hasn't accepted their onboarding invite yet."

4. delete_a_articulate_360_invitation_by_id

Revokes and deletes a pending invitation using its unique ID.

• Required Parameters: id
• Context: Deleting an invitation before the user accepts it invalidates the link sent to their email. This returns a 204 No Content on success.

"Find the pending invitation for m.jones@example.com and delete it, as they are no longer joining the company."

5. list_all_articulate_360_group_memberships

Fetches all active users within a specific Reach 360 group.

• Required Parameters: group_id
• Context: Returns detailed user records including roles, last active timestamps, and reporting URLs. Crucial for compliance audits.

"Get the list of all members currently in the 'EMEA Management' group so I can verify who has access to the leadership training paths."

6. articulate_360_group_memberships_add_user

Assigns an existing Articulate 360 user to a specific group.

• Required Parameters: group_id, user_id
• Context: You must first look up the user_id (via a user listing tool) and the group_id. This allows an AI agent to dynamically route employees into appropriate learning tracks based on HR data changes.

"Add user ID 10452 to the 'Q4 Sales Bootcamp' group."

To see the complete list of available operations - including course enrollments, learning path management, reporting analytics, and webhook configurations - view the full tool inventory on the Articulate 360 integration page.

Workflows in Action

When connected to Claude, these tools can be orchestrated to execute multi-step administration tasks without human intervention. Here are two real-world examples of how AI agents utilize the Articulate 360 MCP server.

Scenario 1: Automating Sales Team Onboarding

When a new cohort of sales representatives joins the company, an IT administrator typically has to manually create groups, issue invites, and assign learning paths. With Claude, this becomes a single conversational prompt.

"We have a new class of SDRs starting today. Please create a new group in Articulate 360 called 'October 2026 SDR Cohort'. Once created, send invitations to a.turner@example.com and b.wilson@example.com, and make sure they are added to that specific group."

How the Agent executes this:

1. Claude calls create_a_articulate_360_group with the name "October 2026 SDR Cohort".
2. The MCP server returns the new group object, including its unique id.
3. Claude calls create_a_articulate_360_invitation for a.turner@example.com, passing the new group ID in the payload.
4. Claude calls create_a_articulate_360_invitation for b.wilson@example.com with the same group ID.
5. Claude outputs a natural language summary confirming the group was created and invites were dispatched.

Scenario 2: Auditing and Revoking Stale Invitations

Enterprise software licenses are expensive. Leaving unaccepted invitations in the system wastes money and creates security sprawl. An AI agent can perform a routine audit to clean these up.

"Check Articulate 360 for any pending invitations. If you find any, list their email addresses for me. Then, go ahead and delete the invitation for c.davis@example.com."

How the Agent executes this:

1. Claude calls list_all_articulate_360_invitations.
2. The MCP server fetches the array of pending invitations from the Articulate 360 API.
3. Claude analyzes the JSON array, identifies the IDs, and presents the list of emails to the user.
4. Claude extracts the specific invitation ID for c.davis@example.com from its context window.
5. Claude calls delete_a_articulate_360_invitation_by_id, passing the extracted ID.
6. The API returns a 204 No Content (which Truto normalizes to a success object), and Claude confirms the deletion.

sequenceDiagram
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant Articulate as Articulate 360 API
    
    Note over Claude, Articulate: Step 1: Auditing Invites
    Claude->>MCP: Call list_all_articulate_360_invitations
    MCP->>Articulate: GET /v1/invitations
    Articulate-->>MCP: 200 OK (JSON array)
    MCP-->>Claude: Return array of pending invites
    
    Note over Claude, Articulate: Step 2: Revoking Stale Invite
    Claude->>MCP: Call delete_a_articulate_360_invitation_by_id {id: "inv_890"}
    MCP->>Articulate: DELETE /v1/invitations/inv_890
    Articulate-->>MCP: 204 No Content
    MCP-->>Claude: JSON-RPC Success

Security and Access Control

Exposing an enterprise LMS to an AI agent requires strict governance. Truto MCP servers are designed with security primitives that allow you to enforce the principle of least privilege at the infrastructure layer.

• Method Filtering (config.methods): You can restrict an MCP server to strictly read-only operations by passing ["read"] during creation. This ensures the AI agent can list users and groups but cannot accidentally delete or modify data.
• Tag Filtering (config.tags): Truto groups integration endpoints by functional tags. You can limit an MCP server to only access endpoints tagged with "users" or "reports", completely blocking access to course content or webhooks.
• Extra Authentication (require_api_token_auth): By default, possessing the MCP URL grants access. By setting this flag to true, the client must also pass a valid Truto API token in the Authorization header, preventing lateral movement if a URL is leaked.
• Time-to-Live (expires_at): You can create ephemeral MCP servers for temporary automation runs (e.g., a one-off audit). Once the timestamp passes, the server automatically invalidates and cleans up all associated cryptographic keys.

Connecting Articulate 360 to Claude shouldn't require weeks of building custom middleware, studying LMS pagination structures, or writing JSON schema mappings by hand. By using a managed MCP architecture, you offload the authentication, formatting, and protocol translation to infrastructure explicitly designed for AI agents. This allows your engineering team to focus on building autonomous workflows, not maintaining integration boilerplate.