Connect Welcome to the Jungle to Claude: Sync Pipeline & Recruiting

If your talent acquisition team needs to connect Welcome to the Jungle to Claude to automate candidate sourcing, pipeline management, or offer tracking, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between Claude's natural language tool calls and Welcome to the Jungle's REST API. 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 /connect-welcome-to-the-jungle-to-chatgpt-manage-jobs-candidates/ or explore our broader architectural overview on /connect-welcome-to-the-jungle-to-ai-agents-automate-hiring-flows/.

Giving a Large Language Model (LLM) read and write access to an Applicant Tracking System (ATS) like Welcome to the Jungle is an engineering challenge. You must handle token lifecycles, map nested JSON schemas to MCP tool definitions, and deal with Welcome to the Jungle's highly relational data models. Every time the vendor updates an endpoint or changes a required field, you must 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 Welcome to the Jungle, connect it natively to Claude, and execute complex recruitment workflows using natural language.

The Engineering Reality of the Welcome to the Jungle 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 B2B APIs is painful. Welcome to the Jungle is built to manage complex organizational structures, multistage pipelines, and rich media assets. Its API reflects that complexity.

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

Reference-Based Identifiers Over Standard UUIDs Welcome to the Jungle does not strictly rely on standard integer IDs or standard UUIDs for its primary operations. Instead, core entities use a reference string. When updating a job or a candidate, the payload requires a job_reference or candidate_reference. An LLM does not natively know the difference between an internal ID and a reference string. A custom integration must explicitly map these fields in the tool descriptions to prevent the model from hallucinating or passing the wrong identifier type.

Strict Relational Dependencies for Write Operations Creating a job in Welcome to the Jungle is not a simple flat JSON payload. The API enforces strict relational integrity. You cannot simply pass "contract_type": "Full Time". You must first query the list_all_welcome_to_the_jungle_job_dependencies and list_all_welcome_to_the_jungle_languages endpoints to retrieve the exact reference codes accepted by the connected workspace. Furthermore, a job must be tied to at least one valid office attribute (e.g., office_id). Managing these multi-step lookups requires rigorous schema definitions so the LLM knows to query dependencies before attempting a POST request.

Handling File Attachments via Remote URLs ATS integrations are heavily reliant on resumes and portfolios. However, the Welcome to the Jungle API handles file attachments differently than standard multipart form uploads. To attach a document to a candidate profile, you must use a dedicated endpoint and pass an array of remote_file_urls. Your MCP server must be capable of receiving a file instruction from the LLM, hosting or pointing to a valid remote URL, and orchestrating the attachment payload correctly.

Rate Limits and 429 Responses Like any enterprise SaaS, Welcome to the Jungle enforces API quotas. Truto handles this cleanly: Truto does not automatically retry, throttle, or absorb rate limit errors. When the upstream Welcome to the Jungle API returns an HTTP 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit information into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). Your MCP client or orchestrator is entirely responsible for implementing the retry and backoff logic based on these headers.

Generating the Welcome to the Jungle MCP Server

Instead of writing boilerplate JSON-RPC handlers and manually mapping the Welcome to the Jungle OpenAPI spec to MCP tools, you can use Truto to generate a managed server endpoint. Truto dynamically derives tools directly from the integration's documented API endpoints, ensuring Claude always has access to accurate schemas.

You can create an MCP server in Truto using either the UI or the API.

Method 1: Via the Truto UI

For teams managing integrations manually, the Truto dashboard provides a quick setup path:

1. Navigate to the Integrated Accounts page in your Truto dashboard and select your connected Welcome to the Jungle account.
2. Click the MCP Servers tab.
3. Click Create MCP Server.
4. Configure the server name, allowed methods (e.g., read-only or read/write), and optional expiration dates.
5. Click Save and copy the generated MCP server URL.

Method 2: Via the Truto API

For platform engineers who want to provision MCP servers programmatically, you can create a server by making a POST request to the Truto API.

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": "Welcome to the Jungle Recruiting Server",
    "config": {
      "methods": ["read", "write"],
      "tags": ["recruiting", "pipeline"]
    }
  }'

