Connect Unipile to ChatGPT: Automate Messaging & LinkedIn Recruiting

If you need to connect Unipile to ChatGPT to automate LinkedIn recruiting, orchestrate cross-platform messaging workflows, or manage unified inboxes, you need a Model Context Protocol (MCP) server. This server acts as the translation layer between ChatGPT's tool calls and Unipile'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 Unipile to Claude or explore our broader architectural overview on connecting Unipile to AI Agents.

Giving a Large Language Model (LLM) read and write access to a platform like Unipile is an engineering challenge. Unipile acts as an aggregator itself, normalizing access to LinkedIn, WhatsApp, Instagram, and IMAP providers. Because it abstracts multiple underlying systems, the API surface is massive and full of provider-specific edge cases. Every time Unipile adds support for a new channel or updates a messaging schema, any custom MCP server code you wrote must be updated, tested, and redeployed.

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

The Engineering Reality of the Unipile 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 Unipile's API requires dealing with a specific set of architectural realities.

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

Asynchronous Auth Checkpoints

When integrating accounts through Unipile, you aren't just dealing with standard OAuth 2.0 flows. Connecting platforms like WhatsApp or LinkedIn requires handling asynchronous authentication checkpoints. You have to submit user credentials, wait for a checkpoint response, prompt the user for an MFA code or QR scan (intent_id), and then submit a follow-up request via create_a_unipile_auth_checkpoint. Exposing this flow to an LLM means you have to design stateful, multi-step prompt chains so the model knows how to poll for QR codes and ask the user for OTP inputs.

Abstracted But Leaky Provider Constraints

Unipile does an excellent job of standardizing communication channels into unified resources like /v1/chats and /v1/messages. However, the underlying providers bleed through the abstraction. For example, adding a reaction to a post (create_a_unipile_post_reaction) works entirely differently depending on the network. LinkedIn expects specific string constants (e.g., linkedin_like), while other networks accept Unicode emojis. Furthermore, Instagram caps reactions at 100 per post. Your MCP server must inject these provider-specific constraints into the JSON Schema descriptions so the LLM doesn't hallucinate invalid payload values.

Provider-Imposed Rate Limits

Unipile's API acts as a gateway to heavily rate-limited networks. When you hit a LinkedIn Recruiter search or a mass email send limit, Unipile returns an HTTP 429. Truto does not retry, throttle, or apply backoff on rate limit errors. When the upstream API returns a 429, Truto passes that error directly to the caller. Truto normalizes the upstream rate limit info into standardized IETF headers (ratelimit-limit, ratelimit-remaining, ratelimit-reset). The caller (your MCP client) is entirely responsible for implementing retry logic and backoff. If you build your own server, you must parse these errors and format them in a way the LLM understands, otherwise the agent will infinitely loop on failed requests.

Quickstart: Generating a Unipile MCP Server

Truto's approach to MCP servers is fundamentally different from building custom endpoints. Instead of hand-coding tool definitions, Truto dynamically derives them from integration resource definitions and documentation schemas.

Each MCP server is scoped to a single integrated account. The server URL contains a cryptographic token that handles routing and authentication automatically.

You can generate an MCP server for your connected Unipile account in two ways.

Method 1: Via the Truto UI

1. Log into your Truto dashboard and navigate to the Integrated Accounts page.
2. Select your connected Unipile account.
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 tags (e.g., messaging, recruiting). You can also set an expiration date for temporary access.
6. Copy the generated MCP server URL. Treat this URL as a secret—it provides direct access to the Unipile account.

Method 2: Via the Truto API

For production workflows, you should generate MCP servers programmatically. This allows you to spin up temporary servers for AI agents on the fly.

curl -X POST https://api.truto.one/integrated-account/YOUR_ACCOUNT_ID/mcp \
  -H "Authorization: Bearer $TRUTO_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "Unipile Recruiting Agent",
    "config": {
      "methods": ["read", "write"],
      "tags": ["recruiting", "messaging", "users"]
    },
    "expires_at": "2026-12-31T23:59:59Z"
  }'

The API response will include the cryptographically secure URL:

{
  "id": "mcp_token_abc123",
  "name": "Unipile Recruiting Agent",
  "config": { "methods": ["read", "write"], "tags": ["recruiting", "messaging", "users"] },
  "expires_at": "2026-12-31T23:59:59.000Z",
  "url": "https://api.truto.one/mcp/a1b2c3d4e5f6g7h8..."
}

