REST API Architecture

One Unified REST API for All Channels

Stop juggling multiple API implementations. Unipile provides a single, consistent REST API schema that works across LinkedIn, WhatsApp, Gmail, Outlook, and all major communication platforms. Write once, integrate everywhere.

Build Now API Reference

unified-api.js

// One request structure for all providers

const response = await

fetch('https://api.unipile.com/api/v1/messages', {

method: 'POST',

headers: { 'Authorization': 'Bearer YOUR_TOKEN' },

body: JSON.stringify({

account_id: "acc_123",

attendees: [{ identifier: "contact@example.com" }],

text: "Hello from Unipile!"

})

});

// Same structure works for:

// LinkedIn • WhatsApp • Gmail • Instagram • Telegram

200 OK - Message Sent

Why Unified Matters

The Power of a Unified Schema

See the difference between maintaining multiple API integrations versus using one unified schema. Less code, fewer bugs, faster development.

Native APIs Complex

linkedin-message.js

                            const linkedin = require('linkedin-api-client');
                            await linkedin.messages.create({
                              recipients: ['urn:li:person:abc123'],
                              body: { text: message },
                              messageType: 'MEMBER_TO_MEMBER'
                            });
                        

whatsapp-message.js

                            await fetch(`https://graph.facebook.com/v18.0/${PHONE_ID}/messages`, {
                              method: 'POST',
                              body: JSON.stringify({
                                messaging_product: 'whatsapp',
                                to: phoneNumber,
                                type: 'text',
                                text: { body: message }
                              })
                            });
                        

gmail-message.js

Gmail

                            const gmail = google.gmail({ version: 'v1', auth });
                            const raw = Buffer.from(
                              `To: ${to}\r\nSubject: ${subject}\r\n\r\n${body}`
                            ).toString('base64');
                            await gmail.users.messages.send({
                              userId: 'me', requestBody: { raw }
                            });
                        

With Unipile Recommended

send-message.js

All Providers

                            // One function for ALL messaging platforms
                            async function sendMessage(accountId, recipient, text) {
                              return fetch(`https://api.unipile.com/api/v1/messages`, {
                                method: 'POST',
                                headers: {
                                  'Authorization': `Bearer ${API_KEY}`,
                                  'Content-Type': 'application/json'
                                },
                                body: JSON.stringify({
                                  account_id: accountId,
                                  attendees: [{ identifier: recipient }],
                                  text: text
                                })
                              });
                            }
                            // Works for: LinkedIn, WhatsApp, Gmail, Instagram...
                        

Native APIs

Different SDK for each platform

Inconsistent data formats & responses

Separate auth flows to manage

3x more code to write & maintain

With Unipile

Single codebase for all providers

Unified error handling & responses

Add new channels without code changes

90% less code to maintain

90%

Less code to write
and maintain

1 week

Average integration time
vs. months with native APIs

0

Breaking changes
when adding new providers

Start Building with Unified API

Everything You Need, One API

From messaging to calendars, access all communication features through consistent, well-documented REST endpoints. Same structure, same responses, across all providers.

Messaging

Send, receive, and manage messages across LinkedIn, WhatsApp, Instagram and Telegram.

GET POST PUT DELETE

/api/v1/messages

/api/v1/chats/{chat_id}

Email

Full email management with Gmail, Outlook, and IMAP. Send, read, organize, and track emails.

GET POST PUT DELETE

/api/v1/emails

/api/v1/emails/{email_id}

Calendar

Manage events, schedules, and availability across Google Calendar and Outlook Calendar.

GET POST PUT DELETE

/api/v1/calendar/events

/api/v1/calendar/availability

Profiles

Access contact information, LinkedIn profiles, company data, and relationship insights.

GET POST

/api/v1/users/{identifier}

/api/v1/companies/{id}

Posts

Create and manage posts on LinkedIn and Instagram. Handle comments, reactions, and engagement.

GET POST DELETE

/api/v1/posts/{post_id}

/api/v1/posts/{post_id}/comments

Admin

Manage accounts and webhooks programmatically. Handle connections, authentication, and events.

Explore API Reference

Built for Developers

A production-ready API with enterprise reliability. Ship faster, maintain less, scale confidently.

Save Weeks of Development

Stop building infrastructure. Focus on your product while we handle the complexity.

Without Unipile

Build auth flows per provider

Maintain each integration

Handle API breaking changes

Manage rate limits yourself

With Unipile

Hosted auth out of the box

Zero maintenance burden

We handle all updates

Smart rate limit handling

Direct API Access, No Scraping

API connections to all providers. Faster responses, better reliability, no risk of being blocked.

Clean RESTful Design