The API returns a secure, hashed token URL. This URL encapsulates the routing, authentication, and integration context required to communicate with Welcome to the Jungle.

Connecting the MCP Server to Claude

Once you have the Truto MCP Server URL, you must connect it to Claude. You can do this via the Claude Desktop UI or by editing the configuration file.

Method A: Via the Claude UI

If you are using an MCP-compatible client that supports UI configuration (like the ChatGPT desktop app or certain enterprise Claude setups):

1. Open Settings -> Integrations (or Connectors) -> Add MCP Server.
2. Provide a name (e.g., "Welcome to the Jungle").
3. Paste the Truto MCP URL into the Server URL field.
4. Click Add or Save.

Method B: Via the Configuration File (Claude Desktop)

For Claude Desktop, you configure remote MCP servers by modifying the claude_desktop_config.json file. Truto's endpoint acts as an SSE (Server-Sent Events) transport.

Add the following JSON block to your configuration file:

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

Restart Claude Desktop. Claude will execute the initialize handshake, request the tools/list, and dynamically load the Welcome to the Jungle capabilities.

Welcome to the Jungle Hero Tools

Truto automatically generates descriptive, snake_case tool names based on the integration's resources. When Claude calls a tool, Truto maps the flat JSON arguments provided by the LLM into the required query strings and JSON body payloads expected by Welcome to the Jungle.

Here are the most critical, high-leverage tools available for your agent.

list_all_welcome_to_the_jungle_jobs

This tool retrieves all active jobs for the connected organization. It returns vital metadata including the job's reference, status, contract type, and published dates. It natively supports pagination.

Usage note: Claude must use this tool to find a valid job_reference before it can query or create candidates for a specific role.

"Fetch all open engineering jobs in Welcome to the Jungle and list their references and contract types."

list_all_welcome_to_the_jungle_candidates

Retrieves a list of candidates attached to a specific job. The response includes the candidate's reference, current pipeline stage, origin, and contact profile.

Usage note: Requires the job_reference parameter. This is the primary tool for auditing pipeline health.

"Show me all the candidates currently in the pipeline for the Senior Frontend Developer role."

create_a_welcome_to_the_jungle_candidate

Creates a new candidate profile and assigns them to a specific job.

Usage note: Requires job_reference, email, firstname, and lastname. This tool is highly effective for automating inbound sourcing flows where Claude parses resumes from an inbox and pushes the data directly into the ATS.

"Create a new candidate named Alice Smith (alice@example.com) for the Product Manager job. Add a note that she was referred by an employee."

update_a_welcome_to_the_jungle_candidate_by_id

Updates an existing candidate record. This tool is primarily used to advance candidates through the hiring pipeline by updating their stage_id or marking them as archived.

Usage note: The id parameter here expects the candidate's reference string, not a numerical ID.

"Move Alice Smith to the 'Technical Interview' stage."

create_a_welcome_to_the_jungle_attachment

Attaches documents (like resumes, cover letters, or code samples) to an existing candidate profile using remote file URLs.

Usage note: Requires the candidate_reference and an array of remote_file_urls containing the filename and accessible URL. Claude can orchestrate this after generating or receiving a document link.

"Attach this PDF resume URL to Alice Smith's candidate profile."

list_all_welcome_to_the_jungle_moves

Tracks candidate pipeline moves across stages, jobs, or organizations. This tool provides an audit trail of how quickly candidates are moving through the hiring funnel.

Usage note: Highly valuable for analytical agents generating time-to-hire reports or identifying pipeline bottlenecks.

"Pull the recent stage movement history for the backend team candidates so we can see where the bottleneck is."

To see the complete schemas, query parameters, and the full inventory of available endpoints, visit the Welcome to the Jungle integration page.

Workflows in Action

Exposing individual endpoints is useful, but the real power of MCP lies in multi-step orchestration. Because Truto standardizes schemas and provides clear descriptions, Claude can reason through complex ATS workflows autonomously.

Scenario 1: Sourcing and Advancing a Candidate

