LinkedIn
Instagram
WhatsApp
Telegram
Gmail
Outlook
Google Calendar
Join Slack CommunityOne multi-channel API for AI agents: Email, LinkedIn, WhatsApp and beyond
Give your AI agents authenticated access to email, LinkedIn, WhatsApp, Telegram and Instagram - from a single unified API. Acting on behalf of the authenticated user, not a shared system inbox. Native MCP server included.
# Give your agent cross-channel tools
from unipile import UnipileClient
client = UnipileClient(api_key="YOUR_KEY")
# Read email on behalf of the user
emails = client.email.list(
account_id="user_gmail_account"
)
# Send LinkedIn DM on behalf of the user
client.messaging.send(
account_id="user_linkedin_account",
attendee_provider_id="prospect_id",
text="Hello, I saw your post..."
)What is a multi-channel API for AI agents?
AI agents need more than a single inbox to operate at scale. A multi-channel API for AI agents is a unified interface that lets an agent read, send, and manage communications across email, LinkedIn, WhatsApp, Telegram, and Instagram, all from a single integration, acting on behalf of the authenticated user who granted access. Unipile is the only multi-channel API for AI agents that covers professional messaging AND email in a single endpoint, with a native MCP server for email and all other channels.
A multi-channel API for AI agents is an API layer that gives an AI agent authenticated access to multiple communication channels, including email, LinkedIn direct messages, WhatsApp, Telegram, and Instagram, through a single endpoint. The agent acts on behalf of an authenticated user, reading and sending messages from that user's real accounts rather than a generic system inbox. This is the foundational difference between an agent that feels human and one that feels like a bot.
| Channel | Supported | Read | Send | On behalf of user | Agent-only inbox |
|---|---|---|---|---|---|
| Email (Gmail) | On behalf of | ||||
| Email (Outlook) | On behalf of | ||||
| Email (IMAP) | On behalf of | ||||
| On behalf of | |||||
| On behalf of | |||||
| Telegram | On behalf of | ||||
| On behalf of |
Ready to give your AI agent multi-channel access?
Build NowEmail API for AI agents: why single-channel is not enough
An email API for AI agents solves one part of the problem. Your agent can read a Gmail inbox, draft replies, and trigger follow-ups. But the moment a prospect responds on LinkedIn, a customer reaches out on WhatsApp, and a key contact replies only via Telegram - a single-channel agent goes silent. Real-world communication does not happen in a single inbox. That is why a multi-channel API for AI agents has become the architectural standard for production-grade agent stacks in 2026.
Channels do not talk to each other
A prospect might ignore your email but reply to a LinkedIn message within hours. With a single email API, your agent has no visibility into these parallel conversations and cannot coordinate a coherent engagement sequence across channels.
Context is lost between handoffs
When your agent reads an email thread but has no access to the LinkedIn conversation history from the same contact, it produces replies that lack context. A unified messaging API for AI agents eliminates this gap by centralizing all channel signals in one place.
Multiple integrations multiply maintenance cost
Stitching together a separate email API, a LinkedIn API wrapper, a WhatsApp integration, and a Telegram bot creates four authentication flows, four credential stores, and four points of failure. Every platform update breaks a different piece of the stack.
Users expect agents to act on their behalf everywhere
Users who link their accounts expect their AI agent to monitor and respond across all channels, not just email. A unified messaging API for AI agents that acts on behalf of each authenticated user satisfies this expectation without requiring the user to manage separate agent credentials per platform.
What single-channel agents cannot do
Several products address the single-channel email API for AI agents use case - the category includes tools designed to give agents a dedicated mailbox. Unipile takes a different approach: instead of a new inbox, agents access the user's existing linked accounts on behalf of the authenticated user, across every supported channel at once.
Start building a multi-channel agent today - no extra integrations needed.
Start buildingOne API, on behalf of the authenticated user
The fundamental design principle behind Unipile's multi-channel API for AI agents is that every action is taken on behalf of the authenticated user. The agent does not get a system-level key to blast messages at scale. It acts as a delegate of a real person who has explicitly granted access to their LinkedIn account, their Gmail inbox, their WhatsApp account. This distinction matters both for platform compliance and for the quality of the agent's output.
How Unipile Operates
Independent technical intermediary - not a platform partner
Unipile acts as an independent technical intermediary between your application and the communication platforms your users have linked. When an AI agent sends a LinkedIn message or reads a Gmail thread via Unipile, it does so using the credentials of the authenticated user who linked that account - not a shared system credential. Unipile is not affiliated with, endorsed by, or sponsored by LinkedIn, Google, or Meta. Each linked account belongs entirely to the user who authenticated it. The scope of access is limited to what the authenticated user has authorized, and no data is stored in parallel archives outside the scope of the active session.
User links their accounts
Each user connects their own email, LinkedIn, WhatsApp, or other accounts via OAuth or secure credential flow. No shared system keys. Each linked account is scoped to that user.
Agent receives a scoped token
Your AI agent receives an account ID that maps to the user's linked account. All API calls include this ID, ensuring every action is attributed to the correct authenticated user - not the API key holder.
Agent acts on behalf of the user
The agent reads, sends, and manages communications as the user. From the recipient's perspective, the message comes from the user's real account. Platform rate limits and usage policies apply on a per-user basis, not globally.
Build your first agent with proper per-user authentication in minutes.
Build your agent with UnipileSupported channels: Email, LinkedIn, WhatsApp, Telegram, Instagram
The Unipile multi-channel API for AI agents covers the full stack of professional and consumer communication. Each channel is accessible via the same unified API surface, using the same authentication model - on behalf of the authenticated user who linked that account. No separate SDK per platform, no fragmented credential management.
Email - Gmail, Outlook, IMAP
Full email access across Gmail, Outlook, and any IMAP-compatible provider. Agents can read threads, send replies, manage labels, and monitor the inbox via webhooks.
LinkedIn - DMs and InMail
Access LinkedIn direct messages and connection requests via the authenticated user's account. Agents can read conversations, send messages, and retrieve contact profiles.
WhatsApp - Personal and Business
Read and send WhatsApp messages from the user's linked account. Ideal for customer success agents that need to close conversations on the channel where customers are most responsive.
Telegram - Chats and Channels
Access Telegram conversations from the user's linked account. Agents operating in developer-heavy communities or crypto/fintech workflows often find Telegram is the primary async channel.
Instagram - Direct Messages
Read and respond to Instagram DMs from the user's linked Business or Personal account. Key for e-commerce and creator economy agents that handle inbound DM volume at scale.
Messenger - Facebook Messaging
Access Facebook Messenger conversations from the user's linked account. Useful for support agents handling customer inquiries that arrive via Facebook Pages or personal Messenger threads.
The Unipile MCP server for AI agents
The Model Context Protocol (MCP) is the open standard that lets AI agents like Claude, Cursor, and Windsurf connect to external tools via a structured, secure interface. Unipile ships a native MCP server at https://developer.unipile.com/mcp - plug it in once and your agent gains immediate access to all linked email, LinkedIn, WhatsApp, Telegram, and Instagram accounts. No custom SDK required, no bespoke tool definitions to write per channel.
{
"mcpServers": {
"unipile": {
"url": "https://developer.unipile.com/mcp",
"headers": {
"X-API-KEY": "YOUR_UNIPILE_API_KEY"
}
}
}
}Create a Unipile API key
Sign up at dashboard.unipile.com and generate an API key from your workspace settings. This key authenticates your MCP server connection.
Add the MCP server config
In your AI editor (Cursor, Windsurf, Claude Desktop), open the MCP settings file and add the Unipile server entry with your API key in the headers.
Link user accounts
Your users connect their email, LinkedIn, WhatsApp, and other accounts via the Unipile hosted account link flow or your own OAuth implementation.
Give your agent the account IDs
Pass the user's linked account IDs as context to your agent. The MCP tools use these IDs to scope every action to the correct authenticated user.
list_emails
Retrieve email threads from the user's linked inbox - Gmail, Outlook, or IMAP
send_email
Send an email from the user's linked account, with optional attachments
send_linkedin_message
Send a LinkedIn direct message or InMail on behalf of the authenticated user
list_messages
Read messages from any linked channel - WhatsApp, Telegram, Instagram, Messenger
send_message
Send a message on any linked messaging channel on behalf of the authenticated user
search_docs
Query Unipile's developer documentation to assist with integration code generation
One MCP config. All channels. Start building your multi-channel agent today.
Build with MCPAgent use cases: what multi-channel unlocks
The following use cases represent the most common patterns where a multi-channel API for AI agents delivers measurable value over a single-channel approach. Each pattern describes the job the agent performs, why multiple channels are necessary, and how the Unipile unified messaging API enables it.
01
ResearchResearch Agent
02
OutreachOutreach Agent
send_linkedin_message tool, all from the authenticated user's real accounts.
03
TriageInbox Triage Agent
04
CS AgentCustomer Success Agent
05
SalesSales Agent
# Sales agent: qualify via email, engage via LinkedIn
async def qualify_lead(lead, user_accounts):
# Step 1, send qualification email
await client.email.send(
account_id=user_accounts["gmail"],
to=lead["email"],
subject="Quick question about your stack",
body=generate_email(lead)
)
# Step 2, if no reply in 48h, LinkedIn follow-up
if not await check_reply(lead["email"], hours=48):
await client.messaging.send(
account_id=user_accounts["linkedin"],
attendee_provider_id=lead["linkedin_id"],
text=generate_linkedin_msg(lead)
)See all agent use cases on the Unipile website.
Explore AI agent use casesCode: give an agent email + LinkedIn tools
The following examples show how to build a multi-channel AI agent using the Unipile unified messaging API. Both Python and Node.js examples demonstrate reading an email and sending a LinkedIn message from the same authenticated user account, using consistent API call patterns across channels.
import requests
BASE_URL = "https://api1.unipile.com:13465/api/v1"
API_KEY = "YOUR_UNIPILE_API_KEY"
HEADERS = {
"X-API-KEY": API_KEY,
"Content-Type": "application/json"
}
# ---- Tool 1: Read emails on behalf of the authenticated user ----
def list_emails(email_account_id, limit=10):
res = requests.get(
f"{BASE_URL}/emails",
headers=HEADERS,
params={
"account_id": email_account_id,
"limit": limit
}
)
return res.json()
# ---- Tool 2: Send LinkedIn DM on behalf of the authenticated user ----
def send_linkedin_dm(linkedin_account_id, recipient_provider_id, message):
res = requests.post(
f"{BASE_URL}/chats",
headers=HEADERS,
json={
"account_id": linkedin_account_id,
"attendees_ids": [recipient_provider_id],
"text": message
}
)
return res.json()
# ---- Agent orchestration example ----
def run_agent(user):
emails = list_emails(user["email_account_id"])
top_email = emails["items"][0] # get most recent email
# Agent decision: follow up via LinkedIn if email is from a prospect
if is_prospect(top_email):
send_linkedin_dm(
user["linkedin_account_id"],
lookup_linkedin_id(top_email["from"]),
generate_followup(top_email)
)const BASE_URL = 'https://api1.unipile.com:13465/api/v1';
const API_KEY = 'YOUR_UNIPILE_API_KEY';
const headers = {
'X-API-KEY': API_KEY,
'Content-Type': 'application/json'
};
// Tool 1: Read emails on behalf of the authenticated user
async function listEmails(emailAccountId, limit = 10) {
const url = `${BASE_URL}/emails?account_id=${emailAccountId}&limit=${limit}`;
const res = await fetch(url, { headers });
return res.json();
}
// Tool 2: Send LinkedIn DM on behalf of the authenticated user
async function sendLinkedInDM(linkedinAccountId, recipientId, message) {
const res = await fetch(`${BASE_URL}/chats`, {
method: 'POST',
headers,
body: JSON.stringify({
account_id: linkedinAccountId,
attendees_ids: [recipientId],
text: message
})
});
return res.json();
}
// Agent: read email, decide, send LinkedIn DM
async function runAgent(user) {
const { items } = await listEmails(user.emailAccountId);
for (const email of items) {
if (isProspect(email)) {
await sendLinkedInDM(
user.linkedinAccountId,
await lookupLinkedInId(email.from),
generateFollowup(email)
);
}
}
}{
"mcpServers": {
"unipile": {
"url": "https://developer.unipile.com/mcp",
"headers": {
"X-API-KEY": "YOUR_UNIPILE_API_KEY"
}
}
}
}
// Once connected, Claude can use natural language instructions:
// "Read the last 5 emails from john@example.com in my Gmail inbox"
// "Send a LinkedIn message to prospect_id saying hello"
// "Check if there are unread WhatsApp messages from my top 3 contacts"
//
// All actions execute on behalf of the authenticated user
// whose linked account IDs are provided as context.Full API reference and more code examples in the developer docs.
Read the API docsData handling and platform limits
Building AI agents that interact with real user accounts requires careful attention to data handling and platform usage policies. The following compliance blocks describe how Unipile handles data, how it operates relative to the platforms it connects, and the responsibility framework for agent cadence and volume.
Data Handling Note
No parallel data archives - session-scoped access only
Unipile does not store user messages, email content, or message metadata in a parallel archive or independent database outside the scope of the active API session. When your agent retrieves emails, LinkedIn messages, or WhatsApp conversations via the Unipile API, that data is retrieved in real time from the user's linked account and returned in the API response. Unipile is a relay layer - it does not replicate or index user communications independently. Your application is responsible for any storage of retrieved data in compliance with applicable data protection regulations (GDPR, SOC2).
Platform Limits and Responsible Use
Rate limits are relayed from the platform - cadence is your responsibility
Unipile relays the rate limits and usage restrictions imposed by each communication platform (LinkedIn, WhatsApp, Gmail, Outlook, Telegram, Instagram). When an agent sends messages or retrieves data via the Unipile API, the platform's own limits apply. The decision about message cadence, daily send volume, and engagement frequency is entirely a customer-side decision and must be made responsibly by the application developer. Unipile does not endorse, recommend, or guarantee any specific engagement volume. Actions that exceed a platform's acceptable use policy are the developer's responsibility. Unipile is not affiliated with, endorsed by, or sponsored by LinkedIn, Google, or Meta.
GDPR and SOC2 compliance
Unipile's infrastructure is designed with GDPR compliance and SOC2 principles in mind. User account credentials are encrypted at rest. Access tokens are never logged or exposed in API responses.
Per-user account isolation
Each linked account is strictly scoped to the user who authenticated it. There is no cross-user data leakage. An agent operating on user A's account cannot access user B's messages.
Platform-native rate limits
LinkedIn, WhatsApp, Gmail, and other platforms impose their own usage quotas. Unipile surfaces these limits in API error responses. Your agent must implement appropriate back-off and volume control logic.
Multi-channel vs single-channel agent stacks
The table below compares a multi-channel API for AI agents approach (Unipile) against typical single-channel or email-only agent stacks. When you need both a reliable email API for AI agents and LinkedIn or WhatsApp access in one place, the architectural difference becomes clear. The comparison is based on capabilities, not marketing claims. No links to third-party products are included - this is a category comparison.
| Capability | Unipile (multi-channel) | Email-only agent API | DIY multi-integration |
|---|---|---|---|
| Number of channels supported | 6+ (Email, LinkedIn, WhatsApp, Telegram, Instagram, Messenger) | Email only (1 channel) | Variable (depends on integrations built) |
| On behalf of authenticated user | Yes - per-user linked accounts | Varies - some use shared inboxes | Requires custom OAuth per platform |
| Native MCP server | Yes - developer.unipile.com/mcp | Some offer MCP for email only | Must build custom MCP tools per platform |
| LinkedIn messaging access | Yes - DMs and InMail | No | Requires separate LinkedIn integration |
| WhatsApp and Telegram access | Yes - both supported | No | Separate integrations needed per channel |
| Unified API endpoint | Yes - same API structure across all channels | No - email API only | No - fragmented endpoint structures |
| Webhook push notifications | Yes - email and messaging channels | Email webhooks only | Varies per integration |
| Time to multi-channel agent | Hours (1 API key + MCP config) | Days (email only) | Weeks to months per additional channel |
Start building with the only multi-channel API for AI agents that covers email, LinkedIn, WhatsApp and more.
Build your agentMulti-Channel API for AI Agents - FAQ
Common questions about building AI agents with multi-channel communication access - email, LinkedIn, WhatsApp, Telegram, and Instagram via one unified API.
Unipile is the only unified API that lets an AI agent send both email (via Gmail, Outlook, or IMAP) and LinkedIn direct messages from a single integration, acting on behalf of the authenticated user. Unlike email-only agent APIs, Unipile covers all major professional channels in one API key. The MCP server at developer.unipile.com/mcp makes the setup a single config file addition in Claude, Cursor, or Windsurf.
Yes. Unipile's unified messaging API for AI agents gives access to both email accounts (Gmail, Outlook, IMAP) and WhatsApp conversations through a single API endpoint. The agent reads and sends on behalf of the authenticated user who linked those accounts. The same account_id-based pattern is used for both channels - no separate authentication flows or SDKs needed.
Yes. Unipile operates a native MCP (Model Context Protocol) server at developer.unipile.com/mcp. Once connected, AI agents running in Claude Desktop, Cursor, or Windsurf can access all linked channels - including LinkedIn, WhatsApp, email, Telegram, and Instagram - through standard MCP tool calls. No custom tool definitions required per channel. This is the only MCP server for email AND LinkedIn messaging in one config.
The user connects their LinkedIn account via Unipile's account linking flow. This returns a linked account ID scoped to that user. The AI agent then calls the Unipile messaging API with that account_id and the recipient's LinkedIn provider ID. The message is sent from the user's real LinkedIn account - not a shared system credential. Platform usage policies apply on a per-user basis, as a customer-side decision.
It means the AI agent's actions are attributed to the real user account - not to a shared API key or system inbox. When an agent reads a Gmail thread via Unipile, the request uses the OAuth token of the user who linked that Gmail account. When it sends a LinkedIn message, the message appears to come from that user's real profile. Recipients see the user's name, not a bot account. This is the fundamental difference between Unipile and agent-only inbox products.
The Unipile email API supports three providers: Gmail (Google OAuth), Outlook (Microsoft OAuth - covering personal Outlook and Microsoft 365 / Exchange Online), and IMAP (universal fallback for any IMAP-compatible email provider). All three use the same API call structure and the same on-behalf-of authentication model for agent access.
Unipile does not store user messages or email content in a parallel archive outside the active API session. Data retrieved via the API is returned in real time from the user's linked account. Unipile acts as a relay layer - a technical intermediary that does not independently index or archive communications. Your application is responsible for any data storage in compliance with GDPR and applicable data protection regulations.
No. Unipile is not affiliated with, endorsed by, or sponsored by LinkedIn, Google, or Meta. Unipile is an independent technical intermediary. When agents access LinkedIn, Gmail, WhatsApp, or Instagram via Unipile, they do so using the credentials of the authenticated user who explicitly linked that account. Platform rate limits and acceptable use policies apply on a per-user basis and remain the developer's responsibility.
Still have questions about building your multi-channel AI agent? Our team is here to help.
EN 
FR 
ES 
DE 
IT 
BR 
NL 
PL 
TR