Connect Degreed to Claude: Manage courses, items, and certifications

If you need to connect Degreed to Claude to automate learning and development operations, curate course catalogs, or manage employee certifications, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Degreed's complex 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 companion guide on connecting Degreed to ChatGPT or explore our broader architectural overview on connecting Degreed to AI Agents.

Giving a Large Language Model (LLM) read and write access to a sprawling Learning Experience Platform (LXP) like Degreed is a serious engineering challenge. You have to handle fragmented OAuth 2.0 token lifecycles, map nested JSON schemas to MCP tool definitions, and deal with Degreed's strict API quotas. Every time Degreed updates a pathway endpoint or introduces a new Skills+ taxonomy, 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 Degreed, connect it natively to Claude Desktop, and execute complex L&D workflows using natural language.

The Engineering Reality of the Degreed 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 specialized enterprise APIs is painful. Degreed is built to manage massive organizational taxonomies, strict compliance requirements, and complex learning pathways. Its API reflects that complexity.

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

Visibility Groups and Privacy Enforcements When creating content in Degreed - such as articles, videos, or podcasts - the API enforces strict rules around visibility groups. You cannot arbitrarily mix groups. All assigned visibility groups must share a single privacy level (either all Administrative or all non-Administrative). If an LLM attempts to create a video and tags both an open department group and a closed executive group, the API will reject the payload. A managed MCP server helps by exposing tools with accurate JSON schemas that guide the LLM to structure these relationships correctly.

Tenant-Level Headers and Global Admin Complexity Degreed handles multi-tenancy differently depending on your organization's structure. If you are operating as a Global Admin Tool Organization, standard CRUD operations often fail unless you explicitly pass the X-Degreed-Organization-Code header to specify which tenant you are acting upon. Conversely, certain PATCH endpoints (like updating books or videos) strictly forbid this header. An AI agent has no inherent context for these header permutations.

Skills+ vs Legacy Skills Drift Degreed has been migrating organizations to its newer Skills+ ontology. This creates a bifurcated API surface. Endpoints like list_all_degreed_legacy_skills are deprecated, while tools like create_a_degreed_skill_suggestion require the target organization to have Skills+ explicitly enabled. Your MCP server must be smart enough to expose the correct schema based on the organization's configuration, otherwise Claude will hallucinate calls to endpoints that return 400 Bad Request errors.

Rate Limits and Data Freshness Constraints Degreed enforces strict rate limits. It is critical to note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the Degreed API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset) per the IETF spec. Your LLM agent or MCP client is responsible for reading these headers and executing its own backoff strategy. Furthermore, certain endpoints like "Today's Learning" only refresh their data every 48 hours unless the user has digest emails enabled, leading to caching confusion if not properly handled.

Generating a Degreed MCP Server with Truto

Truto eliminates the need to build a custom server. Instead, it dynamically generates an MCP server from Degreed's API documentation and OpenAPI schemas. The resulting server is fully self-contained - the URL alone encodes the authentication, the specific tenant connection, and the exposed tools.

You can generate this server in two ways: via the Truto UI or programmatically via the API.

Method 1: Via the Truto UI

