--- title: "Connect JOIN to ChatGPT: Manage Job Postings and Applications" slug: connect-join-to-chatgpt-manage-job-postings-and-applications date: 2026-10-07 author: Riya Sethi categories: ["AI & Agents"] excerpt: "Learn how to connect JOIN to ChatGPT using a managed MCP server. Execute complex recruitment workflows, manage job postings, and automate candidate screening." tldr: "Connect JOIN to ChatGPT using Truto's managed MCP server. This guide shows how to bypass JOIN's API quirks, configure secure access, and orchestrate candidate screening and job management workflows via natural language." canonical: https://truto.one/blog/connect-join-to-chatgpt-manage-job-postings-and-applications/ --- # Connect JOIN to ChatGPT: Manage Job Postings and Applications **JOIN in ChatGPT, in about a minute.** The best way to connect JOIN to ChatGPT is Elaichi: connect JOIN to Elaichi once, then add Elaichi to ChatGPT as a connector. Two steps, about a minute, with a 14-day free trial and no credit card required. 1. **Start your free trial.** Create your Elaichi account. 14 days free, no credit card required. 2. **Connect JOIN.** Connect JOIN once in Elaichi. ChatGPT never gets more access than you have. 3. **Add Elaichi to ChatGPT.** In ChatGPT, open Plugins, press +, and paste https://api.elaichi.ai/mcp into Server URL. Sign in and approve. [Start free on Elaichi, 14 days, no credit card required](https://app.elaichi.ai/signup?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=join) ยท [JOIN on Elaichi](https://elaichi.ai/connectors/join/?utm_source=truto.one&utm_medium=referral&utm_campaign=launchpad&utm_content=post_markdown&utm_term=join) *Building JOIN into your own product? The guide below is for you.* --- 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](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/), 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](https://truto.one/connect-join-to-claude-search-candidates-and-analyze-scorecards/) or explore our broader architectural overview on [connecting JOIN to AI Agents](https://truto.one/connect-join-to-ai-agents-automate-the-full-recruitment-lifecycle/). 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. > 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 JOIN API A custom MCP server is a self-hosted integration layer. While the [open MCP standard](https://truto.one/how-to-build-mcp-servers-for-ai-agents-2026-hands-on-architecture-guide/) 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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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. ```bash curl -X POST https://api.truto.one/integrated-account//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: ```json { "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: ```json { "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](https://truto.one/auto-generated-mcp-tools-for-ai-agents-a-2026-architecture-guide/) 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](https://truto.one/integrations/detail/join). ## 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." ```mermaid 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'." ```mermaid 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. > Ready to connect your AI agents to JOIN and 100+ other enterprise APIs? Get started with Truto today. > > [Talk to us](https://truto.one/book-a-demo/)