DEV Community: Miquel Palet

How to Send WhatsApp Messages with One API Call (No Meta Developer App Needed)

Miquel Palet — Wed, 25 Mar 2026 08:00:00 +0000

Integrating WhatsApp's Cloud API directly means navigating five different Meta products, waiting for template approvals, handling webhooks that silently fail, and dealing with docs that contradict themselves.

We just launched WhatsApp support on Zernio, our unified social media API, and I wanted to share how you can start sending WhatsApp messages in under 5 minutes.

The Problem with Direct Integration

To send a WhatsApp message via Meta's Cloud API, you need to:

Create a Meta developer app
Set up a WhatsApp Business Account
Navigate Business Manager to link everything
Register and verify a phone number
Pass App Review
Configure webhooks manually
Handle template approvals and category reclassification

That's 4-6 weeks of work before you send your first production message.

The Shortcut: One API Call

With Zernio, you skip all of that:

No Meta developer app. No Business Manager. Connect your WhatsApp account in one click via Embedded Signup.

npm install @zernio/node

import Zernio from '@zernio/node';

const zernio = new Zernio(); // uses ZERNIO_API_KEY env var

// Step 1: Create a WhatsApp broadcast with a Meta-approved template
const { data: broadcast } = await zernio.broadcasts.createBroadcast({
  body: {
    profileId: 'YOUR_PROFILE_ID',
    accountId: 'YOUR_WHATSAPP_ACCOUNT_ID',
    platform: 'whatsapp',
    name: 'Welcome Campaign',
    template: {
      name: 'hello_world',
      language: 'en'
    }
  }
});

// Step 2: Add recipients by phone number
await zernio.broadcasts.addBroadcastRecipients({
  path: { broadcastId: broadcast.broadcast.id },
  body: {
    phones: ['+1234567890', '+0987654321']
  }
});

// Step 3: Send the broadcast
const { data: result } = await zernio.broadcasts.sendBroadcast({
  path: { broadcastId: broadcast.broadcast.id }
});

console.log(`Sent: ${result.sent}, Failed: ${result.failed}`);

Send Template Messages

WhatsApp requires approved templates for business-initiated conversations (outside the 24h reply window). With Zernio, you can manage templates via API:

import Zernio from '@zernio/node';

const zernio = new Zernio(); // uses ZERNIO_API_KEY env var

// Create a template (submitted to Meta for approval)
await zernio.whatsapp.createWhatsAppTemplate({
  body: {
    accountId: 'YOUR_ACCOUNT_ID',
    name: 'order_shipped',
    category: 'UTILITY',
    language: 'en',
    components: [{
      type: 'BODY',
      text: 'Hi {{1}}, your order #{{2}} has shipped! Track it here: {{3}}'
    }]
  }
});

// Once approved, send it via a broadcast
const { data: broadcast } = await zernio.broadcasts.createBroadcast({
  body: {
    profileId: 'YOUR_PROFILE_ID',
    accountId: 'YOUR_WHATSAPP_ACCOUNT_ID',
    platform: 'whatsapp',
    name: 'Shipping Notification',
    template: {
      name: 'order_shipped',
      language: 'en',
      components: [{
        type: 'body',
        parameters: [
          { type: 'text', text: 'Sarah' },
          { type: 'text', text: '12345' },
          { type: 'text', text: 'https://tracking.example.com/12345' }
        ]
      }]
    }
  }
});

await zernio.broadcasts.addBroadcastRecipients({
  path: { broadcastId: broadcast.broadcast.id },
  body: { phones: ['+1234567890'] }
});

await zernio.broadcasts.sendBroadcast({
  path: { broadcastId: broadcast.broadcast.id }
});

Broadcast to Multiple Recipients

Create a broadcast campaign and send to up to 100 recipients per request:

// Create a broadcast draft
const { data: broadcast } = await zernio.broadcasts.createBroadcast({
  body: {
    profileId: 'YOUR_PROFILE_ID',
    accountId: 'YOUR_WHATSAPP_ACCOUNT_ID',
    platform: 'whatsapp',
    name: 'March Promo',
    template: { name: 'march_sale', language: 'en' }
  }
});

// Add recipients by phone number (auto-creates contacts)
await zernio.broadcasts.addBroadcastRecipients({
  path: { broadcastId: broadcast.broadcast.id },
  body: {
    phones: ['+1111111111', '+2222222222']
  }
});

// Or add existing contacts by ID
await zernio.broadcasts.addBroadcastRecipients({
  path: { broadcastId: broadcast.broadcast.id },
  body: {
    contactIds: ['contact_1', 'contact_2']
  }
});

// Or auto-populate from segment filters (e.g., all contacts tagged "vip")
await zernio.broadcasts.addBroadcastRecipients({
  path: { broadcastId: broadcast.broadcast.id },
  body: { useSegment: true }
});

// Schedule for later instead of sending immediately
await zernio.broadcasts.scheduleBroadcast({
  path: { broadcastId: broadcast.broadcast.id },
  body: { scheduledAt: '2026-04-01T10:00:00.000Z' }
});

What's Included

37 endpoints covering the full WhatsApp surface:

Messaging: text, templates, media (images, video, docs, audio), interactive (buttons, lists), location, contacts
Broadcasts: campaigns with per-user personalization, scheduling, delivery tracking
Contact CRM: bulk import, tags, groups, opt-in tracking, segmentation
Template CRUD: create, list, update, delete (submissions to Meta handled automatically)
Phone numbers: search, purchase, and verify WhatsApp-ready US numbers
Business profile: read and update via API

Pricing

WhatsApp requires the Inbox addon (7-day free trial). Zernio passes through Meta's per-conversation pricing with zero markup, no additional platform fees.

To celebrate the launch, we've reset every expired Inbox trial. If you already used yours, you get a fresh 7 days. If you're mid-trial, we added 7 extra days.

Links

WhatsApp is the 14th platform on Zernio, alongside Instagram, TikTok, YouTube, LinkedIn, X, Facebook, Pinterest, Reddit, Bluesky, Threads, Google Business, Telegram, and Snapchat. Same API format across all of them.

Social Media API for AI Agents: The Complete Integration Guide

Miquel Palet — Sun, 01 Mar 2026 19:08:52 +0000

Autonomous AI agents are rapidly evolving from simple conversational tools into systems that can take real-world actions on behalf of users and businesses. Instead of just answering questions, modern AI agents can schedule tasks, interact with other tools, and automate workflows.

One increasingly important feature is the ability for AI agents to publish and manage content on social media platforms, enabling automated marketing, customer engagement, and real-time communication at scale. From automatically sharing updates and product announcements to responding to messages in real time, AI agents need reliable ways to interact with multiple platforms like Twitter (X), LinkedIn, Instagram, and TikTok.

In this tutorial, you’ll learn how to integrate a unified social media API that allows AI agents to post and interact with social media platforms efficiently. We will also explore the challenges of direct platform integrations, best practices, and the benefits of unified APIs.

Why AI Agents Need a Unified Social Media API

AI agents are designed to operate autonomously and reliably, but integrating directly with social media platforms introduces complexity that can slow down development and reduce system stability.

Tasks such as publishing content and responding to users become harder to manage when each platform requires a separate integration. This is why a unified API is required; it simplifies this process by providing a consistent endpoint and interface that allows AI agents to operate reliably across multiple platforms.

Using Social Media Platform APIs

Direct integrations with individual social media platforms require separate implementations for each service, making development and maintenance difficult as the number of supported platforms grows.