If you are an IT admin or developer setting up an agent for internal use, the UI is the fastest path.

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Degreed account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Select your desired configuration. You can name the server, filter by HTTP methods (e.g., read, write), or restrict tools by tags (e.g., skills, compliance).
5. Copy the generated MCP server URL (e.g., https://api.truto.one/mcp/a1b2c3d4...).

Method 2: Via the Truto API

If you are building an AI product and need to generate MCP servers dynamically for your end-users, use the Truto API. This provisions a secure token in distributed KV storage.

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": "Degreed Compliance Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["users", "completions", "certifications"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API responds with the self-contained URL you will pass to Claude:

{
  "id": "mcp_token_98765",
  "name": "Degreed Compliance Agent",
  "url": "https://api.truto.one/mcp/xyz987...",
  "expires_at": "2026-12-31T23:59:59Z"
}

Connecting the MCP Server to Claude

Once you have your Truto MCP URL, connecting it to Claude takes seconds. You can do this via the Claude UI or a configuration file.

Method A: Via the Claude UI

If you are using Claude Desktop or an enterprise workspace that supports visual connector management:

1. Open Claude and go to Settings > Integrations (or Connectors).
2. Click Add MCP Server.
3. Paste the Truto MCP URL.
4. Click Add. Claude will instantly handshake with the URL, parse the JSON-RPC response, and populate its context with the available Degreed tools.

Method B: Via Manual Configuration File

If you are running Claude Desktop locally for development, you can inject the server via the JSON configuration file using the Server-Sent Events (SSE) transport adapter.

Open your claude_desktop_config.json (located in ~/Library/Application Support/Claude/ on macOS or %APPDATA%\Claude\ on Windows) and add:

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

Restart Claude Desktop. The agent is now fully authenticated and ready to interact with Degreed.

Hero Tools for Degreed

Truto dynamically maps Degreed's API into dozens of discrete tools. We curate these tools based on documentation schemas to ensure high-quality LLM interactions. Here are 6 of the most powerful operations you can hand to Claude.

List all Degreed users

This tool allows Claude to query the organization's user directory. It returns full user records including IDs, standard attributes, and relational metadata. It is the necessary first step for almost any user-specific workflow.

"Find the Degreed internal user ID for employee 'jane.doe@company.com' so we can check her compliance training status."

List all Degreed user completions

Allows Claude to audit a specific user's learning history. This requires a user_id and supports strict date filtering (added_after, added_before). It returns the exact content items the user has finished.

"Pull all the course completions for user ID 10984 from the past 7 days and format them into a markdown table."

Create a Degreed content course

This tool gives Claude write-access to the organization's content catalog. It can generate a new course record, assign metadata, and optionally establish visibility group relationships in a single call.

"Create a new internal course in Degreed called 'Q3 Cybersecurity Protocols'. Assign it a standard description and make sure it is marked as internal-only."

Create a Degreed skill plan

Skill plans organize upskilling efforts. Claude can use this tool to build structured development plans, assign initial attributes, and prepare the plan for resources and followers.

"Draft a new Skill Plan called 'Advanced Python Data Engineering'. Initialize it with sections for pandas, PySpark, and generic data pipelines."

Create a Degreed pathway

Pathways are curated journeys of learning content. Claude can instantiate a pathway, define its core attributes, and establish its basic structure before populating it with individual learning items.

"We have a new leadership cohort starting. Create a Degreed pathway named 'Emerging Leaders 2026' and return the pathway ID so I can add courses to it."

Degreed relationships skills bulk update

A powerful taxonomy management tool. It allows Claude to replace all skills assigned to a specific piece of content with a newly supplied set, essentially allowing the LLM to re-tag the entire LMS catalog dynamically.

"Update the skills mapping for course ID 5543. Remove the old legacy tags and replace them completely with the new Skills+ IDs for 'Machine Learning' and 'AI Ethics'."

For the complete list of available tools, including operations for xAPI statements, provider licenses, and custom attributes, view the Degreed integration page.

Workflows in Action

Exposing individual tools is useful, but the real power of MCP is how Claude chains these tools together to orchestrate complex operations. Here are two real-world workflows.

1. Automated L&D Onboarding and Upskilling

Persona: L&D Administrator managing a new engineering cohort.

"I need to set up the new engineering hires for success. Find the user record for John Smith, create a new Skill Plan called 'Backend Rust Fundamentals', and enroll him as a follower. Then, find the 'Intro to Rust' course in our catalog and add it as a required learning item for him."

sequenceDiagram
    participant User
    participant Claude as Claude Desktop
    participant Truto as Truto MCP
    participant Degreed as Degreed API

    User->>Claude: "Set up Backend Rust training for John Smith..."
    
    Claude->>Truto: call list_all_degreed_users<br>{"email": "john.smith@company.com"}
    Truto->>Degreed: GET /api/v2/users
    Degreed-->>Truto: User ID 9921
    Truto-->>Claude: Result: User ID 9921
    
    Claude->>Truto: call create_a_degreed_skill_plan<br>{"title": "Backend Rust Fundamentals"}
    Truto->>Degreed: POST /api/v2/skill-plans
    Degreed-->>Truto: Skill Plan ID 443
    Truto-->>Claude: Result: Skill Plan ID 443
    
    Claude->>Truto: call create_a_degreed_skill_plan_follower<br>{"skill_plan_id": 443, "user_id": 9921}
    Truto->>Degreed: POST /api/v2/skill-plans/443/followers
    Degreed-->>Truto: 201 Created
    Truto-->>Claude: Result: Success
    
    Claude->>Truto: call list_all_degreed_content_courses<br>{"keyword": "Intro to Rust"}
    Truto->>Degreed: GET /api/v2/content/courses
    Degreed-->>Truto: Course ID 8812
    Truto-->>Claude: Result: Course ID 8812
    
    Claude->>Truto: call create_a_degreed_required_learning<br>{"user_id": 9921, "content_id": 8812}
    Truto->>Degreed: POST /api/v2/required-learning
    Degreed-->>Truto: 201 Created
    Truto-->>Claude: Result: Success
    
    Claude-->>User: "I found John Smith (ID 9921), created the 'Backend Rust Fundamentals' skill plan, enrolled him, and assigned 'Intro to Rust' as required learning."

2. Compliance Auditing and Gap Analysis

Persona: Compliance Officer ensuring SOC 2 training is complete.

"Audit the compliance training for user ID 4410. List their required learnings, then check their completions for the past 30 days. Tell me if they have finished the 'Annual Security Awareness' assessment, and if not, draft a reminder message."

Execution Steps:

1. Claude calls list_all_degreed_user_required_learnings passing user_id: 4410 to retrieve the baseline requirements.
2. Claude calls list_all_degreed_user_completions passing user_id: 4410 and the 30-day date filters to retrieve recent activity.
3. Claude cross-references the required item IDs against the completed item IDs in its own memory space.
4. Claude identifies that the "Annual Security Awareness" assessment ID is missing from the completions list.
5. Claude responds to the user with a natural language summary and a drafted reminder email.

Security and Access Control

When giving an AI read and write access to your organization's learning and compliance data, security cannot be an afterthought. Truto provides four distinct layers of access control for managed MCP servers:

• Method Filtering: You can restrict a server entirely to safe operations. By passing config: { methods: ["read"] } during creation, the server will drop all POST, PUT, PATCH, and DELETE tools, rendering Claude strictly read-only.
• Tag Filtering: You can scope the server to specific functional domains. If you only want Claude touching certifications and not core HR user records, you can pass config: { tags: ["certifications"] }. Tools without that tag simply disappear from the server.
• Time-to-Live (TTL): Pass an expires_at ISO datetime when generating the token. Truto utilizes an edge alarm system to automatically permanently delete the token from distributed KV storage at the exact second it expires.
• Dual-Layer Authentication: Setting require_api_token_auth: true means possession of the MCP URL is no longer enough. The client connecting (e.g., your custom agent backend) must also inject a valid Truto API token into the HTTP headers, ensuring only authenticated internal systems can execute the tools.

Moving from Manual Tasks to Agentic L&D

Managing an enterprise LXP like Degreed manually is a constant battle against taxonomy drift, compliance chasing, and disjointed onboarding paths. By wrapping Degreed's complex API in a managed MCP server, you instantly abstract away the pain of OAuth, pagination, and multi-tenant headers.

Claude can now act as a true L&D assistant - capable of auditing compliance gaps, generating custom learning pathways, and updating user skills in real-time.

Stop writing custom integration scripts for every new LMS workflow. Generate a secure MCP server, hand the keys to Claude, and let the model do the heavy lifting.