---
title: "Connect Lever to Claude: Automate Interviews and Feedback Loops"
slug: connect-lever-to-claude-automate-interviews-and-feedback-loops
date: 2026-10-10
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to build a secure MCP server to connect Lever to Claude. Automate interview feedback, candidate sourcing, and pipeline management workflows."
tldr: "Connecting Claude to Lever via an MCP server allows you to automate candidate pipeline progression, extract interview feedback, and manage job postings securely. This guide covers architecture, setup, and real-world workflows."
canonical: https://truto.one/blog/connect-lever-to-claude-automate-interviews-and-feedback-loops/
---

# Connect Lever to Claude: Automate Interviews and Feedback Loops


If your team needs to connect Lever to Claude to automate candidate sourcing, extract interview feedback, or manage complex pipeline progressions, 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 natural language tool calls and Lever's REST APIs. You can either build and maintain this infrastructure yourself - dealing with token refresh lifecycles and schema mapping - or use a [managed integration platform like Truto](https://truto.one/managed-mcp-for-claude-full-saas-api-access-without-security-headaches/) to dynamically generate a secure, authenticated MCP server URL. If your team uses ChatGPT, check out our guide on [/connect-lever-to-chatgpt-manage-full-cycle-hiring-and-pipelines/](https://truto.one/connect-lever-to-chatgpt-manage-full-cycle-hiring-and-pipelines/) or explore our broader architectural overview on [/connect-lever-to-ai-agents-orchestrate-job-postings-and-sourcing/](https://truto.one/connect-lever-to-ai-agents-orchestrate-job-postings-and-sourcing/).

Giving a Large Language Model (LLM) read and write access to a specialized applicant tracking system (ATS) like Lever is an engineering challenge. You have to handle OAuth 2.0 token lifecycles, map complex JSON schemas to MCP tool definitions, and deal with Lever's strict domain-specific data constraints. Every time Lever updates an endpoint or changes how feedback fields are structured, 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 Lever, connect it natively to Claude, and execute complex recruiting workflows using natural language.

> Want to give your AI agents secure, authenticated access to Lever and 100+ other SaaS APIs? Let's talk about managed MCP architecture.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Lever API

A [custom MCP server](https://truto.one/the-hands-on-guide-to-building-mcp-servers-for-ai-agents-2026/) 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 ATS APIs is painful. Lever is built to manage massive applicant pipelines, complex interview panels, and highly structured feedback forms. Its API reflects that complexity.

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

**Complex Nested Feedback Structures**
Feedback forms in Lever are not simple flat key-value pairs. Submitting or reading feedback involves nested arrays of field objects that contain scores, text responses, and predefined options. An LLM cannot simply guess this payload structure. A managed MCP server exposes tools like `create_a_lever_feedback` with strictly defined JSON schemas (derived directly from API documentation) that explicitly guide the LLM to provide the correct field arrays and stage parameters.

**Pipeline Stage Progression Mechanics**
Moving a candidate in Lever is not a matter of simply updating a status string on a profile. You have to query the available pipeline stages, extract the correct stage ID, and execute a specific stage-change operation. This often results in a stage-change note being appended to the opportunity. Without strict tool definitions, LLMs will attempt to simply PATCH an opportunity object, resulting in validation errors.

**Strict Rate Limits Without Safety Nets**
Lever enforces strict rate limits to protect its infrastructure. When building an integration, you must account for HTTP 429 Too Many Requests errors. It is a critical factual note that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Lever API returns a 429, Truto passes that error directly to the caller. However, Truto normalizes the upstream rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (your LLM agent framework or orchestration layer) is strictly responsible for inspecting these headers and applying its own retry and backoff logic.

## Creating the Lever MCP Server

Truto dynamically generates MCP tools based on the documentation and schema definitions of the underlying integration. You can generate a Lever MCP server using either the Truto user interface or programmatically via the API.

### Method 1: Via the Truto UI

For administrators and internal tooling teams, the quickest way to spin up an MCP server is through the dashboard:

1. Navigate to the **Integrated Accounts** page in your Truto dashboard and select your connected Lever account.
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., read-only), and set an optional expiration date.
5. Click **Create** and immediately copy the generated MCP server URL. (You will not be able to see the raw token again).

### Method 2: Via the Truto API

