---
title: "Connect Lever to ChatGPT: Manage Full Cycle Hiring and Pipelines"
slug: connect-lever-to-chatgpt-manage-full-cycle-hiring-and-pipelines
date: 2026-10-10
author: Uday Gajavalli
categories: ["AI & Agents"]
excerpt: "Learn how to connect Lever to ChatGPT using an auto-generated MCP server to automate candidate pipelines, schedule interviews, and manage job postings."
tldr: "Connect Lever to ChatGPT via an MCP server to orchestrate full cycle hiring. This guide covers bypassing Lever's complex API quirks, generating an MCP endpoint, and running automated recruitment workflows."
canonical: https://truto.one/blog/connect-lever-to-chatgpt-manage-full-cycle-hiring-and-pipelines/
---

# Connect Lever to ChatGPT: Manage Full Cycle Hiring and Pipelines


If you need to connect Lever to ChatGPT to automate full cycle hiring workflows, manage candidate pipelines, or orchestrate interview feedback, you need a [Model Context Protocol (MCP) server](https://truto.one/what-is-mcp-model-context-protocol-the-2026-guide-for-saas-pms/). This protocol standardizes how AI agents discover and invoke external APIs, transforming ChatGPT from a passive chatbot into an active recruitment assistant. 

If your team uses Claude, check out our guide on [connecting Lever to Claude](https://truto.one/connect-lever-to-claude-automate-interviews-and-feedback-loops/), or explore our broader architectural overview on [connecting Lever to AI Agents](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 complex Applicant Tracking System (ATS) like Lever is a significant engineering challenge. You must handle complex relational candidate data, two-step file uploads for resumes, and strict pagination rules. You can either spend weeks [building, hosting, and maintaining a custom MCP server](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) to translate LLM JSON arguments into Lever's highly specific payload structures, or you can use a [managed infrastructure layer](https://truto.one/best-mcp-server-platforms-for-enterprise-ai-agents-2026/) to generate tools dynamically.

This guide breaks down exactly how to use Truto to generate a secure, managed MCP server for Lever, connect it natively to ChatGPT, and execute complex hiring workflows using natural language.

> Stop writing boilerplate API integration code. Let Truto generate secure, managed MCP servers for your AI agents in seconds.
>
> [Talk to us](https://truto.one/book-a-demo/)

## The Engineering Reality of the Lever API

Building a custom MCP server means owning the entire API integration lifecycle. While the open MCP standard provides a predictable way for models to discover tools, [implementing it against Lever's API](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) requires working around several ATS-specific architectural patterns. 

If you decide to build a custom integration, you will encounter the following Lever-specific integration challenges that break standard REST assumptions.

### The Opportunity-Centric Data Model
AI models intuitively assume a flat "Candidate" or "User" data model. Lever, however, uses an "Opportunity-Centric" model. A single human being (a Contact) can have multiple concurrent or historical Opportunities (applications to specific jobs). If an LLM tries to "Update John Doe's status," your MCP server must somehow resolve which specific Opportunity ID the user is referring to. Truto's auto-generated tools flatten these concepts intelligently, but when building this yourself, you must parse the LLM's intent to distinguish between `contact_id` and `opportunity_id`.

### The Two-Step File Upload Dance
When an LLM wants to apply a candidate to a posting and attach a resume, it cannot simply send a binary file or a base64 string directly to the application endpoint. Lever requires a multi-step orchestration: you must first upload the document to a temporary staging endpoint, receive a secure `uri` back, and then pass that `uri` in the payload of the subsequent application or resume attachment API call. Handling this statefully within a single LLM tool-calling loop requires custom chaining logic.

### Form Field Validation on Postings
Applying a candidate to a job posting via the API (on their behalf) requires strict adherence to the application questions defined on that specific posting. If the job posting requires a portfolio link, and the LLM omits it, the API will reject the application. An MCP server must first fetch the application schema for the posting, feed it to the context window, and force the LLM to structure the application payload accordingly.

### HTTP 429 Rate Limits and the IETF Spec
Lever strictly enforces API rate limits. When integrating AI agents, which can rapidly fire sequential tool calls, you will hit these limits. 

Factual note on rate limits: Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream Lever API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes Lever's native rate limit information into standardized headers (`ratelimit-limit`, `ratelimit-remaining`, `ratelimit-reset`) per the IETF specification. The caller (the AI agent framework or ChatGPT) is responsible for implementing retry and backoff logic based on these headers. This ensures your agent is aware of the upstream constraint rather than hanging indefinitely on silent retries.

## How to Generate a Lever MCP Server with Truto

Truto derives MCP tools dynamically from the Lever integration's documentation and resource definitions. Rather than hard-coding tool definitions, Truto translates the Lever API endpoints into a JSON-RPC 2.0 format that ChatGPT natively understands.

Each MCP server is scoped to a single connected Lever account. The resulting server URL contains a cryptographic token that securely encapsulates authentication, routing, and tool filtering.

Here are the two ways to create a Lever MCP server using Truto.

### Method 1: Via the Truto UI

If you prefer a visual interface, you can generate the MCP server in a few clicks:

1. Log into your Truto dashboard and connect a Lever account.
2. Navigate to the **Integrated Accounts** page for your Lever connection.
3. Click the **MCP Servers** tab.
4. Click **Create MCP Server**.
5. Select your desired configuration. You can filter by methods (e.g., `read`, `write`) or by tags (e.g., `opportunities`, `interviews`) to restrict what ChatGPT can access.
6. Click Save and **copy the generated MCP server URL**. Treat this URL as a sensitive credential.

### Method 2: Via the API

For production workflows, you can programmatically generate MCP servers. This is ideal if you are deploying multi-tenant AI agents and need to spin up isolated toolsets for different customers.

Send a `POST` request to `/integrated-account/:id/mcp` with your filtering configuration:

```bash
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 Lever Access",
    "config": {
      "methods": ["read", "write", "custom"],
      "tags": ["opportunities", "interviews", "postings"]
    }
  }'
```

The API will return a JSON object containing the secure URL:

```json
{
  "id": "mcp_123abc",
  "name": "ChatGPT Lever Access",
  "config": { 
    "methods": ["read", "write", "custom"],
    "tags": ["opportunities", "interviews", "postings"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f67890"
}
```

This `url` is all you need to connect ChatGPT to Lever.

## Connecting the MCP Server to ChatGPT

Once you have the Truto MCP URL, you need to register it with your ChatGPT environment. The MCP server handles JSON-RPC 2.0 communication over Server-Sent Events (SSE) or standard HTTP POST, flattening Lever's query and body schemas into a single namespace for the model.

Here are the two ways to connect it.

### Method A: Via the ChatGPT UI

If you are using a ChatGPT Pro, Plus, Business, Enterprise, or Education account, you can add custom connectors directly in the application interface:

1. In ChatGPT, navigate to **Settings** -> **Apps** -> **Advanced settings**.
2. Ensure that **Developer mode** is toggled on (MCP support requires this flag).
3. Under the **MCP servers / Custom connectors** section, click **Add new server**.
4. Enter a descriptive name (e.g., "Lever ATS Server").
5. Paste the Truto MCP `url` you generated earlier.
6. Click **Save**.

ChatGPT will immediately ping the endpoint, execute the `tools/list` handshake, and populate your context window with the available Lever tools.

### Method B: Via Manual Config File (for local or framework-driven agents)

If you are running a custom agent framework alongside ChatGPT (like an internal LangChain or LlamaIndex instance using the OpenAI API), you can configure the MCP server using a JSON configuration file. Use the `@modelcontextprotocol/server-sse` transport wrapper to bridge the HTTP endpoint.

Create an `mcp-config.json` file:

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

Your agent runtime will use this configuration to discover tools and route LLM function calls directly to Truto's proxy handlers.

## Lever Hero Tools for ChatGPT

By default, Truto translates every documented endpoint in the Lever integration into a discrete tool. To prevent overwhelming the model's context window, it is highly recommended to filter your MCP server down to the highest-leverage operations.

Here are the hero tools you should expose for a full-cycle hiring assistant.

### list_all_lever_opportunities
Fetches a list of all pipeline opportunities. This is the foundational tool for reading candidate state. It returns the opportunity ID, candidate name, stage, and origin. 

*Contextual Note*: Because Lever can return hundreds of opportunities, Truto automatically injects `limit` and `next_cursor` fields into the tool schema. The description explicitly instructs ChatGPT to pass the cursor back unmodified to handle pagination.

> "Find all active opportunities currently in the 'Onsite Interview' stage for the Senior Backend Engineer role."

### lever_opportunities_move
Moves a Lever opportunity to a new pipeline stage. This is a critical write operation for progressing candidates through the hiring lifecycle.

*Contextual Note*: This tool requires an `opportunity_id` and the destination `stage` ID. The API returns a `noteId` corresponding to the system note generated by the stage change, not the full opportunity object.

> "Move Jane Smith's opportunity (id: opp_456) to the 'Offer Extended' stage."

### create_a_lever_posting
Creates a new job posting in Lever. This allows the AI agent to draft and publish job descriptions based on intake notes from hiring managers.

*Contextual Note*: Creating a posting via the API bypasses Lever's internal approval chains and cannot be marked as confidential. You must supply the `text` (title) and categorize it by team, department, and location.

> "Create a new job posting for a 'Staff Cloud Architect' based in Remote - US, within the Engineering department. Set the state to draft."

### lever_postings_apply
Applies a candidate to a specific job posting on their behalf. 

*Contextual Note*: This is an advanced tool. The posting must be in a 'published' or 'internal' state. If the posting requires a resume file, the agent must have previously called `create_a_lever_upload` to retrieve a file URI, which it then passes into this tool's payload.

> "Submit an application for John Doe to the 'Staff Cloud Architect' posting. Use the file URI 'uri_789' for his resume."

### list_all_lever_interviews
Retrieves the interview schedule and panel details for a specific opportunity.

*Contextual Note*: This tool requires the `opportunity_id`. It returns extensive metadata including interviewers, duration, location, and timezone, enabling ChatGPT to cross-reference candidate availability or brief hiring managers.

> "Get the interview schedule for candidate ID opp_123 and tell me who is on their technical panel tomorrow."

### create_a_lever_interview
Creates a new interview for a Lever opportunity on an existing panel.

*Contextual Note*: New interviews can only be scheduled on panels where `externallyManaged` is true. The agent must supply the `opportunity_id` and the `panel` identifier.

> "Schedule a 45-minute technical screen for candidate opp_123 on the externally managed Engineering panel. Set the interviewers to Alice and Bob."

### create_a_lever_feedback
Submits a feedback form (scorecard) for a specific opportunity. 

*Contextual Note*: This tool requires an array of `fields` representing the specific questions on the feedback form. It is highly effective when ChatGPT is used to transcribe and summarize interview notes, subsequently logging the structured feedback directly into the ATS.

> "Log interview feedback for candidate opp_123. The candidate demonstrated strong system design skills. Submit a 'Strong Yes' rating for technical aptitude."

To view the full inventory of Lever tools and their exact JSON schemas, visit the [Lever integration page](https://truto.one/integrations/detail/lever).

## Workflows in Action

Once the MCP server is connected, ChatGPT can sequence these tools together to execute multi-step recruitment workflows autonomously. Here are two concrete examples.

### Scenario 1: Candidate Stage Progression and Interview Scheduling

Recruiters frequently ask ChatGPT to manage administrative tasks following a successful initial call.

> "Jane Smith passed her recruiter screen. Move her opportunity to the 'Technical Screen' stage and schedule a 60-minute interview on the Engineering panel for tomorrow."

**Tool Execution Sequence:**
1. **`list_all_lever_opportunities`**: ChatGPT searches for "Jane Smith" to retrieve her unique `opportunity_id`.
2. **`lever_opportunities_move`**: The agent calls the move tool, passing the `opportunity_id` and the ID for the "Technical Screen" stage.
3. **`create_a_lever_interview`**: The agent schedules the event, specifying the duration and panel.

**The Result:** The LLM responds confirming the stage has been updated and the interview has been created, without the recruiter ever opening the Lever interface.

```mermaid
sequenceDiagram
    autonumber
    participant User as "ChatGPT User"
    participant LLM as "ChatGPT"
    participant Truto as "Truto MCP Server"
    participant Upstream as "Upstream API (Lever)"

    User->>LLM: "Move Jane Smith to Tech Screen and schedule interview."
    LLM->>Truto: Call list_all_lever_opportunities<br>{"name": "Jane Smith"}
    Truto->>Upstream: GET /opportunities?name=Jane%20Smith
    Upstream-->>Truto: Return opportunity_id (opp_123)
    Truto-->>LLM: JSON Result
    
    LLM->>Truto: Call lever_opportunities_move<br>{"opportunity_id": "opp_123", "stage": "tech_screen"}
    Truto->>Upstream: POST /opportunities/opp_123/stage
    Upstream-->>Truto: 200 OK (noteId)
    Truto-->>LLM: JSON Result
    
    LLM->>Truto: Call create_a_lever_interview<br>{"opportunity_id": "opp_123", "duration": 60}
    Truto->>Upstream: POST /opportunities/opp_123/interviews
    Upstream-->>Truto: 200 OK (interview details)
    Truto-->>LLM: JSON Result
    
    LLM-->>User: "Jane Smith moved successfully. Interview scheduled."
```

### Scenario 2: Job Posting and Automated Application Processing

For high-volume hiring or internal mobility, you might want ChatGPT to create a role and immediately queue a candidate for it.

> "We need a new posting for a Senior Data Scientist in New York. Draft the posting and apply our internal candidate, John Doe, using his resume file ID."

**Tool Execution Sequence:**
1. **`create_a_lever_posting`**: ChatGPT drafts a job description based on its training data and calls the posting tool with the required location and team parameters.
2. **`lever_postings_apply`**: Using the ID of the newly created posting, ChatGPT applies the candidate. Because the prompt provided a resume file ID, the agent injects the URI into the application payload.

**The Result:** A new, formatted job posting is created in a draft state, and John Doe's profile is immediately attached as an opportunity against that posting.

## Security and Access Control

Exposing an ATS to an AI agent requires strict security guardrails. Truto's MCP servers are designed with built-in controls to ensure LLMs cannot access or modify unauthorized data.

*   **Method Filtering**: During server creation, use `config.methods` to restrict the server to specific operations. A `["read"]` filter ensures the agent can query candidate data but cannot create postings or move stages, preventing accidental database modifications.
*   **Tag Filtering**: Use `config.tags` to group and restrict tools. For example, filtering by `["interviews"]` prevents the LLM from accessing sensitive compensation or offer data.
*   **Require API Token Auth**: By default, possessing the MCP URL grants access to the tools. For zero-trust environments, enable `require_api_token_auth: true`. This forces ChatGPT to pass a valid Truto user session or API token in the Authorization header, adding a strict secondary authentication layer.
*   **Automatic Expiration**: When generating an MCP server for a temporary AI workflow, set an `expires_at` ISO datetime. Truto's infrastructure will automatically schedule a cleanup alarm, permanently deleting the server and invalidating the URL at the exact specified time.

If you want to bypass the complexity of custom API orchestration, let Truto handle the integration layer. Connect your Lever account, generate an MCP server, and bring your AI agents to life.