Unipile Linkedin SDK

# RECOMMENDED: Read-only mode (safe, no write operations)
UNIPILE_PERMISSIONS=read node scripts/linkedin.mjs posts <account> andrewyng

# ONLY if you need to send messages or create posts
UNIPILE_PERMISSIONS=read,write node scripts/linkedin.mjs create-post <account> "text"

npm install unipile-node-sdk

# 1. Start with read-only (safest)
export UNIPILE_PERMISSIONS=read

# 2. Only enable write when specifically needed
export UNIPILE_PERMISSIONS=read,write  # Temporarily for a specific task

# 3. Revert to read-only after
export UNIPILE_PERMISSIONS=read

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

const client = new UnipileClient(
  process.env.UNIPILE_DSN,
  process.env.UNIPILE_ACCESS_TOKEN
);

// Check permissions before operations
const canWrite = (process.env.UNIPILE_PERMISSIONS || 'read,write').includes('write');
const canRead = (process.env.UNIPILE_PERMISSIONS || 'read,write').includes('read');

"Connect to my LinkedIn account via Unipile"
"List my connected LinkedIn accounts"
"What's my LinkedIn profile info?"

// Step 1: Get your LinkedIn account ID
const accounts = await client.account.getAll();
const linkedin = accounts.items.find(a => a.type === 'LINKEDIN');
const accountId = linkedin.id;  // Use this for all operations

// Step 2: Get your own profile
const me = await client.users.getOwnProfile(accountId);

"Look up Andrew Ng's LinkedIn profile"
"Get Satya Nadella's LinkedIn experience section"
"Find the company profile for OpenAI on LinkedIn"

// User profile by public identifier (URL slug)
const profile = await client.users.getProfile({
  account_id: accountId,
  identifier: 'andrewyng'  // from linkedin.com/in/andrewyng
});

// With specific sections
const profile = await client.users.getProfile({
  account_id: accountId,
  identifier: 'satyanadella',
  linkedin_sections: ['experience', 'education', 'skills'],
  notify: true  // sends profile view notification
});

// Company profile
const company = await client.users.getCompanyProfile({
  account_id: accountId,
  identifier: 'openai'  // company URL slug
});

"List posts from Andrew Ng on LinkedIn from last week"
"Get the latest 5 posts from Sundar Pichai"
"Show me Microsoft's recent LinkedIn posts"
"What did Andrew Ng post about AI recently?"

// Get posts from a user
const posts = await client.users.getAllPosts({
  account_id: accountId,
  identifier: 'andrewyng',  // or use provider_id from profile lookup
  limit: 10
});

// Filter by date range (client-side)
const oneWeekAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000);
const recentPosts = posts.items.filter(p => 
  new Date(p.parsed_datetime) >= oneWeekAgo
);

// Get specific post details
const post = await client.users.getPost({
  account_id: accountId,
  post_id: posts.items[0].id
});
// Returns: reactions, comments count, share_url, text, etc.

// Create a post on your own profile
await client.users.createPost({
  account_id: accountId,
  text: 'Excited to share my latest project! 🚀'
});

"List my LinkedIn chats"
"Show unread messages on LinkedIn"
"Send a message to my last LinkedIn conversation"

// List all chats
const chats = await client.messaging.getAllChats({
  account_type: 'LINKEDIN',
  account_id: accountId,
  limit: 20
});

// Filter unread
const unreadChats = chats.items.filter(c => c.unread_count > 0);

// Get messages from a chat
const messages = await client.messaging.getAllMessagesFromChat({
  chat_id: chats.items[0].id,
  limit: 50
});

// Send message to existing chat
await client.messaging.sendMessage({
  chat_id: 'chat_id',
  text: 'Thanks for connecting!'
});

// Start new chat with someone
await client.messaging.startNewChat({
  account_id: accountId,
  attendees_ids: ['provider_id_from_profile'],
  text: 'Hi, I wanted to reach out about...'
});

"Send an InMail to someone outside my network"
"Message a LinkedIn user I'm not connected to"

