Connect JOIN to ChatGPT: Manage Job Postings and Applications

If you need to connect JOIN to ChatGPT to automate applicant tracking workflows, manage job postings, or orchestrate candidate screening, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and JOIN's 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 Claude, check out our guide on connecting JOIN to Claude or explore our broader architectural overview on connecting JOIN to AI Agents.

Giving a Large Language Model (LLM) read and write access to a recruitment platform like JOIN is a significant engineering challenge. You have to handle complex candidate data payloads, map dynamic application stages to MCP tool definitions, and deal with highly specific file download signature protocols for resumes and attachments. Every time JOIN updates their API or you need to support a new candidate workflow, your custom server code must be updated, redeployed, and tested.

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

The Engineering Reality of the JOIN 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, implementing it against JOIN's highly specific ATS endpoints is exceptionally painful.

If you decide to build a custom MCP server for JOIN, you own the entire API lifecycle. Here are the specific integration challenges that break standard CRUD assumptions when working with JOIN:

The "Content" Toggle on Job Endpoints

When an LLM asks "Get me the job description and salary for the Senior Engineer role," a standard GET to the JOIN jobs endpoint will return empty fields for the most critical data. By default, the list and get operations in JOIN return minimal metadata (status, ID, title, office). To retrieve the actual job description, salary, contact person, and category data, the client must pass an undocumented or easily-missed content=true query parameter. If your MCP server doesn't force this context, the LLM will hallucinate job details because the API quietly omitted them.

Cryptographic Signatures for File Downloads

Downloading a candidate's resume or cover letter is not as simple as hitting a /files/{id} endpoint. JOIN protects application attachments using a cryptographic signature (sig) appended to the file URL in the application detail response. To successfully download an attachment via the API, your tool must extract the attachment_id, the external_file_name, and the sig from the application payload, and pass them exactly as required to the download endpoint. If your tool schemas do not explicitly instruct the LLM on how to parse and pass this signature, document retrieval will fail with a 403 Forbidden error.

Exclusive and Conflicting Application Filters

Filtering candidate applications in JOIN involves strict endpoint validation rules. If an LLM attempts to filter applications by stageType, the API will reject the request unless hiringState is also explicitly provided. Furthermore, the legacy state filter is deprecated and will throw an error if combined with the newer filtering parameters. Building a static MCP schema means you must write complex input validation to ensure the LLM does not generate conflicting query parameters that trigger 400 Bad Request errors from JOIN.

Creating the JOIN MCP Server

Truto eliminates these headaches by dynamically generating tool definitions directly from validated documentation and integration schemas. A single API call or UI action generates a secure, self-contained MCP server URL scoped exclusively to a specific JOIN account.

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

Method 1: Via the Truto UI

For teams who prefer a visual interface, you can generate an MCP server directly from the dashboard:

1. Navigate to the Integrated Accounts page in your Truto dashboard.
2. Select your connected JOIN integrated account.
3. Click the MCP Servers tab.
4. Click Create MCP Server.
5. Select your desired configuration (name, allowed methods like read or write, and specific tag filters).
6. Copy the generated MCP server URL. Treat this URL as a sensitive secret.

Method 2: Via the Truto API

For teams building automated deployment pipelines, you can provision the MCP server programmatically. You need the integrated_account_id of your connected JOIN instance.

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": "JOIN Recruitment Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["candidates", "jobs", "applications"]
    }
  }'

The API returns a secure, cryptographically hashed token URL:

{
  "id": "mcp_123abc",
  "name": "JOIN Recruitment Agent",
  "config": { 
    "methods": ["read", "write"],
    "tags": ["candidates", "jobs", "applications"]
  },
  "expires_at": null,
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6..."
}

This single url handles all JSON-RPC 2.0 routing, authentication, and tool execution.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you can connect it to ChatGPT. You have two primary methods depending on your environment.