Each platform has its own authentication flow, request structure, rate limits, and error responses, forcing developers to manage multiple integrations instead of focusing on the AI agent itself.

Some of its disadvantages include:

Complex Authentication Workflow

Social media authentication is particularly challenging for AI agents because it often requires browser-based user interaction, which does not align well with automated workflows. Managing token refresh cycles and handling credentials across multiple platforms adds additional operational complexity.
Schema Inconsistencies

Each platform uses different post formats, media requirements, and API responses, making it difficult to build agents that are consistent across multiple networks. Error handling also becomes fragmented, as developers must account for different failure cases and response structures for every platform.

Direct platform APIs may be suitable for platforms that require a single social media integration, but they become increasingly inefficient as soon as multi-platform support is required.

The Unified API Solution

A unified social media API solves these challenges by providing a single endpoint for multiple platforms. Instead of building and maintaining separate integrations, developers can connect once and gain access to many social networks through a consistent interface.

Some of its benefits include:

One Endpoint, Multiple Platforms

A unified API allows you to integrate once and publish content across multiple social media platforms through a single endpoint, eliminating the need to maintain separate integrations for each platform.
Consistent Request and Response Schemas

Unified APIs standardise post formats, media handling, and API responses across all supported platforms, allowing AI agents to operate with predictable inputs and outputs without needing platform-specific logic.
Simplified authentication workflow

Unified APIs typically use API key authentication rather than complex OAuth flows, making them much easier to integrate into automated AI workflows and server-side environments.
Centralised Credential Management

Instead of managing separate credentials for each social platform, unified APIs consolidate authentication into a single configuration, simplifying deployment and maintenance.

How to Integrate a Unified Social Media API with AI Agents

In this section, you will learn how to use popular AI frameworks with Late API, a unified social media API for scheduling and publishing content across 13 social media platforms.

Late is an all-in-one social media scheduling platform that allows you to connect multiple social media accounts and publish posts across them.

To get started, create a Late account and sign in.

Create an API key and save it on your computer. We will need it later while connecting the Late API with AI agents.

Connect your social media accounts to Late so you can manage and publish posts across all platforms.

After connecting your social media accounts via OAuth, you can start writing, posting, and scheduling content directly to your social media platforms.

Late lets you write your post content and attach media files directly from the dashboard.

You can choose when your content should be published: post immediately, schedule for later, add it to a job queue, or save it as a draft.

Once a post is published, you can view its status and preview it directly in the dashboard using the post link.

🎉 Congratulations! You’ve successfully created your first post using the Late dashboard. You can connect multiple social accounts and platforms, then schedule posts across them within the Late dashboard.

Late API Integration with LangChain

LangChain is an open-source framework for building applications and autonomous agents powered by large language models (LLMs). It provides pre-built components that enable you to connect AI models with external tools, APIs, and data sources easily without building everything from scratch.

LangChain is primarily available as libraries in Python and TypeScript. In this section, you will learn how to build an agent that publishes content on your behalf by generating content using AI chat models and posting it on your social media platforms using the Late API.

To get started, create a project folder named social-media-agents.

# contains the JavaScript LangChain agent
mkdir social-media-agents

Next, add a package.json file to the folder using the following code snippet:

npm init -y

Install the necessary project dependencies required for the project.

npm i axios dotenv express @langchain/core @langchain/google

Axios enables the application to send HTTP requests to the Late API, Dotenv loads environment variables such as API keys from a .env file, Express provides a simple server for running and triggering the AI agent, and LangChain enables the agent to generate content using Google Gemini models.

Before we proceed, create a .env file and copy the following credentials into the file:

LATE_API_KEY=
LATE_TWITTER_ACCOUNT_ID=
GOOGLE_API_KEY=

Add an index.js file within the project directory and copy the following imports into the file:

require("dotenv").config();
const axios = require("axios");
const express = require("express");
const { ChatGoogle } = require("@langchain/google");

const app = express();
app.use(express.json());
const model = new ChatGoogle("gemini-2.5-flash");

The code snippet above initialises the Express server and sets up the Google Gemini language model, which will be used to generate content for social media posts.

Copy the following code snippet into the index.js file:

// POST Endpoint to generate and post a tweet
app.get("/twitter/post", async (req, res) => {
 try {
  // 1. Get the topic from the request body (or use a default)
  const topic = "Tech trends in 2026"; // You can replace this with req.body.topic for dynamic input

  console.log(`⏳: Generating tweet about: ${topic}...`);

  // 2. Generate content using Gemini
  const { content } = await model.invoke([
   [
    "system",
    "You are an expert social media manager. Write an engaging tweet about the topic provided. Keep it under 280 characters, use 1-2 relevant hashtags, and do not wrap the output in quotes.",
   ],
   ["human", `Topic: ${topic}`],
  ]);

  console.log(`✅ Tweet Generated:  "${content}"`);

  // 3. Post to X (Twitter) using Late API
  console.log(`⏳: Publishing to Twitter via Late API...`);

  const response = await axios.post(
   "https://getlate.dev/api/v1/posts",
   {
    content: content,
    publishNow: true,
    platforms: [
     {
      platform: "twitter",
      accountId: process.env.LATE_TWITTER_ACCOUNT_ID,
     },
    ],
   },
   {
    headers: {
     Authorization: `Bearer ${process.env.LATE_API_KEY}`,
     "Content-Type": "application/json",
    },
   },
  );

  // 4. Send success response back to the client
  res.status(200).json({
   success: true,
   message: response.data.message,
   tweet: content,
   post: response.data.post,
  });

  console.log(`💬: ${response.data.message}`);
 } catch (error) {
  console.error("Error creating or posting tweet:", error);
  res.status(500).json({
   success: false,
   error: error.message || "An error occurred while posting the tweet.",
  });
 }
});

// Start the server
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
 console.log(`Server running at: http://localhost:${PORT}/twitter/post`);
});

From the code snippet above:

The model.invoke() method generates a Twitter (X) post about a specified topic using the Gemini model.
The generated content is sent to the Late API using Axios to publish the post immediately.
The Express endpoint (/twitter/post) triggers the AI agent to generate and publish content when the route is accessed.
The server returns a JSON response containing the generated post and publishing status.

Late also offers a Node.js SDK that abstracts direct API calls and simplifies publishing across multiple platforms.

https://www.youtube.com/watch?v=fDO_U7iOfVM

Late API Integration with MCP Servers

MCP (Model Context Protocol) servers allow AI tools such as Claude Desktop to securely interact with external services and APIs. They provide a standardised way for AI assistants to access tools like databases, APIs, and automation services through natural language commands.

In this section, you will learn how to integrate Late with a Claude MCP server to schedule and publish posts directly from Claude Desktop using natural language.

Before we proceed, install the uv Python package manager:

# macOS / Linux
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows
powershell -c "irm https://astral.sh/uv/install.ps1 | iex"

Next, download Claude Desktop on your computer.

Sign into the application, and select Settings from the top menu.

Click Developer from the sidebar menu to edit the configuration file (claude_desktop_config.json). Add Late to the configuration file as shown below:

{
    "mcpServers": {
        "late": {
            "command": "uvx",
            "args": ["--from", "late-sdk[mcp]", "late-mcp"],
            "env": {
                "LATE_API_KEY": "your_api_key_here"
            }
        }
    }
}

After updating the configuration file, restart the application to enable the Late API integration in Claude Desktop. Once configured, you can publish and schedule social media posts directly from Claude using natural language commands.

If you encounter any issues, refer to the complete documentation or follow the video guide below.

https://www.youtube.com/watch?v=QqP5gvBPHDA

