unipile-linkedin-sdk（unipile linkedin SDK 搜索）

Unipile LinkedIn SDK

LinkedIn API via official Unipile Node.js SDK for messaging, profiles, posts, and invitations.

⚠️ Security: Use Least Privilege

Recommended: Set UNIPILE_PERMISSIONS=read for read-only access.

# 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"

Your access token can perform actions on your behalf. Limit its scope with UNIPILE_PERMISSIONS.

Setup

Installation

npm install unipile-node-sdk

Environment Variables

Permission Modes

Default: read,write (full access) — Change to read for safety.

Least-Privilege Best Practice

# 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

Client Initialization

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');

Credential Storage

Recommended approaches (in order of security):

1. Environment variables — Set in shell profile or .env (add .env to .gitignore)
2. Secrets manager — AWS Secrets Manager, HashiCorp Vault, etc.
3. CI/CD secrets — GitHub Actions secrets, GitLab CI variables

Avoid: Storing tokens in plaintext files, especially in shared or version-controlled directories.

Get Credentials

1. Sign up at dashboard.unipile.com
2. Create an app to get your DSN and access token
3. Connect a LinkedIn account via the dashboard or API

Invocation Examples

Setup & Account Discovery

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

Pattern: First get the account ID, then use it for all other operations.

// 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);

Profile Lookup

"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
});

Posts & Content

"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! 🚀'
});

Messaging

"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...'
});

InMail (Non-Connections)

"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
    }
  }
});

Note: InMail requires LinkedIn Premium.

Connections & Invitations

"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
});

Reactions & Comments

"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.'
});

Account Connection

"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'
});

Quick Reference

Read Operations (require read permission)

Write Operations (require write permission)

Implementing Permission Checks

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 });
}

Response Patterns

List Endpoints

Return { object: '...List', items: [...], cursor: string | null }

• Filter with limit, after (ISO date), cursor for pagination
• Date filtering done client-side on parsed_datetime field

Account Object

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

Profile Object

{
  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://...'
}

Post Object

{
  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: '...' }
}

Error Handling

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;
    }
  }
}

Common Error Types

Limitations

• Post Comments API: getAllPostComments may return errors for some posts due to API limitations
• InMail: Requires LinkedIn Premium subscription
• Rate Limits: LinkedIn has strict rate limits; implement backoff for bulk operations
• Date Filtering: Must be done client-side on parsed_datetime field

Resources

• SDK Repository
• Unipile API Docs
• Unipile Dashboard

Security & Trust

What This Skill Does

This skill provides a wrapper around the official unipile-node-sdk npm package. It only makes API calls to your configured Unipile DSN endpoint.

Network calls: Only to UNIPILE_DSN (your Unipile API endpoint)

Data handling: Credentials are read from environment variables only — never stored or transmitted elsewhere

Required Credentials

Best practices:

• Store in environment variables or a secrets manager
• Never commit tokens to git or version control
• Avoid storing in workspace files that may be shared or synced

Verify the SDK

The underlying SDK is open source and can be audited:

• npm: npm info unipile-node-sdk
• GitHub: https://github.com/unipile/unipile-node-sdk
• Install from source: npm install git+https://github.com/unipile/unipile-node-sdk.git

Scope Considerations

This skill can:

• Read your LinkedIn profile and connections
• Send messages and create posts on your behalf
• View other users' profiles and posts

Recommendations:

• Use a dedicated LinkedIn account for automation
• Review Unipile's OAuth scopes before connecting
• Monitor activity via Unipile dashboard
• Use UNIPILE_PERMISSIONS=read for least privilege

Provenance

• Publisher: @Mohit21GoJs on ClawHub
• Skill Source: https://clawhub.ai/skills/unipile-linkedin-sdk
• SDK Source: https://github.com/unipile/unipile-node-sdk
• SDK License: MIT (official Unipile package)