Unipile GitHub: SDKs, Docs, and How to Get Started

If you are evaluating Unipile as a multi-channel messaging and email API, GitHub is the first place most developers look. The Unipile GitHub organization hosts the official developer documentation repository, language-specific SDKs, and issue trackers where the team accepts feedback and bug reports.

This guide explains what lives in the Unipile GitHub ecosystem, how to install and use the official SDKs, what the API covers, and how Unipile compares with a unified messaging platform such as UnifyPort when your channels differ.

What Is in the Unipile GitHub Organization?

The Unipile GitHub profile currently lists six public repositories. The most important ones for integration work are:

• Developer documentation repository — the central hub for guides, API references, and product resources.
• Unipile Node.js SDK — a wrapper for the Unipile API covering LinkedIn, WhatsApp, Email, Telegram, Instagram, Messenger, and X (Twitter).
• Unipile Python SDK — the official Python client for Unipile API v2, currently in beta.
• Unipile PHP SDK — the official PHP client for teams working in Laravel, Symfony, or other PHP stacks.

The organization page points developers to the official documentation site for comprehensive guides and to the SDK repositories for language-specific installation and usage instructions.

Unipile Node.js SDK: Installation and Quick Start

Unipile GitHub: SDKs, Docs & Integration Guide - Unipile Node.js SDK: Installation and Quick Start.

The Node.js SDK is the most mature client and the one most frequently referenced in support threads and integration examples. It requires Node 18 or newer.

Install the SDK

npm install unipile-node-sdk

Authenticate with Your Unipile Credentials

import { UnipileClient } from 'unipile-node-sdk';

const client = new UnipileClient('https://{YOUR_DSN}', '{YOUR_ACCESS_TOKEN}');

The DSN is the endpoint assigned to your Unipile account, and the access token is generated from the dashboard.

Connect a Messaging Account

The SDK supports provider-specific connection methods. For example, to connect a LinkedIn account with username and password:

const response = await client.account.connectLinkedin({
  username: 'your LinkedIn username',
  password: 'your LinkedIn password',
});

Other supported connection methods include:

• connectWhatsapp()
• connectInstagram({ username, password })
• connectMessenger({ username, password })
• connectTelegram()
• connectTwitter({ username, password })

For accounts protected by two-factor authentication or one-time passcodes, the SDK exposes a checkpoint solver:

await client.account.solveCodeCheckpoint({
  account_id: 't5XY4yQzR9WVrlNFyzPMhw',
  provider: 'LINKEDIN',
  code: '******',
});

Send a Message

await client.messaging.sendMessage({
  chat_id: 'vISKyHtDUmagrk6vrnlXhw',
  text: 'Hello World',
});

List Chats with Filters

await client.messaging.getAllChats({
  account_type: 'LINKEDIN',
  account_id: 't5XY4yQzR9WVrlNFyzPMhw',
  limit: 50,
  after: '2024-07-22T12:00:00.000Z',
});

Send File Attachments

const fs = require('fs');
const path = './src/unipile.png';
const fileBuffer = await fs.readFile(path);

await client.messaging.sendMessage({
  chat_id: 'vISKyHtDUmagrk6vrnlXhw',
  text: 'Hello World',
  attachments: [['unipile.png', fileBuffer]],
});

Handle Errors by Type

The SDK throws UnsuccessfulRequestError instances with structured error bodies. You can branch on HTTP status or on the API error type:

try {
  const result = await client.messaging.getAllAttendees({ account_id });
} catch (err) {
  if (err instanceof UnsuccessfulRequestError) {
    const { status, type } = err.body;
    switch (type) {
      case 'errors/invalid_credentials':
        // prompt re-authentication
        break;
      case 'errors/disconnected_account':
        // trigger reconnect flow
        break;
      default:
        // log and retry or surface to user
        break;
    }
  }
}

Call Endpoints Not Yet Packaged in the SDK

For routes that the SDK does not yet wrap, the client exposes a raw request method. This is useful for LinkedIn actions such as following a company or profile:

await client.request.send({
  path: ['linkedin'],
  method: 'POST',
  parameters: { account_id: '!!YOURACCOUNTID!!' },
  body: {
    body: { patch: { $set: { following: true } } },
    account_id: 'dfR-rG0tQfGhfeP2l5_Bdw',
    method: 'POST',
    request_url: 'https://www.linkedin.com/voyager/api',
  },
});

Unipile Python SDK: API v2 Beta

The Unipile Python SDK targets Unipile API v2, which is still in beta. Because the package is not yet published on PyPI, install it directly from GitHub:

pip install git+https://github.com/unipile/unipile-python.git

You can pin a specific branch, tag, or commit if your project requires reproducibility:

pip install git+https://github.com/unipile/unipile-python.git@main

Basic usage follows the standard generated-client pattern:

import unipile

configuration = unipile.Configuration()
configuration.api_key["apiKey"] = "apikey"

api_client = unipile.ApiClient(configuration)
messaging_api = unipile.MessagingApi(api_client)

For endpoint details, the repository directs developers to the Unipile v2 API documentation and the dashboard.

Unipile PHP SDK

Unipile GitHub: SDKs, Docs & Integration Guide - Unipile PHP SDK.

The PHP SDK is listed alongside the Node.js client in the main documentation repository. It follows the same design philosophy: a thin wrapper around the REST API that handles authentication, account connection, messaging, attachments, and profile retrieval without requiring developers to manage raw HTTP calls.