await client.messaging.startNewChat({
  account_id: accountId,
  attendees_ids: ['target_provider_id'],
  text: 'Hi, I came across your profile...',
  options: {
    linkedin: {
      api: 'classic',  // or 'recruiter', 'sales_navigator'
      inmail: true
    }
  }
});

"List my LinkedIn connections"
"Show my pending connection requests"
"Send a connection request to [profile]"
"Cancel my pending invitation to [name]"

// List your connections
const connections = await client.users.getAllRelations({
  account_id: accountId,
  limit: 100
});

// Send connection request
await client.users.sendInvitation({
  account_id: accountId,
  provider_id: 'ACoAAA...',  // from profile lookup
  message: 'Hi, I enjoyed your recent post about AI!'
});

// List pending invitations you've sent
const invitations = await client.users.getAllInvitationsSent({
  account_id: accountId
});

// Cancel an invitation
await client.users.cancelInvitationSent({
  account_id: accountId,
  invitation_id: invitations.items[0].id
});

"Like Andrew Ng's latest post"
"Add a comment on [post]"
"React with celebrate on [post]"

// React to a post
await client.users.sendPostReaction({
  account_id: accountId,
  post_id: '7440079959160913920',
  reaction_type: 'like'  // 'celebrate', 'support', 'love', 'insightful', 'funny'
});

// Comment on a post
await client.users.sendPostComment({
  account_id: accountId,
  post_id: '7440079959160913920',
  text: 'Great insights! Thanks for sharing.'
});

"Generate a link to connect my LinkedIn account"
"Create a hosted auth link for LinkedIn"

// Hosted auth (for multi-user apps)
const link = await client.account.createHostedAuthLink({
  type: 'create',
  expiresOn: new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString(),
  providers: ['LINKEDIN'],
  success_redirect_url: 'https://yourapp.com/success',
  failure_redirect_url: 'https://yourapp.com/fail',
  notify_url: 'https://yourapp.com/webhook'
});
// Share link.url with user to connect their account

// Handle 2FA checkpoint
await client.account.solveCodeCheckpoint({
  account_id: accountId,
  provider: 'LINKEDIN',
  code: '123456'
});

const PERMISSIONS = (process.env.UNIPILE_PERMISSIONS || 'read,write').split(',');

function requireWrite() {
  if (!PERMISSIONS.includes('write')) {
    throw new Error('Operation requires write permission. Set UNIPILE_PERMISSIONS=write');
  }
}

function requireRead() {
  if (!PERMISSIONS.includes('read')) {
    throw new Error('Operation requires read permission. Set UNIPILE_PERMISSIONS=read');
  }
}

// Usage
async function safeCreatePost(accountId, text) {
  requireWrite();
  return client.users.createPost({ account_id: accountId, text });
}

{
  id: 'MvbNEuYTTZ-o-QCHITLGnw',  // Use as account_id
  type: 'LINKEDIN',
  name: 'John Doe',
  sources: [{ id: '...', status: 'OK' }]
}

{
  provider_id: 'ACoAAA...',       // Use for invitations
  public_identifier: 'john-doe',  // URL slug
  first_name: 'John',
  last_name: 'Doe',
  headline: 'CEO at Company',
  location: 'San Francisco, CA',
  profile_picture_url: 'https://...'
}

{
  id: '7440079959160913920',
  text: 'Post content...',
  parsed_datetime: '2026-03-18T17:01:32.265Z',
  reaction_counter: 2064,
  comment_counter: 130,
  share_url: 'https://www.linkedin.com/posts/...',
  author: { name: '...', public_identifier: '...' }
}

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

try {
  await client.users.getProfile({ account_id, identifier });
} catch (err) {
  if (err instanceof UnsuccessfulRequestError) {
    const { status, type, detail } = err.body;
    
    switch (type) {
      case 'errors/invalid_credentials':
        // Reconnect account
        break;
      case 'errors/checkpoint_error':
        // Prompt for 2FA code
        break;
      case 'errors/disconnected_account':
        // Account needs reconnection
        break;
      case 'errors/resource_not_found':
        // Invalid ID or profile doesn't exist
        break;
      case 'errors/invalid_recipient':
        // Profile identifier not found
        break;
    }
  }
}