Method 1: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the server directly via the interface:

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Enable Developer mode.
3. Under MCP servers / Custom connectors, click Add new server.
4. Name: Enter a descriptive name (e.g., "JOIN ATS").
5. Server URL: Paste the Truto MCP URL (https://api.truto.one/mcp/...).
6. Click Save.

ChatGPT will immediately perform the MCP handshake, discover the JOIN tools, and surface them to the model.

Method 2: Via Manual Config File

If you are orchestrating an AI agent framework locally or using an SSE-based client connector, you can define the server in your MCP configuration file using the standard SSE command.

Create or update your mcp-config.json (or your client's respective config file) to use the @modelcontextprotocol/server-sse transport:

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

When your agent boots, it will execute the npx command, establish a Server-Sent Events connection to the Truto MCP URL, and pull the dynamically generated tool schemas.

Handling JOIN API Rate Limits in Truto

When exposing an ATS to an LLM, the model can easily trigger rate limits by iterating through hundreds of candidate profiles or polling for application updates.

It is critical to understand that Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream JOIN API returns an HTTP 429 Too Many Requests error, Truto passes that error directly back to the caller (your LLM or agent framework).

To make handling this easier, Truto normalizes the upstream rate limit information into standardized headers per the IETF specification:

• ratelimit-limit
• ratelimit-remaining
• ratelimit-reset

The caller (your agent framework) is strictly responsible for interpreting these headers, implementing retry logic, and managing exponential backoff.

Security and Access Control

Handing over full CRUD access to your recruitment pipeline is dangerous. Truto provides four mechanisms to lock down your JOIN MCP server:

• Method Filtering: Restrict the server to safe operations. Setting "methods": ["read"] ensures the LLM can only query data (like list_all_join_jobs) and fundamentally cannot call create_a_join_job or delete_a_join_application_by_id.
• Tag Filtering: Scope the server to specific operational domains. Passing "tags": ["candidates", "scorecards"] completely hides internal office management or employment type tools from the model.
• API Token Authentication: By setting require_api_token_auth: true, the URL itself is no longer sufficient. The connecting client must also pass a valid Truto API token in the Authorization header, providing a second layer of enterprise security.
• Time-to-Live (TTL): Pass an ISO datetime to the expires_at parameter when creating the server. Once the timestamp passes, the server self-destructs - perfect for granting temporary audit access to external AI agents.

Hero Tools for JOIN Operations

Truto automatically generates descriptive, context-rich tools from JOIN's endpoints. Here are the highest-leverage tools available to your ChatGPT agent.

list_all_join_jobs

Retrieves a paginated list of job postings in the JOIN account. Truto automatically passes status=ONLINE,OFFLINE,ARCHIVED and content=true by default, ensuring the LLM receives the full job description, salary data, and screening questions without needing to guess the correct query parameters.

"Fetch all of our currently active engineering job postings, and summarize the key responsibilities listed in their descriptions."

list_all_join_applications

Fetches candidate applications. This tool handles complex filtering, allowing the LLM to search by job ID, hiring state, or pipeline stage. Note that the LLM must obey the schema constraints regarding exclusive filters (e.g., combining stageType with hiringState).

"Find all applications for the Product Manager role that are currently in the 'Interview' stage."

create_a_join_application

Creates a new application by adding a candidate to a specific job. The LLM can pass candidate details (email, first name, last name), optional base64-encoded documents, and source channel data to instantly insert a candidate into the pipeline.

"Take the contact details from this email thread and create a new application for Jane Doe under the Senior Designer job ID."

list_all_join_candidates

Retrieves the core candidate directory for the authenticated company. This tool supports fuzzy search by email or name, making it highly effective for lookups when the LLM only has partial candidate context.

"Search our candidate database for anyone with the email domain '@example.com' and tell me what tags are associated with them."

list_all_join_scorecards

Retrieves all interview scorecards submitted for a specific application. It returns the reviewer details, overall recommendation, and the specific answers to custom scorecard questions, allowing the LLM to summarize interview feedback.

"Get all the interview scorecards for application ID 8472 and write a brief summary of the team's overall impression of the candidate."

join_attachments_download

Downloads the raw binary file (typically a PDF) of an application attachment. The tool schema explicitly guides the LLM to provide the attachment_id, external_file_name, and the cryptographic sig required by JOIN to authenticate the download.

"Download the resume attachment for application ID 9921 using the signature provided in the application metadata, and extract the text."

For the complete inventory of available tools, query parameters, and schema definitions, view the JOIN integration page.

Workflows in Action

By chaining these tools together, ChatGPT can execute multi-step recruitment workflows autonomously. Here are two real-world scenarios.

The Automated Candidate Screener

When managing high-volume roles, recruiters need to quickly summarize applications and review scorecards. ChatGPT can act as an automated screener.

"Find the newest applications for the Data Analyst job. For each candidate, download their resume, summarize their experience, and check if any interview scorecards have been submitted yet."

sequenceDiagram
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant JOIN as JOIN API
    
    ChatGPT->>Truto: Call list_all_join_applications (job_id)
    Truto->>JOIN: GET /applications?jobId=...
    JOIN-->>Truto: Return application list with sigs
    Truto-->>ChatGPT: Return application JSON
    
    loop For each candidate
        ChatGPT->>Truto: Call join_attachments_download (id, name, sig)
        Truto->>JOIN: GET /applications/{id}/attachments/.../?sig=...
        JOIN-->>Truto: Return PDF binary
        Truto-->>ChatGPT: Return resume file
        
        ChatGPT->>Truto: Call list_all_join_scorecards (application_id)
        Truto->>JOIN: GET /applications/{id}/scorecards
        JOIN-->>Truto: Return scorecard data
        Truto-->>ChatGPT: Return reviewer feedback
    end

What the user gets back: ChatGPT provides a structured breakdown for each new applicant, providing a natural-language summary of the downloaded resume alongside an aggregated view of any existing team feedback from the scorecards.

The Sourcing Pipeline Audit

Hiring managers frequently need to audit their candidate pipeline and update tracking tags based on recent activity.

"Search for candidates named 'Michael Smith'. Look up their active applications, check if any notes have been added recently, and update their candidate profile with the tag 'Needs Follow Up'."

sequenceDiagram
    participant ChatGPT as ChatGPT
    participant Truto as Truto MCP
    participant JOIN as JOIN API
    
    ChatGPT->>Truto: Call list_all_join_candidates (name=Michael Smith)
    Truto->>JOIN: GET /candidates?query=Michael%20Smith
    JOIN-->>Truto: Return candidate profile
    Truto-->>ChatGPT: Return candidate JSON
    
    ChatGPT->>Truto: Call list_all_join_notes (candidate_id)
    Truto->>JOIN: GET /candidates/{id}/notes
    JOIN-->>Truto: Return notes history
    Truto-->>ChatGPT: Return note content
    
    ChatGPT->>Truto: Call update_a_join_candidate_by_id (tags)
    Truto->>JOIN: PUT /candidates/{id}
    JOIN-->>Truto: Confirm update
    Truto-->>ChatGPT: Return success

What the user gets back: ChatGPT locates the correct candidate across the entire directory, reads the internal recruiter notes to assess the current status, and seamlessly updates the candidate's tagging taxonomy to trigger the next step in the ATS workflow.

Building Reliable AI Recruitment Workflows

Connecting ChatGPT to JOIN via an MCP server turns a static ATS into a dynamic, agentic recruitment assistant. Instead of forcing your team to navigate complex UIs to download resumes or hunt down interview feedback, they can interact with the pipeline using natural language.

By leveraging Truto, you bypass the complexity of JOIN's cryptographic file signatures, hidden content toggles, and mutually exclusive query filters. Truto handles the schema derivation and secure routing, allowing your engineering team to focus on building great AI workflows rather than maintaining boilerplate API integration code.