For engineering teams building multi-tenant AI applications, you will want to provision MCP servers dynamically. You can do this by making an authenticated POST request to the Truto API.

```typescript
// Example: Generating a Lever MCP Server via API
const response = await fetch('https://api.truto.one/integrated-account/{integrated_account_id}/mcp', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer YOUR_TRUTO_API_KEY',
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    name: "Claude-Lever-Integration",
    config: {
      methods: ["read", "write"], // Expose both read and write operations
      tags: ["recruiting", "candidates"]
    },
    expires_at: "2026-12-31T23:59:59Z"
  })
});

const mcpServer = await response.json();
console.log(mcpServer.url); 
// Output: https://api.truto.one/mcp/a1b2c3d4e5f6...
```

This API call validates that the integration has tools available, generates a secure cryptographically hashed token, stores it in a distributed Key-Value store, and schedules cleanup alarms for the expiration date. The resulting URL contains everything Claude needs to authenticate and discover tools.

## Connecting the MCP Server to Claude

Once you have your MCP server URL, you need to register it with your LLM client. Truto's MCP servers communicate using JSON-RPC 2.0 over standard HTTP POST, making them highly compatible.

### Method A: Via the Claude UI (or ChatGPT)

If you are using consumer interfaces that support custom connectors, adding the server takes seconds:

1. In your AI client (e.g., Claude Desktop, ChatGPT), navigate to **Settings -> Integrations** (or Connectors).
2. Click **Add MCP Server** or **Add Custom Connector**.
3. Paste the Truto MCP URL (`https://api.truto.one/mcp/...`).
4. Click **Add** or **Save**. The client will immediately perform a handshake, calling the `initialize` and `tools/list` endpoints to discover the available Lever tools.

### Method B: Via the Claude Desktop Configuration File

If you are configuring Claude Desktop locally for development, you can add the server using the configuration file and the standard Server-Sent Events (SSE) transport adapter.

Open your `claude_desktop_config.json` file (typically found at `~/Library/Application Support/Claude/claude_desktop_config.json` on macOS) and add the following:

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

Restart Claude Desktop. The application will connect to the server, and the model will instantly understand how to read and write to your Lever instance.

## Hero Tools for Lever Automation

Truto maps Lever's REST endpoints into heavily documented, schema-validated MCP tools. Below are the highest-leverage tools for automating recruiting workflows. 

### List All Lever Opportunities

This tool retrieves all pipeline opportunities for contacts. It is the primary entry point for agentic workflows, allowing Claude to find candidate IDs based on name, stage, or tags.

> "Claude, find all opportunities currently in the 'Onsite Interview' stage and summarize their current tags and origins."

### Lever Opportunities Move

Moving an opportunity to a different pipeline stage. This tool takes the opportunity ID and the target stage ID, returning the ID of the auto-generated stage-change note.

> "Move candidate ID 12345 to the 'Offer Extended' stage."

### List All Lever Interviews

Retrieves all scheduled and past interviews for a specific opportunity. It returns critical panel data, subject details, timezones, and the specific interviewers assigned to the candidate.

> "Pull the interview schedule for candidate ID 98765. Who is on their technical panel this Thursday?"

### Create a Lever Feedback

Submits a new feedback form for a Lever opportunity. This tool expects a specific array of fields containing the submitted values and options, mapping directly to Lever's complex feedback architecture.

> "Submit interview feedback for candidate 44556. Use the standard engineering rubric, score the technical communication as a 4 out of 5, and add a note that they excelled at system design."

### List All Lever Resumes

Lists all resumes attached to a specific Lever opportunity. Crucially, this returns not just file metadata, but the `parsedData` object containing the candidate's extracted positions and education history.

> "Fetch the parsed resume data for the latest applicant to the Senior DevOps role and summarize their past three job titles."

### Create a Lever Posting

Creates a new job posting in the Lever account. It requires text, categories (team, department, location), and manages the state (defaulting to draft). API-created postings skip the approvals chain.

> "Draft a new job posting for a 'Backend Engineer' in the Engineering department based in New York. Leave it in the draft state for my review."

