---
title: "Connect Navan SCIM to Claude: Access Company Directory Records"
slug: connect-navan-scim-to-claude-access-company-directory-records
date: 2026-09-16
author: Yuvraj Muley
categories: ["AI & Agents"]
excerpt: Learn how to connect Navan SCIM to Claude via a managed MCP server. Automate employee directory synchronization and travel provisioning without writing code.
tldr: "A technical guide to connecting Navan SCIM to Claude using Truto's managed MCP server. Covers dynamic tool generation, SCIM schema handling, rate limit passthrough, and secure workflows."
canonical: https://truto.one/blog/connect-navan-scim-to-claude-access-company-directory-records/
---

# Connect Navan SCIM to Claude: Access Company Directory Records


If you need to connect Navan SCIM to Claude to automate employee provisioning, audit travel profiles, or instantly execute offboarding tasks, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Navan's strict SCIM 2.0 REST APIs. You can either build, host, and maintain this complex infrastructure yourself (see our [guide to building MCP servers](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/)), or use a managed integration platform like Truto to dynamically generate a secure, authenticated MCP server URL in seconds. 

If your team uses ChatGPT, check out our guide on [connecting Navan SCIM to ChatGPT](https://truto.one/connect-navan-scim-to-chatgpt-search-and-audit-user-profiles/) or explore our broader architectural overview on [connecting Navan SCIM to AI Agents](https://truto.one/connect-navan-scim-to-ai-agents-automate-directory-data-lookups/).

Giving a Large Language Model (LLM) read and write access to your corporate travel and expense directory is an engineering challenge. You must handle secure token lifecycles, map deeply nested SCIM JSON schemas to flat MCP tool definitions, and deal with strict API quotas. Every time an endpoint changes or you need to onboard a new tenant, 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](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) for Navan SCIM, connect it natively to Claude Desktop, and execute complex identity management workflows using natural language.

> Want to give your AI agents secure, authenticated access to Navan SCIM 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 Navan SCIM 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 like Navan SCIM is painful. Navan uses the System for Cross-domain Identity Management (SCIM) standard, which enforces highly specific schema requirements.

If you decide to [build a custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) for Navan SCIM, here are the specific integration challenges you will face:

**Deeply Nested SCIM 2.0 Schemas**
SCIM 2.0 requires payloads formatted with specific schema URIs (e.g., `urn:ietf:params:scim:schemas:core:2.0:User`) and heavily nested arrays for attributes like `emails`, `phoneNumbers`, and `addresses`. LLMs notoriously struggle with generating deeply nested arrays perfectly on the first try. Your MCP server must present a strictly defined JSON Schema that forces the LLM to output the exact structure Navan expects, while handling the translation between a flat argument namespace and a nested API request body.

**Cursor Pagination and State Management**
Navan SCIM handles large directory queries using standardized pagination. When Claude requests a list of all employees in a specific department, the API will not return a single flat array. It returns paginated chunks. Your MCP server must automatically inject pagination schemas (like `limit` and `next_cursor`) into the tool definitions and explicitly instruct the LLM to pass cursor values back unchanged to traverse the dataset.

**Explicit Rate Limiting and Backoff Responsibilities**
When an LLM runs in an autonomous loop auditing hundreds of employee profiles, it will quickly hit Navan's rate limits. It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When Navan returns an HTTP 429 status code, 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 specification. The caller - in this case, the Claude agent loop - is entirely responsible for reading these headers, sleeping, and applying retry or backoff logic. Truto does not automatically retry or absorb rate limit errors on your behalf.

## Generating a Managed MCP Server for Navan SCIM

Truto's MCP architecture completely eliminates the need to write custom translation code. Tool generation is dynamic and documentation-driven. Rather than hand-coding tool definitions for Navan SCIM, Truto derives them instantly from the integration's resource definitions and schema documentation. 

A tool only appears in the MCP server if it has a corresponding documentation entry - acting as a strict quality gate to ensure Claude only sees well-documented, tested endpoints.

There are two ways to generate an MCP server in Truto for Navan SCIM.

### Method 1: Via the Truto UI

For internal automation and single-tenant use cases, the UI is the fastest path.

1. Navigate to the **Integrated Accounts** page in your Truto dashboard.
2. Select your connected Navan SCIM account.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration (e.g., set the server name, restrict methods to read-only, or filter by tags).
6. Copy the generated MCP server URL (e.g., `https://api.truto.one/mcp/a1b2c3d4...`).

### Method 2: Via the API (Multi-Tenant Architecture)