Intuitive endpoints following REST best practices. Resource-based URLs, standard HTTP methods, proper status codes.

Smart Rate Limit Handling

Automatic rate limit management across all providers. We queue, retry, and optimize requests so you don't have to.

Comprehensive Documentation

Detailed guides, code examples, and API references for every endpoint. Get started in minutes, not days.

Interactive API explorer

Copy-paste code snippets

Step-by-step tutorials

High Performance

Lightning-fast response times with proven reliability. Built on global infrastructure for speed everywhere.

Ultra-low latency

99.9% uptime over 24 months

Global CDN distribution

Enterprise Security

Bank-level encryption, OAuth 2.0, and SOC 2 compliance. Your data and your users' data stays protected.

GDPR compliant

SOC 2 compliant

Secure token management

Provider abstraction without feature loss

Most aggregation layers flatten features. Unipile does not. The REST API is designed to expose provider-specific capabilities when needed, keep common endpoints consistent, and allow progressive adoption of advanced features.

Shared endpoints for common operations

A basic inbox view uses shared endpoints across all providers for consistent behavior.

Provider-specific routes for advanced features

Advanced LinkedIn actions are available through dedicated routes when you need them.

Raw provider data when required

Access to raw provider data is always available when you need full control or specific metadata.

Example: Flexibility in action

                                
                                Shared Endpoint
                            
                                GET /api/v1/messages
                                # Works across all providers
                            
                                Provider-Specific
                            
                                POST /api/v1/linkedin/invitations
                                # LinkedIn-only features
                            
                                Raw Data
                            
                                GET /api/v1/messages?include_raw=true
                                # Access original provider payload

You choose the level of abstraction.
The API does not force tradeoffs.

Start with simple unified endpoints, add provider-specific features as needed.

Build Now

Quick Start

Start Building in Minutes

Choose your language, install the SDK, and send your first API request. It's that simple. Full documentation and examples included.

Node.js / TypeScript

npm install unipile-node-sdk

Python

pip install requests

cURL / REST

Direct HTTP requests

Documentation

quick-start.js

Get Your API Key Read Full Documentation

6000+ Companies Innovating with Unipile

Trusted by industry leaders

1 API

Streamline operations for all major communication channels

2 Days

Achieve live integration quickly with minimal setup

30%

Reduction in maintenance efforts and resources

Built-In Security and Compliance

Enterprise-grade protection for your data and workflows Learn more about our security

SOC 2 Type II

Certified

Independently audited security controls ensuring data protection and operational integrity.

GDPR

Compliant

Full compliance with European data protection regulations for user privacy.

99.9%

Platform Uptime over the last 24 months

24/7

Global Support with high-performance API

REST API FAQ

Common questions about Unipile's unified REST API architecture

01 What does "unified REST API" mean?

Instead of learning different APIs for each provider (LinkedIn, WhatsApp, Gmail, etc.), you use one consistent schema for all channels. The same request structure, response format, and authentication flow work across every platform — reducing integration time from weeks to days.

02 How many endpoints does the API offer?

Unipile provides ~150 unified endpoints that work across all providers. Without Unipile, you'd need to manage 500+ provider-specific endpoints (each provider has its own API structure). Our unified approach means less code to write, fewer edge cases, and simpler maintenance. Check our full API reference for details.

03 How does authentication work?

All API requests use Bearer token authentication. Simply include your API key in the Authorization header: Authorization: Bearer YOUR_TOKEN. We handle OAuth flows, token refresh, and provider-specific auth complexities automatically.

04 What response format does the API return?

All responses are in JSON format with consistent structure across all providers. You get standardized fields like id, created_at, status, and provider — no need to normalize data from different sources yourself.

05 Are there rate limits on API calls?

Unipile itself has no usage-based fees or artificial rate limits. However, underlying providers (LinkedIn, WhatsApp, etc.) have their own limits. We include built-in safeguards and quotas management to help you stay within provider guidelines and protect your accounts.

06 How do I receive real-time updates?

Use our Webhooks system to receive instant notifications. Configure webhook URLs in your dashboard to get real-time events for new messages, status changes, calendar updates, and more — no polling required. Events are delivered with the same unified schema.

07 What's the API uptime guarantee?

We guarantee 99.9% uptime SLA for all API endpoints. Monitor real-time status at status.unipile.com. Our infrastructure is hosted in Europe with automatic failover and redundancy built in.

08 Can I test the API before committing?

Yes! Sign up for a 7-day free trial with full API access — no credit card required. Test all endpoints, connect real accounts, and build your proof of concept. Our documentation and live support help you get started quickly.

Ready to explore the API? Start building today.

View API Reference