To view the complete inventory of available Lever tools, including schemas for users, notes, files, and requisitions, visit the [Lever Integration Page](https://truto.one/integrations/detail/lever).

## Workflows in Action

By exposing these tools to Claude, you can orchestrate complex, multi-step workflows that historically required manual data entry by recruiters.

### Scenario 1: Automated Interview Debrief Summarization

**Persona:** Engineering Hiring Manager

> "Claude, pull all the interview feedback for Jane Doe (opportunity ID 55432) from yesterday's onsite loop. Summarize the technical scores, highlight any red flags, and draft a final debrief note to post on her profile."

1. Claude calls `list_all_lever_interviews` with the opportunity ID to confirm the panel.
2. Claude calls `list_all_lever_feedback` to extract the submitted forms and scores from the interviewers.
3. Claude processes the raw JSON, analyzing the nested score arrays to determine consensus.
4. Claude calls `create_a_lever_note` to post the synthesized debrief summary directly to the candidate's Lever profile.

```mermaid
sequenceDiagram
    participant User as Hiring Manager
    participant Agent as Claude
    participant Truto as Truto MCP Server
    participant Upstream as Lever API

    User->>Agent: "Summarize feedback for Jane Doe and post debrief note"
    Agent->>Truto: Call list_all_lever_feedback(opportunity_id)
    Truto->>Upstream: GET /opportunities/{id}/feedback
    Upstream-->>Truto: Return nested feedback arrays
    Truto-->>Agent: JSON Schema validated response
    Agent->>Agent: Analyze scores and text responses
    Agent->>Truto: Call create_a_lever_note(opportunity_id, text)
    Truto->>Upstream: POST /opportunities/{id}/notes
    Upstream-->>Truto: Return note ID
    Truto-->>Agent: Success confirmation
    Agent-->>User: "Debrief posted to Lever profile."
```

### Scenario 2: Resume Screening and Pipeline Progression

**Persona:** Technical Sourcer

> "Review the resumes for all new applicants in the 'New Lead' stage. If their parsed resume shows more than 5 years of experience using Kubernetes, move them to the 'Recruiter Screen' stage."

1. Claude calls `list_all_lever_opportunities` to get a batch of candidates in the starting stage.
2. Claude loops through the IDs, calling `list_all_lever_resumes` for each to access the `parsedData`.
3. Claude evaluates the parsed work history against the user's criteria (Kubernetes, 5+ years).
4. For candidates who pass, Claude calls `list_all_lever_stages` to find the target stage ID.
5. Claude calls `lever_opportunities_move` to advance the qualified candidates, leaving the rest for manual review.

```mermaid
graph TD
    A["Get New Leads<br>(list_all_lever_opportunities)"] --> B["Extract Parsed Data<br>(list_all_lever_resumes)"]
    B --> C{"Experience > 5 yrs<br>Kubernetes?"}
    C -->|"Yes"| D["Get Stage ID<br>(list_all_lever_stages)"]
    C -->|"No"| E["Skip Candidate"]
    D --> F["Advance Candidate<br>(lever_opportunities_move)"]
```

## Security and Access Control

Giving an LLM write access to your primary ATS requires strict governance. Truto's MCP servers provide granular access controls enforced at the token layer:

*   **Method Filtering:** You can restrict a server to read-only access by passing `methods: ["read"]` during creation. If Claude attempts to invoke a `create` or `update` tool, the server will reject it.
*   **Tag Filtering:** You can isolate scopes by functional area. Passing `tags: ["recruiting"]` ensures only tools related to candidates and jobs are exposed, hiding sensitive administrative or billing endpoints.
*   **Expiration (TTL):** Set an `expires_at` timestamp for contractor or temporary workflow access. Truto's distributed architecture uses scheduled alarms to automatically tear down the server and purge the keys exactly when time expires.
*   **Extra Authentication:** By enabling `require_api_token_auth`, the MCP server will mandate that the client provides a valid Truto API token in the Authorization header. This guarantees that possession of the URL alone is insufficient to execute tools.

## Architecting for Scale

Integrating Lever with Claude transforms how recruiting teams operate. Instead of clicking through complex UI tabs to extract interview scores or update pipeline stages, teams can leverage autonomous agents to synthesize data and execute workflows in seconds.

By utilizing an MCP server backed by a platform like Truto, you bypass the friction of custom API development. You don't have to write TypeScript interfaces for Lever's deeply nested feedback forms, nor do you have to build infrastructure to manage OAuth tokens. You get documentation-driven tool generation, strictly enforced JSON schemas, and transparent error handling - allowing your engineers to focus on AI logic rather than API plumbing.