Best Practices for AI Agent Social Media Posting

When building AI agents that publish to social media platforms, following best practices helps ensure reliability and consistency across all APIs or agents. While you can implement these practices manually, unified social media APIs such as Late handle many of these concerns automatically, reducing the complexity of agent development.

Rate limit handling

AI agents should monitor API rate limits and implement retry strategies such as exponential backoff to prevent failed requests and ensure the agent can continue posting reliably without being blocked by the platform. However, unified platforms like Late provide predictable rate-limit headers and centralised handling, reducing the need to implement platform-specific rate-limit logic.
Content validation

AI-generated posts should be validated before sending them to the API. This includes checking character limits, required fields, supported media formats, and platform-specific constraints to prevent rejected requests. Unified APIs can simplify validation by enforcing standardised request formats and automatically adapting content to platform requirements.
Error handling patterns

AI agents should implement structured error handling that detects failures, logs useful information, and retries requests when appropriate. For instance, Late API returns consistent error responses across platforms, making it easier for AI agents to detect and handle failures predictably.
Scheduling vs immediate posting

AI agents should support both scheduled and real-time posting. Scheduling helps distribute posts evenly and avoid rate limits, while immediate posting is useful for time-sensitive actions such as alerts or live updates. Late offers built-in scheduling capabilities, allowing AI agents to manage both scheduled and immediate posts through a single interface.

Conclusion

AI agents require reliable and simple APIs to autonomously post, monitor, and interact across multiple social media platforms. The Late API simplifies multi-platform management by providing a single endpoint, consistent response schemas, and easy authentication, reducing both development and operational overhead.

With its SDKs and unified design, Late API is ideal for AI workflows, supporting seamless integration with agents and LLMs such as Claude, OpenAI, and Google Studio.

💡

Sign up and get your free API key to enable automated posting, monitoring, and engagement across multiple platforms with your AI agents.

https://www.youtube.com/watch?v=LOuU8BW17UM

How to Integrate Social Media into Your SaaS App

Miquel Palet — Sun, 22 Feb 2026 00:20:15 +0000

Social media integration is fast becoming an essential feature in modern SaaS applications. Whether it is used for authentication (social login) or for enabling users to share milestones and achievements with a single click, integrating social platforms enhances user engagement and product visibility.

But how do you ensure that this integration is seamless and easy to maintain?

In this tutorial, you will learn:

Why social media integration matters for SaaS applications.
How and when to build a custom integration from scratch or use a unified social media API.
A comparison between DIY and unified integration approaches (with code examples).
A real-world example of social media integration in action.

Why Social Media Integration Is Essential for SaaS Apps

In today's competitive SaaS ecosystem, standalone applications are rapidly losing relevance. Modern users expect seamless connectivity between platforms, enabling them to authenticate and share content without friction.

Social media integration allows SaaS apps to offer features such as social login, one-click content sharing, and automated publishing. These capabilities not only improve user experience but also increase product visibility, customer acquisition, and engagement rates.

Social media integration has become a strategic growth lever for SaaS businesses aiming to scale efficiently. Below are some benefits of integrating social media platforms into your SaaS application:

Reduced Onboarding Friction (Social Auth)

One of the biggest growth challenges for any SaaS app is user onboarding friction. Requiring users to create a new username and password increases sign-up drop-off rates and negatively impacts conversion.

By implementing social login through OAuth authentication (such as Login with Google, LinkedIn, or GitHub), users can create an account and access your platform in just a few clicks, reducing bounce rates, improving user acquisition, and enhancing the overall onboarding experience.

In addition to increasing conversion rates, OAuth-based social authentication also reduces password-related support tickets and strengthens account security through trusted identity providers.

Viral Loops and Organic Growth

Social media integration enables SaaS platforms to turn user achievements into organic marketing opportunities. For instance, when users complete milestones such as finishing a project, reaching a fitness goal, generating a report, or maintaining a usage streak, built-in social sharing features allow them to publish these achievements directly to platforms like LinkedIn or X (formerly Twitter).

This type of social media sharing creates a viral growth loop. Each shared milestone exposes your SaaS product to new audiences, generating referral traffic and increasing brand awareness without paid advertising. Over time, this network effect supports product-led growth by transforming existing users into brand advocates and organic acquisition channels.

Data Enrichment and Personalisation

Social media integrations provide access to rich user metadata that would otherwise take months to collect via forms. With user authorisation, you can learn about what your users really want by pulling their professional details or interests to personalise the dashboard or recommend specific features. As a result, this improves user engagement and increases retention rates.

Interoperability with CRMs and CMS Platforms

For many B2B users, social media platforms are an integral part of their workflow. CRMs that do not sync with LinkedIn, marketing tools that cannot post directly to Instagram, or content management systems (CMS) without social sharing functionality feel incomplete.

Integrating social media directly into your SaaS application enables users to manage their professional and social presence without leaving your platform. By eliminating context switching, that is, constantly moving between tabs or apps, you create a seamless user experience that keeps your users engaged and satisfied.

Social media integration across CRMs, marketing tools, and CMS platforms ensures that your SaaS product becomes a central hub for professional workflows, increasing long-term retention.

Social Media Integration: DIY vs Unified API for SaaS Apps

When integrating social media into your SaaS application, you have two main approaches:

Build it Yourself (DIY Integration) - This process involves using the platform's official API and developer documentation directly to implement social authentication and content sharing. It gives you full control over your integration, but processes such as handling multiple endpoints and their rate limits, API updates, and ensuring security compliance will need to be managed by you.
Use a Unified API - Alternatively, you can leverage unified APIs, such as the Late API, to manage these processes for you and even enable you to integrate and interact with multiple social media platforms through a single, consistent interface. A unified API eliminates the need to manage multiple endpoints individually.

Choosing between DIY and unified API integration depends on your team's technical resources, time-to-market goals, and the level of customisation required.

Late is an all-in-one social media scheduling platform that allows you to connect multiple social media accounts and publish posts across them. With its API, you can schedule and publish social media content, including images or videos, across 13 platforms.

The Hidden Costs of DIY Social Media Integration

While a DIY integration may seem cost-effective for small teams or single-platform projects, it often hides substantial long-term engineering costs. These costs arise from constantly adapting to volatile API changes, managing OAuth security at scale, and handling platform-specific requirements and rate limits.

Integrating directly with each native social media API forces your development team to shift focus from building core product features to managing integration overhead. Hidden costs include:

Volatile API Environments: Major platform updates, such as the Facebook v18 and Twitter v1.1 deprecation, can break your integration and force you to rebuild.
Security Scaling: Managing OAuth tokens, encryption, and secrets for thousands of users grows exponentially complex as your app scales.
Infrastructure Overhead: Custom logic is required to handle rate limiting, retries, and error recovery to prevent data loss.
Media Fragmentation: Each platform has unique requirements for images, videos, and file formats, requiring custom processing per network.

When to Choose the DIY Approach

Your core value proposition is the integration: Tools that rely on full platform-specific features, like a LinkedIn-only automation product, require all the platform's API capabilities.
You have a large engineering team: Teams can dedicate engineers specifically to integrations and ongoing maintenance.
Data privacy requirements are strict: Legal or compliance rules may prevent third-party APIs from handling sensitive tokens.
You only need a single platform: For one-off integrations, the complexity of a unified API may outweigh its benefits.

Using a Unified Social Media API (The Modern Approach)

Modern SaaS applications often rely on multiple social media platforms, making DIY integration complex, time-consuming, and maintenance-heavy. A Unified Social Media API abstracts the fragmented APIs of individual platforms into a single, standardised interface, simplifying multi-platform integration.