If you are building an AI product and need to programmatically generate MCP servers for each of your customers who connect Navan SCIM, use the Truto API. 

Truto validates that the integration is AI-ready, hashes the token securely, stores it in a globally distributed key-value store for single-digit millisecond lookups, and returns a ready-to-use URL.

```typescript
// POST https://api.truto.one/integrated-account/{integrated_account_id}/mcp

const response = await fetch(`https://api.truto.one/integrated-account/${accountId}/mcp`, {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${TRUTO_API_KEY}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Navan SCIM Operations Agent",
    config: {
      methods: ["read", "write"] // Or restrict to "read" only
    }
  })
});

const mcpServer = await response.json();
console.log(mcpServer.url); // The URL to pass to your MCP client
```

## Connecting the MCP Server to Claude

Once you have the Truto MCP Server URL, connecting it to Claude requires zero additional code. The URL contains a cryptographic token that securely identifies the integrated account and configuration.

### Method A: Via the Claude Desktop UI

If you are using Claude Desktop for internal operations:

1. Open Claude Desktop and navigate to **Settings**.
2. Go to **Integrations** (or **Connectors** depending on your version).
3. Click **Add MCP Server**.
4. Paste the Truto MCP URL generated in the previous step.
5. Click **Add**.

Claude will immediately perform a JSON-RPC `initialize` handshake, discover the Navan SCIM tools dynamically, and make them available in your chat context.

### Method B: Via the Claude Configuration File

For automated environments or strict configuration management, you can define the server in your `claude_desktop_config.json` file. Because Truto exposes a remote HTTP/SSE endpoint, you use the standard MCP SSE client wrapper to bridge the standard I/O expected by Claude Desktop to Truto's remote server.

```json
{
  "mcpServers": {
    "navan_scim": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/client-sse",
        "--url",
        "https://api.truto.one/mcp/YOUR_SECURE_TOKEN_HERE"
      ]
    }
  }
}
```

## Hero Tools for Navan SCIM

Truto dynamically translates Navan's SCIM resources into snake_case, highly descriptive tools optimized for LLM comprehension. 

Here are the high-leverage hero tools your agent will use to automate travel directory operations. *Note: When an MCP client calls a tool, all arguments arrive as a single flat object. The Truto MCP router intelligently splits them into query parameters and body parameters using the schemas' property keys.*

### list_all_navan_scim_users

Retrieves a paginated list of users from the Navan directory over the SCIM 2.0 endpoint. This is the primary tool for auditing your workforce and finding specific user IDs for downstream operations.

> "Claude, pull a list of all active users in the Navan SCIM directory. Check if any users have missing department data in their enterprise extension attributes."

### get_single_navan_scim_user_by_id

Fetches a complete, detailed profile for a single Navan user based on their SCIM ID. This returns the full nested schema, including their travel roles, status, and contact arrays.

> "Get the full SCIM profile for the user with ID 8a7b6c5d. Verify that their primary email address matches our new corporate domain."

### create_a_navan_scim_user

Provisions a new user in Navan. The tool enforces the complex SCIM body schema, ensuring the LLM provides the required `schemas` array, `userName`, and `name` object structure.

> "Provision a new Navan account for Jane Doe (jane.doe@company.com). She is a Senior Engineer. Make sure her account is active and set her locale to US."

### update_a_navan_scim_user_by_id

Executes a full update (PUT) or partial patch (PATCH) on an existing user. This is the critical tool for role changes, department transfers, or correcting profile metadata.

> "Update the Navan SCIM profile for user ID 12345. Change their title to 'Director of Sales' and update their department to 'Revenue'."

### delete_a_navan_scim_user_by_id

Hard deletes a user record from the Navan SCIM directory. (Note: Many organizations prefer using the update tool to set `active: false` instead of a hard delete, depending on their travel data retention policies).

> "We need to purge the contractor profile with ID 998877. Call the delete tool to remove them entirely from the Navan directory."

To view the complete inventory of available resources, schemas, and endpoint documentation, visit the [Navan SCIM integration page](https://truto.one/integrations/detail/navanscim).

## Workflows in Action

By chaining these tools together, Claude transforms from a simple chatbot into an autonomous IT and HR operations agent. Here are concrete examples of workflows you can execute via natural language.

### 1. The Autonomous Employee Offboarding Flow

Offboarding requires immediate action to revoke travel booking capabilities. Instead of logging into the Navan admin console, an IT admin can simply instruct Claude.

> "Marcus Johnson is leaving the company today. Please find his Navan profile and deactivate his account immediately so no new travel can be booked."

**Step-by-step Execution:**
1. Claude calls `list_all_navan_scim_users` with a query parameter filtering for Marcus Johnson's name or email to retrieve his SCIM ID.
2. Claude analyzes the result and extracts the ID.
3. Claude calls `update_a_navan_scim_user_by_id`, passing the ID and a payload setting `active: false` to suspend the account.
4. Claude returns a confirmation message stating the account has been successfully deactivated.

```mermaid
sequenceDiagram
    participant Admin as IT Admin
    participant Claude as Claude Desktop
    participant Truto as Truto MCP Server
    participant Navan as Navan SCIM API

    Admin->>Claude: "Deactivate Marcus Johnson's Navan account"
    Claude->>Truto: Call list_all_navan_scim_users (filter by name)
    Truto->>Navan: GET /Users?filter=userName eq ...
    Navan-->>Truto: Return user array
    Truto-->>Claude: JSON response with user ID (abc-123)
    Claude->>Truto: Call update_a_navan_scim_user_by_id (ID: abc-123, active: false)
    Truto->>Navan: PUT /Users/abc-123
    Navan-->>Truto: 200 OK
    Truto-->>Claude: Update successful
    Claude-->>Admin: "Marcus Johnson's account has been deactivated."