This URL alone handles authentication and protocol routing. No additional proxy code is required.

Connecting the MCP Server to ChatGPT

Once you have your Truto MCP URL, you need to register it with your ChatGPT environment. You can do this through the OpenAI interface or via a local configuration file for custom agent deployments.

Method A: Via the ChatGPT UI

If you are using ChatGPT Pro, Plus, Business, Enterprise, or Education, you can add the server directly via Developer mode.

1. Open ChatGPT and navigate to Settings -> Apps -> Advanced settings.
2. Toggle Developer mode to ON.
3. Under the custom connectors or MCP servers section, click Add.
4. Enter a recognizable name (e.g., "Unipile Recruiting Integration").
5. Paste the Truto MCP URL (https://api.truto.one/mcp/...) into the Server URL field.
6. Click Save.

ChatGPT will immediately ping the endpoint, initialize the JSON-RPC 2.0 handshake, and download the filtered list of Unipile tools.

Method B: Via Manual Config File

If you are running a custom MCP client, building a desktop application, or wrapping an agent locally, you can use the standard Server-Sent Events (SSE) setup. Create an mcp_config.json file:

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

When your agent boots, it will execute the remote SSE transport and mount the Unipile tools into the LLM's context window.

Hero Tools for Unipile Automation

Truto automatically generates over 100 tools for Unipile based on the underlying API documentation. Instead of overwhelming the LLM with every possible endpoint, you should filter your MCP server to expose only the highest-leverage operations.

Here are six hero tools that unlock powerful Unipile workflows in ChatGPT.

1. Search LinkedIn Recruiter for Candidates

Tool: list_all_unipile_recruiter_search_people

This tool allows the LLM to execute complex candidate searches against a connected LinkedIn Recruiter seat. It supports advanced filters like keywords, locations, skills, current companies, and spotlights.

"Search LinkedIn Recruiter for software engineers located in Berlin who have experience with Rust and Kubernetes. Filter for candidates who are open to work."

2. Extract Rich User Profiles

Tool: get_single_unipile_user_by_id

Once the LLM finds a candidate or prospect, it needs full context to write personalized outreach. This tool retrieves the complete profile as visible to the linked account, including employment history, education, and contact specifics.

"Fetch the full profile details for the user ID 'jane-doe-12345' and summarize her last three engineering roles."

3. Initiate Cross-Platform Chats

Tool: create_a_unipile_chats_send

This is the core execution tool for outreach. It allows the LLM to send the first message to a user on LinkedIn, WhatsApp, or Instagram, starting a new 1-to-1 conversation.

"Send a direct message to user ID 'john-smith-987' on LinkedIn. Keep it under 300 characters, mention his recent work on distributed systems, and ask if he's open to a quick chat about an infrastructure role."

4. Query Universal Inboxes

Tool: list_all_unipile_emails

Unipile isn't just for social networks; it unifies standard email infrastructure as well. This tool allows the agent to pull recent emails, query threads by subject, and check for unread messages across connected providers.

"Check my recent emails from the domain '@acme.com'. Summarize the key points from any threads updated in the last 24 hours."

5. Publish LinkedIn Job Postings

Tool: create_a_unipile_linkedin_job

For HR and talent acquisition teams, this tool allows ChatGPT to draft a job description and push it directly to LinkedIn as a draft posting on behalf of the company page.

"Create a new LinkedIn job posting draft for a 'Senior Product Designer' in London. Use a hybrid workplace type. Set the employment status to full-time and include the job description we just drafted."

6. Search Target Companies

Tool: list_all_unipile_search_search_companies

Ideal for Account-Based Marketing (ABM) and sales prospecting. The LLM can query companies based on industry, headcount range, location, and job postings.

"Find B2B SaaS companies in San Francisco with a headcount between 50 and 200 employees that are currently hiring for sales roles."

For the complete inventory of available Unipile operations, parameter schemas, and payload structures, visit the Unipile integration page.

Workflows in Action

Connecting tools in isolation is helpful, but the real power of MCP lies in autonomous workflow orchestration. Here are two real-world scenarios showing how ChatGPT chains these tools together.

Scenario 1: Automated Sourcing and Outreach

An internal recruiter wants to find backend engineers and immediately initiate personalized outreach based on their specific work history.

User Prompt: "Find 3 backend engineers in New York who work with Go. Read their profiles, draft a personalized 2-sentence LinkedIn message for each highlighting one specific achievement from their current role, and send it."

Step-by-Step Execution:

1. Search: The agent calls list_all_unipile_recruiter_search_people with keywords: "Backend Engineer Go" and location: "New York", limiting the result to 3.
2. Enrich: For each returned user ID, the agent calls get_single_unipile_user_by_id to retrieve their full employment history.
3. Reason: The LLM analyzes the JSON profile data, identifies a relevant achievement (e.g., "Scaled a Go microservice to 10k RPS"), and drafts the personalized text.
4. Execute: The agent calls create_a_unipile_chats_send for each user, injecting the drafted text into the payload to dispatch the LinkedIn message.

sequenceDiagram
    participant User as "Recruiter"
    participant Agent as "ChatGPT (MCP Client)"
    participant Truto as "Truto MCP Server"
    participant Unipile as "Unipile API"

    User->>Agent: Find Go engineers in NY and message them.
    Agent->>Truto: tools/call (list_all_unipile_recruiter_search_people)
    Truto->>Unipile: GET /v1/linkedin/recruiters/search
    Unipile-->>Truto: Return 3 matching profiles
    Truto-->>Agent: JSON response with IDs
    
    loop For each candidate
        Agent->>Truto: tools/call (get_single_unipile_user_by_id)
        Truto->>Unipile: GET /v1/users/{id}
        Unipile-->>Truto: Full profile payload
        Truto-->>Agent: JSON profile data
        Note over Agent: LLM drafts personalized<br>outreach text.
        Agent->>Truto: tools/call (create_a_unipile_chats_send)
        Truto->>Unipile: POST /v1/chats
        Unipile-->>Truto: 201 Created (Message ID)
        Truto-->>Agent: Success confirmation
    end
    
    Agent-->>User: Outreach complete. Sent 3 messages.

Scenario 2: Omnichannel Support Escalation

A customer success manager wants an agent to monitor emails and escalate urgent issues to WhatsApp.

User Prompt: "Check my unread emails. If there is anything from a 'vip-customer.com' domain complaining about downtime, immediately send a WhatsApp message to my manager (ID: 'mgr-456') summarizing the issue."

Step-by-Step Execution:

1. Fetch Inbox: The agent calls list_all_unipile_emails filtered by is_unread: true.
2. Analyze: The LLM reads the sender domains and body snippets. It finds an email from cto@vip-customer.com containing the word "outage".
3. Extract Detail: The agent calls get_single_unipile_email_by_id to get the full thread and stack trace.
4. Escalate: The agent summarizes the technical details and calls create_a_unipile_messages_send targeting the manager's WhatsApp chat ID, delivering a high-priority alert.

Security and Access Control

Exposing an integrated messaging and recruiting platform to an AI model carries risk. Truto provides several mechanisms at the MCP server level to ensure you maintain strict governance over what the LLM can do.

• Method Filtering: When creating the server via config.methods, you can restrict access to read-only operations by passing ["read"]. This allows the LLM to search profiles and read emails, but strictly prevents it from sending messages or creating job posts.
• Tag Filtering: You can restrict the server to specific domains by passing config.tags. For example, setting tags: ["recruiting"] ensures the LLM can only interact with LinkedIn Recruiter endpoints, hiding WhatsApp and email tools entirely.
• Enforced Expiration (expires_at): You can generate ephemeral MCP servers by passing an ISO timestamp. Once the timestamp passes, the distributed scheduling system permanently deletes the underlying token, severing the LLM's access.
• Dual Authentication (require_api_token_auth): By default, the MCP URL acts as a bearer token. For enterprise deployments, setting this flag to true forces the MCP client to also pass a valid Truto user session or API key in the headers, ensuring only authenticated human operators can execute the tools.

Stop Writing Boilerplate Integration Code

Building a custom MCP server for a massive API like Unipile requires handling authentication checkpoints, normalizing erratic provider limits, mapping dynamic schemas, and maintaining infrastructure for rate limits and webhooks.

Truto eliminates this entire class of engineering work. By dynamically generating documentation-driven tools and proxying requests securely, Truto lets your engineering team focus on building better AI agents instead of wrestling with third-party messaging APIs.