This approach is particularly beneficial for SaaS products that prioritise rapid time-to-market, as it removes the burden of managing multiple OAuth flows, disparate data schemas, and platform-specific quirks, enabling you to focus on building your core product features.

Some of its advantages include:

Middleware for All Platforms: Unified APIs translate your app's single request into the specific language of each connected social network.
Multi-Platform Efficiency: Ideal for applications that require connectivity across several platforms, reducing maintenance overhead and accelerating deployment.
Complexity Abstraction: Data from TikTok, LinkedIn, Instagram, and other platforms is normalised into a consistent JSON structure, so your application code remains unchanged.
Single Endpoint Architecture: Connect to dozens of platforms through one integration, dramatically reducing codebase size and development complexity.
Hands-Off OAuth Management: The provider handles authentication, token refresh cycles, and user sessions, ensuring seamless access without manual intervention.

When to Choose a Unified API

You are a Lean Startup: You prioritise speed or need to launch your MVP in days instead of months.
Multi-Platform Support is Critical: Ideal for social media schedulers or influencer marketing tools that connect to multiple social media platforms.
Focus on Core Product Features: When you prioritise unique product functionality and core features rather than maintaining individual API integrations.

Comparison Table: DIY vs. Unified API

When developing a SaaS application, choosing between building integrations from scratch or using a unified API is a classic Build vs Buy dilemma. Below is a detailed comparison to help you decide which path fits your product roadmap.

Feature	DIY Approach (Native APIs)	Unified API Approach (Middleware)
Initial Dev Time	High. Weeks/months spent reading documentation for each platform (Meta, LinkedIn, X).	Low. Days spent integrating a single, standardised schema.
Maintenance	Extreme. You must fix breaks every time a platform updates its API or documentation.	None. The provider handles all upstream API changes and versioning.
Feature Depth	Full. Access to every niche endpoint and beta feature the platform offers.	Standardised. Limited to the features supported by the middleware.
Authentication	Complex. You must manage OAuth flows, token refreshes, and secrets for every app.	Simplified. Usually provides pre-built UI component for all platforms.
Scalability	Linear Effort. Adding subsequent platforms takes as much work as the first.	Instant. Adding a new platform usually requires just one line of code change.
Data Consistency	Variable. Every platform returns data in different formats (JSON structures vary wildly).	Normalised. Data is cleaned and mapped to a consistent format regardless of the source.
Rate Limiting	Direct. You deal directly with the platform's limits and headers.	Aggregated. The provider often manages queuing and throttling for you.

Social Media Integration for SaaS Apps (Code Examples)

In this section, you will learn how to authenticate users via LinkedIn, using its API (DIY approach) and a unified API (Late API).

DIY Approach: The LinkedIn Developer Portal

The LinkedIn Developer Portal is where you create and manage applications that can securely access LinkedIn APIs, enabling you to configure authentication, request permissions, and manage access to LinkedIn resources.

To get started, you must create a LinkedIn page that will be linked with the application.

Then, navigate to the LinkedIn Developer Portal to create the application.

Provide your App name, upload the logo, and select your newly created page from the drop-down list to create the app.

Next, verify the LinkedIn page to ensure you authorised linking it with the app.

It will display a dialogue box that asks you to generate the verification URL. Generate it and open the link in your browser to verify the page.

After successfully creating the application, a client ID and primary client secret have been issued for your app's authentication and authorisation. Copy and save them for later.

Finally, click the Products tab and request access to user authentication and sharing of posts on LinkedIn.

Congratulations! You can start authenticating users and creating posts via the LinkedIn API.

LinkedIn API Authentication Workflow

In this section, you will implement the LinkedIn API 3-legged OAuth flow, which involves requesting an authorisation code from LinkedIn, exchanging it for an access token, and using that token to access member data.

Before we proceed, add the following redirect URL to the list of Redirect URLs in your LinkedIn developer dashboard. LinkedIn will send the authorisation code to this URL during this development phase.

http://localhost:3000/auth/linkedin/callback

The examples in this guide are written in JavaScript. Therefore, install the following tools to ensure you can execute the code on your computer:

Node.js - a JavaScript runtime used to run the example code locally. You can download it from the official Node.js website and verify your installation by running node -v in your terminal.
Code editor - any modern code editor will work. This tutorial uses Visual Studio Code, but you can use your preferred editor.

DIY Social Media Integration: LinkedIn API Code Walkthrough

Create a new folder for the project and install a package.json file using the code snippet below:

mkdir linkedin-api-guide
cd linkedin-api-guide
npm init -y

Run the following code snippet in the terminal to install the project dependencies:

npm install axios dotenv express

Add an index.js and .env file to the project directory:

cd linkedin-api-guide
touch index.js .env

Declare the following variables within the .env file and fill it with your credentials:

ACCESS_TOKEN=
CLIENT_ID=<your_LinkedIn_client_ID>
CLIENT_SECRET=<your_LinkedIn_client_secret>
URI=http://localhost:3000/auth/linkedin/callback

Now let's implement the member authorisation (3-legged) workflow.

Copy the following code snippet into the index.js file to import the packages and environment variables:

// Package imports
require("dotenv").config();
const express = require("express");
const axios = require("axios");
const app = express();

// Environment variables
const CLIENT_ID = process.env.CLIENT_ID;
const CLIENT_SECRET = process.env.CLIENT_SECRET;
const REDIRECT_URI = process.env.URI;

The dotenv package loads environment variables from a .env file into your application, keeping sensitive credentials out of your source code. Express provides a lightweight web server for handling OAuth redirects and API routes, while Axios is used to send HTTP requests to LinkedIn's API endpoints.

Add the following code snippet into the index.js file:

app.get("/auth/linkedin", (req, res) => {
  const scope = "openid profile email w_member_social"; // Modern OIDC scopes
  const state = "foobar"; // Use for CSRF protection

  const callbackUrl = `https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&state=${state}&scope=${encodeURIComponent(scope)}`;

  res.redirect(callbackUrl);
});

The code above defines the LinkedIn OAuth authorisation URL, required permission scopes and a state parameter for CSRF protection, then redirects the user to LinkedIn's authorisation page. If the user approves access, LinkedIn redirects them back to your callback URL with an authorisation code.

Next, declare another API route that fetches the user's access token using the auth code and retrieves the user's profile:

app.get("/auth/linkedin/callback", async (req, res) => {
  // 1. Get the code from the URL query parameters
  const code = req.query.code;

  if (!code) {
    return res.status(400).send("Authorization failed: No code provided.");
  }

  try {
    // 2. Exchange the code for an Access Token
    // LinkedIn requires 'application/x-www-form-urlencoded'
    const response = await axios.post(
      "https://www.linkedin.com/oauth/v2/accessToken",
      null,
      {
        params: {
          grant_type: "authorization_code",
          code: code,
          client_id: CLIENT_ID,
          client_secret: CLIENT_SECRET,
          redirect_uri: REDIRECT_URI,
        },
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      },
    );

    const accessToken = response.data.access_token;
    console.log("Access Token:", accessToken);

    // 3. Use the token to get the user's name/email
    const userProfile = await axios.get(
      "https://api.linkedin.com/v2/userinfo",
      {
        headers: { Authorization: `Bearer ${accessToken}` },
      },
    );

    res.json({
      message: "Success!",
      token: accessToken,
      profile: userProfile.data,
    });
  } catch (error) {
    console.error(
      "Error exchanging code:",
      error.response?.data || error.message,
    );
    res.status(500).json(error.response?.data || "Internal Server Error");
  }
});