```

### 2. Department Data Audit and Reconciliation

When a company restructures, employee profiles in downstream SaaS apps often fall out of sync. Claude can audit and reconcile this data autonomously.

> "Audit all Navan users. Find anyone who is listed in the 'Marketing' department and update their department to 'Growth'. Give me a summary of who was changed."

**Step-by-step Execution:**
1. Claude calls `list_all_navan_scim_users` and requests the first page of results.
2. If pagination cursors are present, Claude repeatedly calls the tool, passing the `next_cursor` back unchanged, until it has ingested the full directory.
3. Claude identifies the subset of users with the department set to 'Marketing'.
4. For each identified user, Claude calls `update_a_navan_scim_user_by_id` in a loop, patching the department field to 'Growth'.
5. Claude formulates a final summary response listing the names of all updated employees.

### 3. Executive Onboarding

Provisioning a new executive requires ensuring all standard SCIM metadata is applied correctly so their travel profiles are accurate.

> "We have a new VP of Engineering starting next week, Sarah Connor. Her email is sarah@company.com. Provision her in Navan SCIM with active status."

**Step-by-step Execution:**
1. Claude formulates a strict SCIM 2.0 JSON body schema based on the tool definition for `create_a_navan_scim_user`.
2. Claude maps the name, title, and email to the required nested arrays.
3. Claude calls the tool.
4. Truto proxies the request to Navan.
5. Claude reads the 201 Created response and returns the newly generated SCIM ID to the user.

## Security and Access Control

Giving AI agents API access to your company directory requires strict governance. Truto MCP servers provide four layers of security configuration that you can define at creation time to constrain agent behavior:

*   **Method Filtering:** Restrict the server to specific operations. Setting `methods: ["read"]` ensures the agent can execute `list_all_navan_scim_users` and `get_single_navan_scim_user_by_id`, but any attempt to create or delete a user will be blocked at the protocol level before it ever reaches Navan.
*   **Tag Filtering:** Limit the server to specific resource domains. Using `tags: ["directory"]` groups tools logically, allowing you to hide unrelated or highly sensitive endpoints.
*   **Token Authentication (`require_api_token_auth`):** By default, possessing the MCP URL grants access. Enabling this flag applies an additional middleware layer requiring the MCP client to pass a valid Truto API token in the Authorization header. This ensures only authenticated team members can execute tools, even if the URL leaks.
*   **Expiration (`expires_at`):** Schedule the server to auto-destruct. Truto uses distributed alarms to automatically purge the token from the key-value store and database when the timestamp is reached. This is ideal for granting an AI agent temporary access during a specific migration or audit window.

## The Strategic Advantage of Managed MCP

Connecting Navan SCIM to Claude transforms how IT and HR operations manage identity lifecycles for travel and expenses. But managing the underlying integration infrastructure - translating flat LLM arguments into nested SCIM payloads, normalizing pagination, and handling standard IETF rate limit headers - is a massive distraction for engineering teams.

By leveraging Truto's dynamically generated MCP servers, you eliminate the integration build phase entirely. You gain immediate, secure, and fully typed tool calling capabilities out of the box, allowing you to focus on building better AI workflows rather than babysitting API schemas.

> Ready to orchestrate Navan SCIM and 100+ other enterprise platforms with Claude? Let's discuss your AI agent architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)