When a recruiter identifies a strong prospect via email or LinkedIn, they can ask Claude to add the prospect to the system and immediately move them to an active screening stage.

"Find the open 'DevOps Engineer' job. Create a candidate profile for Bob Jones (bob@example.com), and move him directly to the 'Phone Screen' stage."

Execution Steps:

1. list_all_welcome_to_the_jungle_jobs: Claude searches for jobs matching "DevOps Engineer" and extracts the correct reference.
2. create_a_welcome_to_the_jungle_candidate: Claude pushes the name and email to the API, using the job reference retrieved in step 1. The API returns the new candidate's reference.
3. update_a_welcome_to_the_jungle_candidate_by_id: Claude uses the candidate reference to patch the record, updating the stage_id to the phone screen stage.

sequenceDiagram
    participant User as User
    participant Claude as Claude Desktop
    participant MCP as Truto MCP Server
    participant WttJ as Welcome to the Jungle API

    User->>Claude: "Add Bob Jones to the DevOps role and move to Phone Screen."
    Claude->>MCP: Call list_all_welcome_to_the_jungle_jobs
    MCP->>WttJ: GET /jobs
    WttJ-->>MCP: Returns jobs list
    MCP-->>Claude: Returns job reference
    Claude->>MCP: Call create_a_welcome_to_the_jungle_candidate
    MCP->>WttJ: POST /candidates
    WttJ-->>MCP: Returns new candidate
    MCP-->>Claude: Returns candidate reference
    Claude->>MCP: Call update_a_welcome_to_the_jungle_candidate_by_id
    MCP->>WttJ: PATCH /candidates/{id}
    WttJ-->>MCP: 200 OK
    MCP-->>Claude: Returns updated record
    Claude-->>User: "Bob Jones added and moved to Phone Screen."

Scenario 2: Pipeline Auditing and Archiving

Hiring managers frequently need to clean up stale pipelines. Claude can identify candidates who haven't moved recently and archive them automatically.

"Check the pipeline for the 'Marketing Manager' role. Find candidates who haven't had any activity in the last 30 days and archive them."

Execution Steps:

1. list_all_welcome_to_the_jungle_jobs: Claude locates the reference for the Marketing Manager position.
2. list_all_welcome_to_the_jungle_candidates: Claude pulls the active roster for that job.
3. list_all_welcome_to_the_jungle_moves: Claude checks the recent movement history to identify candidates with no recent stage changes.
4. update_a_welcome_to_the_jungle_candidate_by_id: For each stale candidate, Claude iterates through the list, setting the archived flag to true.

Claude then provides the user with a natural language summary of exactly who was archived, maintaining full transparency.

Security and Access Control

Giving an AI agent access to sensitive applicant data requires strict governance. Truto MCP servers provide granular controls to restrict what the LLM can see and do:

• Method Filtering: You can lock down the server to specific HTTP verbs. Passing methods: ["read"] during server creation ensures the LLM can only query jobs and candidates, completely eliminating the risk of accidental deletions or unauthorized profile updates.
• Tag Filtering: Integrations in Truto support functional tagging. You can restrict an MCP server using tags: ["recruiting"] so it only exposes endpoints relevant to hiring, hiding administrative or billing resources.
• Secondary Authentication: By enabling require_api_token_auth, possession of the MCP URL is no longer enough. The client must also pass a valid Truto API token in the Authorization header, ensuring only authenticated internal systems can interact with the server.
• Time-to-Live Expirations: Using the expires_at parameter, you can generate temporary MCP servers for contractors or short-lived AI agent tasks. Truto automatically schedules cleanup routines to destroy the access tokens when the time expires.

Decoupling Infrastructure from AI Logic

Building AI agents that interact with Welcome to the Jungle should be an exercise in prompt engineering and workflow design, not API maintenance. By leveraging a managed MCP server, you abstract away the complexities of token refreshes, endpoint tracking, and JSON schema mapping.

Your AI engineers can focus on building intelligent recruiting assistants, while the integration layer handles the strict validation rules and reference lookups required by the Welcome to the Jungle API. The result is a more resilient agent that scales alongside your hiring demands without burying your team in technical debt.