The authorisation code from LinkedIn is exchanged for an access token, which your application uses to access the user's data.

Finally, add the following code snippet to the file to start the server and run it using node index.js:

// Start the server
app.listen(3000, () =>
  console.log("Server: http://localhost:3000/auth/linkedin"),
);

Here is a sample of the data returned from the authorisation API:

{
  "message": "Success!",
  "token": "AQXs_b_gXF9pXBdwdvmOWEL4TQXKiHWAjnRvP-WNe4nxaIq",
  "profile": {
    "sub": "xzorpyHada",
    "email_verified": true,
    "name": "Jane Doe",
    "locale": {
      "country": "US",
      "language": "en"
    },
    "given_name": "Jane",
    "family_name": "Doe",
    "email": "janedoe@gmail.com",
    "picture": "https://media.licdn.com/dms/image/v2/<image_id>"
  }
}

Note: The code example logs the access token to the console. In a real application, you should store the token securely (for example, in a database or a secure environment variable) rather than saving it directly in your .env file.

Using Late for Social Authentication and Cross-Platform Content Publishing

Late is an all-in-one social media scheduling platform that allows you to connect your social media accounts and publish posts across multiple platforms. In this section, you'll learn how to configure Late to schedule and publish social media posts across multiple platforms.

To get started, create a Late account and sign in.

Create an API key and save it somewhere on your computer.

Connect your social media accounts to Late so you can manage and publish posts across all platforms.

After connecting your social media accounts via OAuth, you can start writing, posting, and scheduling content directly to your social media platforms.

Late lets you write your post content and attach media files directly from the dashboard.

You can choose when your content should be published: post immediately, schedule for later, add it to a job queue, or save it as a draft.

Once a post is published, you can view its status and preview it directly in the dashboard using the post link.

Late API Integration with SaaS Applications

The Late API enables you to integrate social media functionality into your applications via HTTP requests or using its official SDKs. This unified API simplifies cross-platform social media integration, including authentication, content creation, sharing, and scheduling.

The Late API SDK is available in multiple programming languages, making it easy to send HTTP requests to supported endpoints:

npm install @getlatedev/node  # Node.js SDK

pip install late-sdk           # Python SDK

With these SDKs, your SaaS application can connect multiple social media accounts, manage posts, and schedule content across all supported platforms without building individual integrations for each social network.

For detailed instructions and advanced use cases, visit the official documentation.

Real-World Example: How an LMS Added Multi-Platform Social Posting

Consider a learning management system (LMS) and digital e-commerce platform that enables users to create and sell online courses. Their core product is education technology, not social media management. However, course creators need to promote their content across multiple social media platforms to reach learners and maximise revenue.

Using the Late API, the LMS was able to implement cross-platform posting without diverting engineering resources from its core features.

Here is why it worked for them:

Speed to Market: Multi-platform social posting was added in weeks, rather than the 6-12 months a DIY integration would have required.
Focused Resource Allocation: Engineers continued enhancing core features like the course player and quiz functionality, rather than troubleshooting platform-specific API changes.
Maintenance-Free: When X (formerly Twitter) changed its API pricing and structure, Late API handled the updates, keeping the LMS service uninterrupted.
Tangible Result: The platform now offers social promotion as a feature, adding significant value to creators without incurring massive engineering overhead.

Common Social Media Integration Patterns in SaaS

To deliver a seamless user experience, SaaS applications typically adopt one or more proven integration patterns based on their users' workflows. Here are the common patterns that modern SaaS platforms use to implement social media connectivity:

User-Initiated Posting: Users can click a "Share Now" button to publish content to multiple social networks. For instance, users can share their newly earned certificate, a published blog post, or a milestone achievement.
Scheduled and Queued Posting: Users can prepare content in advance and set a future publication date and time. The SaaS backend uses Late API to manage a task queue that posts content at the designated time.
Multi-Account Management: B2B and agency-focused SaaS platforms allow a single user to manage multiple social media profiles for different brands or clients. This pattern requires handling multiple OAuth tokens and platform-specific permissions under a centralised account.
Webhook-Driven Workflows: Automated event-triggers can send a message to the social API when an action occurs in the SaaS app (e.g., a new sale, video upload, or milestone), eliminating manual intervention and creating an intelligent user experience.
Batch Posting (Cross-Platform Distribution): A "write-once, publish-everywhere" pattern lets users push a single piece of content to multiple platforms simultaneously. The integration layer handles platform-specific requirements, such as image resizing or caption formatting, ensuring native appearance on each network.

All of these patterns are fully supported by Late API, making it easy for SaaS developers to implement scalable, multi-platform social media integrations without managing separate endpoints for each platform.

Next Steps

As you have learnt, the decision between a DIY build and a Unified API is a choice between maintenance and innovation. If your SaaS is built entirely around a single social network and requires deep, niche functionality, the DIY approach provides the granular control you need.

However, for most modern SaaS companies where social media integration is a growth lever or a supplementary feature, the Unified API approach is the best. It transforms a months-long engineering project into a plug-and-play utility, allowing you and your team to stay focused on your core product.

With Late API, you can manage 50+ client accounts from a centralised dashboard, implement white-label posting pipelines, and automate reporting and performance tracking.

Sign up and get your free API key to start building modern SaaS apps with powerful, multi-platform social media integration.

The Complete Guide to the LinkedIn API for Developers (2026)

Miquel Palet — Mon, 16 Feb 2026 11:55:02 +0000

LinkedIn is the world's largest professional platform, used for networking, recruiting, sharing content and career development. It offers a feature-rich API that enables you to build integrations for LinkedIn user authentication and verification, content publishing, ads, events, and community management.

However, as a new user, the LinkedIn API can be difficult to work with because it spans multiple products, and access often requires approvals and permission scopes.

Therefore, in this guide, you will learn how to use and integrate the LinkedIn API into your software applications and automation workflows, from user authentication to publishing content. The goal is to turn hours of trial and error into a clear, repeatable process you can apply in your own applications.

How to Access the LinkedIn Developer Portal

To get started, you must create a LinkedIn page that will be linked with the application.

Then, navigate to the LinkedIn Developer Portal to create the application.

Provide your App name, upload the logo, and select your newly created page from the drop-down list to create the app.

Next, verify the LinkedIn page to ensure you authorised linking it with the app.

It will display a dialogue box that asks you to generate the verification URL. Generate it and open the link in your browser to verify the page.

After successfully creating the application, a client ID and primary client secret have been issued for your app's authentication and authorisation. Copy and save them for later.

Finally, click the Products tab and request access to user authentication and sharing of posts on LinkedIn.

Congratulations! You can start authenticating users and creating posts via the LinkedIn API.

How LinkedIn API Authentication and Authorisation Works

The LinkedIn API uses OAuth 2.0 to authorise applications and grant secure access to LinkedIn resources. Before your application can request data or act on behalf of a user, it must complete an OAuth authorisation flow.

LinkedIn supports two authorisation methods:

Member Authorisation (3-legged OAuth): This is the most common flow that grants your application permission to access users' LinkedIn data and perform actions on their behalf.
Application Authorisation (2-legged OAuth): This flow is used when your application does not need access to a specific user's data. Only a few LinkedIn APIs support this method.

In this section, you will implement the 3-legged OAuth flow, which involves requesting an authorisation code from LinkedIn, exchanging it for an access token, and using that token to access member data.

http://localhost:3000/auth/linkedin/callback

Node.js Prerequisites