What the Unipile API Covers

Across the SDKs, the Unipile API exposes several functional areas:

Account Connection

• Hosted authentication wizard links for end users
• Custom authentication flows with provider credentials
• Cookie and user-agent based connection for LinkedIn
• Checkpoint and 2FA/OTP resolution
• Account resync for LinkedIn

Messaging

• Start new chats
• Send text messages
• List and retrieve chats
• List attendees in a chat
• Send and retrieve file attachments

User Profiles

• Retrieve a profile by user ID or provider ID
• Retrieve the authenticated account's own profile
• Retrieve LinkedIn company profiles

LinkedIn-Specific Features

• Send InMail
• Send and manage connection invitations
• Create posts and comments
• Add reactions to posts
• List contacts and company profiles

Email

• Retrieve email history
• Send, reply to, and delete emails

Unipile vs. UnifyPort: Which GitHub-Driven Approach Fits?

Both Unipile and UnifyPort reduce the cost of multi-channel messaging, but they optimize for different channel sets and integration styles.

Capability	Unipile	UnifyPort
Primary channels	LinkedIn, WhatsApp, Email, Telegram, Instagram, Messenger, X	Telegram, WhatsApp, LINE, X, Zalo, TikTok
API style	REST with official Node.js, PHP, and Python SDKs	REST with official Node.js, PHP, and Go SDKs
Event delivery	Provider-specific webhooks	Standardized JSON event layer with webhook control plane
Reliability features	Error types and checkpoint handling	Built-in rate limiting, retries with idempotency, failure isolation
Security	Access token and API key	API keys plus HMAC-SHA256 webhook signatures
Best fit	Teams needing deep LinkedIn and email automation	AI agents, CRMs, and ops tools needing normalized events across chat apps

If your product depends heavily on LinkedIn automation or email workflows, Unipile's GitHub SDKs are a strong fit. If your stack is built around chat platforms such as Telegram, WhatsApp, LINE, X, Zalo, or TikTok and you need every provider event normalized into one JSON shape, a unified messaging API like UnifyPort removes more provider-specific plumbing.

For teams already running Telegram-heavy workloads, the Telegram bot guide explains how BotFather and the Bot API work, while the Unipile MCP guide shows how to connect AI agents to multi-channel messaging through Model Context Protocol.

Common Integration Pitfalls

1. Ignoring Checkpoint Handling

LinkedIn and other providers frequently trigger 2FA or OTP challenges. A production integration must handle errors/checkpoint_error and errors/invalid_checkpoint_solution gracefully rather than treating them as fatal failures.

2. Not Pinning SDK Versions

The Python SDK is beta and installed directly from Git. Pin a commit or tag in your requirements file to avoid unexpected breakage.

3. Mixing API Versions

The Node.js SDK targets the stable API, while the Python SDK targets API v2 beta. Verify which API version your dashboard credentials belong to before choosing a client.

4. Overlooking Raw Request Fallbacks

Not every provider route is packaged in the SDKs. The raw request method is the escape hatch, but it requires you to understand the underlying provider endpoint and request shape.

Related reading

• Line of Duty: Series Guide, Cast, Watch Order & Why It Works - A complete guide to Line of Duty: series order, cast, AC-12 storylines, the H mystery, where to watch, and what makes the BBC drama so compelling.
• How to Use LINE: Complete Beginner’s Guide - Learn how to use LINE from setup to advanced features. This guide covers account creation, chats, calls, groups, privacy settings, and multi-channel API integration.

Sources and further reading

• GitHub - unipile/unipile-node-sdk: A Node.js wrapper for Unipile’s API to manage LinkedIn API, WhatsApp API, Email API... - A Node.js wrapper for Unipile’s API to manage LinkedIn API, WhatsApp API, Email API... - unipile/unipile-node-sdk

Frequently Asked Questions

Where is the official Unipile GitHub repository?

The organization is at github.com/unipile. It contains the developer documentation repository and the official SDK repositories.

What SDKs does Unipile provide?

Unipile provides official Node.js, PHP, and Python SDKs. The Node.js and PHP SDKs target the stable API, while the Python SDK targets API v2 beta.

How do I install the Unipile Node.js SDK?

Run npm install unipile-node-sdk in a Node 18+ project, then instantiate UnipileClient with your DSN and access token.

Does Unipile support Telegram and WhatsApp?

Yes. The Node.js SDK includes connection methods for both connectTelegram() and connectWhatsapp(), alongside LinkedIn, Instagram, Messenger, X, and email.

Can I use Unipile with Python?

Yes, but the Python SDK is beta and not yet on PyPI. Install it directly from GitHub with pip install git+https://github.com/unipile/unipile-python.git.

How do I report a bug or request a feature?

Open an issue in the relevant GitHub repository or contact the Unipile support team through the documentation repository.

Conclusion

The Unipile GitHub organization is the practical entry point for developers integrating LinkedIn, WhatsApp, email, and other channels through a single API. The Node.js SDK offers the broadest coverage and the most complete examples, while the PHP and Python clients give teams flexibility in their stack. Understanding the account connection flow, checkpoint handling, and error types will save you significant debugging time.

If your channel mix leans toward chat platforms rather than LinkedIn and email, evaluate whether a normalized event layer matters more than deep provider-specific features. In that case, a platform like UnifyPort can complement or replace a provider-heavy SDK approach by giving every message a consistent JSON shape and a managed webhook pipeline.