The examples in this guide were written in JavaScript. Therefore, install the following tools to ensure you can execute the code on your computer:

Node.js - a JavaScript runtime used to run the example code locally. You can download it from the official Node.js website and verify your installation by running node -v in your terminal.
Code editor - any modern code editor will work. This tutorial uses Visual Studio Code, but you can use your preferred editor.

Implementing LinkedIn User Authentication and Authorisation in Node.js

Create a new folder for the project and install a package.json file using the code snippet below:

mkdir linkedin-api-guide
cd linkedin-api-guide
npm init -y

Run the following code snippet in the terminal to install the project dependencies:

npm install axios dotenv express

Add an index.js and .env files to the project directory.

cd linkedin-api-guide
touch index.js .env

Declare the following variables within the .env file and fill it with your credentials.

ACCESS_TOKEN=
CLIENT_ID=<your_LinkedIn_client_ID>
CLIENT_SECRET=<your_LinkedIn_client_secret>
URI=http://localhost:3000/auth/linkedin/callback

Now let's implement the member authorisation (3-legged) workflow.

Copy the following code snippet into the index.js file to import the packages and environment variables.

// Package imports
require("dotenv").config();
const express = require("express");
const axios = require("axios");
const app = express();

// Environment variables
const CLIENT_ID = process.env.CLIENT_ID;
const CLIENT_SECRET = process.env.CLIENT_SECRET;
const REDIRECT_URI = process.env.URI;

Add the following code snippet into the index.js file:

app.get("/auth/linkedin", (req, res) => {
  const scope = "openid profile email w_member_social"; // Modern OIDC scopes
  const state = "foobar"; // Use for CSRF protection

  const callbackUrl = `https://www.linkedin.com/oauth/v2/authorization?response_type=code&client_id=${CLIENT_ID}&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&state=${state}&scope=${encodeURIComponent(scope)}`;

  res.redirect(callbackUrl);
});

Next, declare another API route that fetches the user's access token using the auth code.

app.get("/auth/linkedin/callback", async (req, res) => {
  // 1. Get the code from the URL query parameters
  const code = req.query.code;

  if (!code) {
    return res.status(400).send("Authorization failed: No code provided.");
  }

  try {
    // 2. Make the POST request to exchange the code for an Access Token
    // LinkedIn requires 'application/x-www-form-urlencoded'
    const response = await axios.post(
      "https://www.linkedin.com/oauth/v2/accessToken",
      null,
      {
        params: {
          grant_type: "authorization_code",
          code: code,
          client_id: CLIENT_ID,
          client_secret: CLIENT_SECRET,
          redirect_uri: REDIRECT_URI,
        },
        headers: {
          "Content-Type": "application/x-www-form-urlencoded",
        },
      },
    );

    const accessToken = response.data.access_token;
    console.log("Access Token:", accessToken);

    // 3. (Optional) Immediately use the token to get the user's name/email
    const userProfile = await axios.get(
      "https://api.linkedin.com/v2/userinfo",
      {
        headers: { Authorization: `Bearer ${accessToken}` },
      },
    );

    res.json({
      message: "Success!",
      token: accessToken,
      profile: userProfile.data,
    });
  } catch (error) {
    console.error(
      "Error exchanging code:",
      error.response?.data || error.message,
    );
    res.status(500).json(error.response?.data || "Internal Server Error");
  }
});

The authorisation code from LinkedIn is exchanged for an access token, which your application uses to access the user's data.

Finally, add the following code snippet to the file to start the server and run it using node index.js:

// Start the server
app.listen(3000, () =>
  console.log("Server: http://localhost:3000/auth/linkedin"),
);

Here is a sample of the data returned from the authorisation API:

{
  "message": "Success!",
  "token": "AQXs_b_gXF9pXBdwdvmOWEL4TQXKiHWAjnRvP-WNe4nxaIq",
  "profile": {
    "sub": "xzorpyHada",
    "email_verified": true,
    "name": "Jane Doe",
    "locale": {
      "country": "US",
      "language": "en"
    },
    "given_name": "Jane",
    "family_name": "Doe",
    "email": "janedoe@gmail.com",
    "picture": "https://media.licdn.com/dms/image/v2/<image_id>"
  }
}

Note: The code example logs the access token to the console. In a real application, you should store the token securely (for example, in a database or a secure environment variable) rather than saving it directly in your .env file.

How to Post Content using the LinkedIn API

In this section, you will learn how to post content, including text-only posts, articles, images, and videos on LinkedIn via its API. We'll build on the index.js file from the previous section to add endpoints for creating these posts.

Ensure you have added your access token to its environment variable in the .env file.

Text Only Posts

Add the following code snippet to the index.js file:

app.get("/auth/linkedin/post/share", async (req, res) => {
  const accessToken = process.env.ACCESS_TOKEN;
  message = "Hello LinkedIn!";

  if (!accessToken) {
    return res.status(401).send("Access token required");
  }

  try {
    // STEP 1: Get the Member's ID (Person URN)
    const userResponse = await axios.get(
      "https://api.linkedin.com/v2/userinfo",
      {
        headers: { Authorization: `Bearer ${accessToken}` },
      },
    );

    const personURN = `urn:li:person:${userResponse.data.sub}`;

    // STEP 2: Make the POST request to share
    const shareResponse = await axios.post(
      "https://api.linkedin.com/v2/ugcPosts",
      {
        author: personURN,
        lifecycleState: "PUBLISHED",
        specificContent: {
          "com.linkedin.ugc.ShareContent": {
            shareCommentary: {
              text: message || "Default share text from Node.js!",
            },
            shareMediaCategory: "NONE",
          },
        },
        visibility: {
          "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC",
        },
      },
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
          "X-Restli-Protocol-Version": "2.0.0",
          "Content-Type": "application/json",
        },
      },
    );

    res.status(201).json({
      message: "Post shared successfully!",
      data: shareResponse.data,
    });
  } catch (error) {
    console.error(
      "Error sharing content:",
      error.response?.data || error.message,
    );
    res
      .status(error.response?.status || 500)
      .json(error.response?.data || "Internal Server Error");
  }
});

From the code snippet above, the route first retrieves the member's LinkedIn ID (URN) using the access token, which is required as the author field when creating a post.

It then sends a POST request to LinkedIn's ugcPosts endpoint with the post content, lifecycle state, media category, and visibility settings. If successful, the API returns the created post's data; otherwise, any errors are logged and returned in the response.

Test the endpoint by pointing your Express server to the /auth/linkedin/post/share route.

If successful, it returns the following JSON object:

{
  "message": "Post shared successfully!",
  "data": {
    "id": "urn:li:share:<id>"
  }
}

Articles or URL Posts

To share articles or URLs using the LinkedIn API, update the specificContent object by adding a media array and setting shareMediaCategory to "ARTICLE". This tells LinkedIn that the post contains a link or article rather than just text.

Add a new API endpoint for creating articles or URL posts.

app.get("/auth/linkedin/article/share", async (req, res) => {
  const accessToken = process.env.ACCESS_TOKEN;
  message = "Hello LinkedIn!";

  if (!accessToken) {
    return res.status(401).send("Access token required");
  }

  try {
    const userResponse = await axios.get(
      "https://api.linkedin.com/v2/userinfo",
      {
        headers: { Authorization: `Bearer ${accessToken}` },
      },
    );

    const personURN = `urn:li:person:${userResponse.data.sub}`;

    // Make the POST request to share
    const shareResponse = await axios.post(
      "https://api.linkedin.com/v2/ugcPosts",
      {
        author: personURN,
        lifecycleState: "PUBLISHED",
        specificContent: {
          "com.linkedin.ugc.ShareContent": {
            shareCommentary: {
              text: message || "Default share text from Node.js!",
            },
            shareMediaCategory: "ARTICLE",
            media: [
              {
                status: "READY",
                description: {
                  text: "Official LinkedIn Blog - Your source for insights and information about LinkedIn.",
                },
                originalUrl: "https://blog.linkedin.com/",
                title: {
                  text: "Official LinkedIn Blog",
                },
              },
            ],
          },
        },
        visibility: {
          "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC",
        },
      },
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
          "X-Restli-Protocol-Version": "2.0.0",
          "Content-Type": "application/json",
        },
      },
    );

    res.status(201).json({
      message: "Post shared successfully!",
      data: shareResponse.data,
    });
  } catch (error) {
    console.error(
      "Error sharing content:",
      error.response?.data || error.message,
    );
    res
      .status(error.response?.status || 500)
      .json(error.response?.data || "Internal Server Error");
  }
});

The route retrieves the member's LinkedIn ID (URN), sets shareMediaCategory to "ARTICLE", and includes a media array containing the article's URL, title, and description. The shareCommentary.text field provides the post message that appears above the article preview.

Image or Video Upload

To upload images or videos using the LinkedIn API, you need to register the image or video, upload it to LinkedIn, and create an image or video share.

First, create the register function as shown below:

async function registerMedia(accessToken, personURN, mediaType = "image") {
  const registerUrl =
    "https://api.linkedin.com/v2/assets?action=registerUpload";

  // Use 'feedshare-image' for images and 'feedshare-video' for videos
  const recipe =
    mediaType === "video"
      ? "urn:li:digitalmediaRecipe:feedshare-video"
      : "urn:li:digitalmediaRecipe:feedshare-image";

  const body = {
    registerUploadRequest: {
      recipes: [recipe],
      owner: personURN,
      serviceRelationships: [
        {
          relationshipType: "OWNER",
          identifier: "urn:li:userGeneratedContent",
        },
      ],
    },
  };

  const response = await axios.post(registerUrl, body, {
    headers: {
      Authorization: `Bearer ${accessToken}`,
      "X-Restli-Protocol-Version": "2.0.0",
      "Content-Type": "application/json",
    },
  });

  return {
    uploadUrl:
      response.data.value.uploadMechanism[
        "com.linkedin.digitalmedia.uploading.MediaUploadHttpRequest"
      ].uploadUrl,
    asset: response.data.value.asset,
  };
}

The registerMedia function accepts an image or video upload, the user's access token and the person's URN. The mediaType parameter determines whether the asset is an image (feedshare-image) or a video (feedshare-video).

Next, add the upload function:

async function uploadBinary(uploadUrl, accessToken, filePath) {
  const fileBuffer = fs.readFileSync(filePath);

  await axios.put(uploadUrl, fileBuffer, {
    headers: {
      Authorization: `Bearer ${accessToken}`,
      "Content-Type": "application/octet-stream",
      "X-Restli-Protocol-Version": "2.0.0",
    },
  });

  console.log("Upload successful.");
}

The uploadBinary function uploads the media file (image or video) to LinkedIn using the uploadUrl returned by the registerMedia function.

Finally, create the share function that utilises both functions before sharing the image/video to LinkedIn.

app.get("/auth/linkedin/share-media", async (req, res) => {
  const accessToken = process.env.ACCESS_TOKEN;
  const filePath = "./cover.png"; // Path to your local file

  try {
    // Step 0: Get User URN
    const userRes = await axios.get("https://api.linkedin.com/v2/userinfo", {
      headers: { Authorization: `Bearer ${accessToken}` },
    });
    const personURN = `urn:li:person:${userRes.data.sub}`;

    // Step 1: Register
    const { uploadUrl, asset } = await registerMedia(
      accessToken,
      personURN,
      "image",
    );

    // Step 2: Upload Binary
    await uploadBinary(uploadUrl, accessToken, filePath);

    // Step 3: Create the UGC Post using the asset
    const shareResponse = await axios.post(
      "https://api.linkedin.com/v2/ugcPosts",
      {
        author: personURN,
        lifecycleState: "PUBLISHED",
        specificContent: {
          "com.linkedin.ugc.ShareContent": {
            shareCommentary: { text: "Posting with an image!" },
            shareMediaCategory: "IMAGE",
            media: [
              {
                status: "READY",
                media: asset, // The URN from Step 1
                title: { text: "My Image Title" },
              },
            ],
          },
        },
        visibility: { "com.linkedin.ugc.MemberNetworkVisibility": "PUBLIC" },
      },
      {
        headers: {
          Authorization: `Bearer ${accessToken}`,
          "X-Restli-Protocol-Version": "2.0.0",
        },
      },
    );

    res.json({ success: true, post: shareResponse.data });
  } catch (error) {
    console.error(error.response?.data || error.message);
    res.status(500).json(error.response?.data || "Upload failed");
  }
});

The code above demonstrates the full workflow for posting an image to LinkedIn:

It first retrieves the user's LinkedIn ID (URN) using the access token.
The image is then registered with LinkedIn via the registerMedia function, returning an uploadUrl and asset identifier.
The uploadBinary function uploads the image file to LinkedIn using the provided uploadUrl.
Finally, a UGC post is created using the asset ID, setting the shareMediaCategory to "IMAGE" and including a post message and optional title.

The examples in this guide use HTTP GET requests to allow testing the API endpoints directly in a web browser. In a real-world application, you should replace these GET requests with POST requests (or the appropriate HTTP method) where required by LinkedIn's API.

Recommended: Unified Solution for LinkedIn Posts

Late is an all-in-one social media scheduling platform that allows you to connect multiple social media accounts and publish posts across them. With its API, you can schedule and publish social media content, including images or videos, across 13 platforms, including LinkedIn.

LinkedIn for Outreach: API vs Automation

So far, you've learnt how to create and share content on LinkedIn using its API. However, the API has limitations: it doesn't support direct messages or connection requests, and using browser automation tools like Selenium or Puppeteer can put your account at risk.

This is where WaLead comes in. WaLead is a cloud-based LinkedIn automation platform for connection requests, personalised messaging, and campaign management at scale. It doesn't require a browser, supports multiple accounts, and eliminates account risk.

With WaLead, sales and marketing teams can:

All of this can be done easily and safely, without jeopardising your LinkedIn account.

LinkedIn API vs Late API vs WaLead

What you need	LinkedIn API	Late API	WaLead
Post to LinkedIn	OAuth + media upload	One API call	N/A
Post to 13 platforms	Build each integration	One API call	N/A
LinkedIn outreach/DMs	Not available via API	N/A	Full automation
Token management	Build refresh logic	Automatic	Automatic
Scale many accounts	Complex multi-tenant OAuth	Multi-profile support	Unlimited accounts

Conclusion

In this guide, you've learned how to create and share content using the LinkedIn API. For easier authentication and more advanced features, the Late API provides a powerful solution that also allows you to schedule and publish posts, including media, across 13 social media platforms, including LinkedIn.

While these APIs are great for content publishing, they don't cover direct messages, connection requests, or large-scale outreach, areas where WaLead excels. Together, these tools give developers, marketers, and sales teams a complete toolkit for content creation, scheduling, and outreach on LinkedIn.

Thank you for reading!

Automate Social Media Posting with n8n: Step-by-Step Tutorial

Miquel Palet — Mon, 16 Feb 2026 11:32:46 +0000

Social media automation has become a core part of modern digital workflows. With advances in AI and workflow automation tools, it's now possible to build scalable systems that generate, schedule, and publish content across multiple platforms with minimal manual effort.

This tutorial guides you through using n8n, an open-source workflow automation platform, to build reliable social media posting pipelines. Whether you're a developer, agency, or SaaS builder, you'll learn how to design workflows that automate multi-platform content publishing using modern APIs.

By the end of this guide, you will:

Understand why n8n is well-suited for social media automation workflows.
Compare native social media APIs with multi-platform services like Late API.
Configure Late for automated social media posting.
Build your first workflow to publish content across multiple platforms.
Integrate content generation and media files into your automation pipeline.
Explore the popular social media platforms and their media requirements.

Why Choose n8n for Social Media Automation?

n8n is a powerful, low-code automation platform that supports multiple tools and services, enabling you to create or schedule automated workflows.

Visual workflow builder

n8n offers an intuitive visual workflow editor with drag-and-drop components that clearly illustrate the connections and execution of each step in a workflow, simplifying debugging and monitoring. When an error occurs, you can quickly identify the failing step and inspect its inputs and outputs.

Self-hosting and data control

n8n supports both managed cloud deployments and self-hosted installations. For teams that require greater control over data privacy, security, or infrastructure, the self-hosted option runs on your server, without relying on third-party infrastructure.

Extensive integration ecosystem

n8n provides over 1,300 prebuilt integrations that connect to popular services, such as email platforms, messaging tools, spreadsheets, and cloud storage, enabling you to automate common workflows like scheduled messaging, lead collection, and data synchronisation.

In addition, n8n allows you to connect to virtually any external service via APIs and webhooks. This extensibility makes it possible to create powerful automation workflows that perform complex processes.

Working with Social Media APIs: The Easy or The Hard Way

When building social media automation workflows, there are two approaches to integrating social media APIs into your applications: using the native platform APIs directly or using a unified API service. This section compares both approaches and explains their trade-offs.

Native Platform APIs (The Hard Way)

Native platform APIs are the official APIs provided by each social media service. They offer detailed, low-level control over platform features, but integrating multiple native APIs can quickly become complex when building cross-platform automation workflows.

Some common challenges include:

Authentication complexity per platform: Each social media platform implements its own authentication and authorisation model, often involving OAuth flows, permission scopes, and token refresh mechanisms. Managing these differences across multiple platforms adds significant implementation overhead.
Rate limit handling: Native APIs enforce platform-specific rate limits. Without careful request management, error-handling logic and retry strategies, workflows can exceed these limits and fail.
Maintenance burden: Direct integrations must be updated whenever a platform changes its API, authentication requirements, or versioning. This ongoing maintenance can be time-consuming, especially when supporting multiple platforms simultaneously.

Unified Social Media APIs (The Easy Way)

Unified API services abstract multiple social media platforms behind a single interface. For example, Late API provides a consolidated API for connecting accounts and publishing content across several platforms.

Instead of managing separate integrations, you work with a single, consistent API layer. Late API offers this capability with a free access tier, making it easy to get started without upfront infrastructure costs.

Key advantages include:

Single integration for multiple platforms: With Late API, you can publish content to multiple social media platforms through one integration, reducing development time and architectural complexity.
Centralised token management: Authentication, token refresh, and permission handling are managed by Late API, minimising security and maintenance overhead.
Reduced maintenance effort: Late API handles API version changes and infrastructure updates, allowing you to focus on workflow design rather than platform compatibility.

Unified APIs, like Late API, are particularly useful for automation workflows that prioritise speed of development, reliability, and cross-platform publishing.

Posting Content Across Social Media Platforms with Late

To get started, create a Late account and sign in.

Create an API key and save somewhere on your computer. We will need later while connecting Late API with n8n.

Connect your social media accounts to Late so you can manage and publish posts across all platforms.

After connecting your social media accounts via OAuth, you can start writing, posting, and scheduling content directly to your social media platforms.

Late lets you write your post content and attach media files directly from the dashboard.

You can choose when your content should be published: post immediately, schedule for later, add it to a job queue, or save it as a draft.

Once a post is published, you can view its status and preview it directly in the dashboard using the post link.

Congratulations! You've successfully created your first post using the Late dashboard. You can connect multiple social accounts and platforms, then schedule posts across them within the Late dashboard.

Building Your First Social Media Workflow with n8n

In this section, you will learn how to integrate Late API, an all-in-one social media scheduling API, with n8n to publish multimedia content across multiple social media platforms.

Log into your n8n workspace and create a new workflow from scratch.

n8n supports multiple workflow triggers, including manual execution, app events, scheduled triggers, webhooks, and form submissions. For this tutorial, select the manual trigger option.

Next, type Late into the sidebar search field to locate the Late API.

Install the Late package.

Select the Create Post action within the Late API functions list.

Next, configure and connect Late to n8n using your API key.

After connecting Late API to n8n, enter your post content, select the target platform, and enable Publish Now to run the step and verify that the post is published.

Congratulations! You've created your first automated post using n8n and Late API. The image below shows the complete workflow used to publish text-only posts.

Adding Media Files to Posts

To publish media files with your posts in n8n, connect your Google Drive account to the workflow so you can access existing files.

Add a Google Drive node and select Search files and folders.

Next, enter the exact filename and filter by folder to narrow the search results to a specific folder. In the node options, select * to return the full file data object so the workflow can access the file metadata.

Finally, update Create Post step to include the media file. Set the media field value to:

{{ $json.webContentLink }} // Exact image URL

The Late API and n8n integration supports multiple media formats, including images, videos, GIFs, and PDF documents across supported social media platforms.

You can extend this workflow further by integrating AI-powered content generation or RSS-based automation. For example, you can add AI models to generate captions or automatically publish posts from RSS feeds, allowing you to build fully automated social media pipelines.

Understanding Popular Social Media Platforms

When building automated posting workflows with Late API, it's important to understand that each social media platform has its own content formats, media constraints, and publishing features. These differences affect how you structure your workflows in n8n, especially when posting across multiple platforms at once.

Late supports 13 major social media platforms and standardises their APIs, but platform-specific media requirements, such as image dimensions, video formats, and post types, still apply. The table below summarises the supported platforms, the types of posts you can publish, and where to find their detailed media requirements.

Platform	Post Types	Media Requirements
Twitter / X	Text, Images, Videos, Threads	View
Instagram	Feed, Stories, Reels, Carousels	View
Facebook	Text, Images, Videos, Reels	View
LinkedIn	Text, Images, Videos, Documents	View
TikTok	Videos	View
YouTube	Videos, Shorts	View
Pinterest	Pins (Image/Video)	View
Reddit	Text, Images, Videos, Links	View
Bluesky	Text, Images, Videos	View
Threads	Text, Images, Videos	View
Google Business	Updates, Photos	View
Telegram	Text, Images, Videos, Albums	View
Snapchat	Stories, Saved Stories, Spotlight	View

Next Steps

So far, you've learnt how to build automated social media workflows for both text and multimedia content by combining n8n with Late API. With this foundation, you can scale from simple scheduled posts to fully automated, cross-platform publishing systems.

Late offers pre-built n8n templates for advanced social media automation, which are especially useful for agencies and social media managers handling dozens of client accounts, as well as developers building SaaS products that require content publishing directly within their applications. With Late API, you can manage 50+ client accounts from centralised workflows, implement white-label posting pipelines, and automate reporting and performance tracking.

Sign up and get your free API key to start building your own production-ready social media workflows.

Thank you for reading!