Skip to main content
Glama
LinkedIn Intelligence MCP Server

LinkedIn Intelligence MCP Server

by southleft

LinkedIn Content Intelligence Platform

Your AI-powered content strategist for LinkedIn.

Create compelling content, analyze what resonates with your audience, research industry trends, and build meaningful professional relationships—all through natural conversation with Claude.


A Content-First Approach to LinkedIn

This isn't another automation tool for mass outreach. It's a Content Intelligence Platform designed for professionals who value quality over quantity.

What makes this different:

  • Content Strategy Focus: Understand what content performs, why it resonates, and how to improve

  • Authentic Engagement: Build genuine professional relationships, not spray-and-pray automation

  • Research-Driven: Make informed decisions based on real data about your audience and industry

  • Quality Over Quantity: Craft thoughtful content rather than churning out generic posts

The Power of AI-Assisted Workflows

Imagine this: You ask Claude to research a competitor's content strategy. Minutes later, you understand their top-performing topics, posting patterns, and engagement drivers. You craft a differentiated response post, Claude helps optimize it for your audience, and you schedule it for when your network is most active.

Cross-platform intelligence:

LinkedIn Research → Blog Post → WordPress Publish → LinkedIn Promotion
  1. Analyze trending topics from industry thought leaders

  2. Develop a unique perspective with Claude's help

  3. Publish to your blog (via another MCP)

  4. Share insights with your LinkedIn network

This is content intelligence—understanding your professional landscape and creating content that genuinely adds value.


Related MCP server: LinkedIn MCP Server

Who Is This For?

Content Creators & Thought Leaders

  • Develop and refine your content strategy with data-driven insights

  • Understand what topics resonate with your audience

  • Build a consistent publishing cadence with draft management and scheduling

  • Analyze engagement patterns to continuously improve

Marketing & Brand Teams

  • Research competitor content strategies and positioning

  • Track industry trends and thought leadership topics

  • Measure content performance and engagement metrics

  • Coordinate team content calendars

Professionals Building Their Brand

  • Craft authentic content that showcases expertise

  • Engage meaningfully with your professional network

  • Research industry conversations before contributing

  • Build genuine connections with relevant professionals

Analysts & Researchers

  • Gather company and professional data for market research

  • Analyze engagement patterns and content trends

  • Generate comprehensive reports on LinkedIn presence

  • Track industry movements and competitive intelligence


Features

Content Creation

Feature

Description

Text Posts

Create and publish professional posts with AI assistance

Image Posts

Share images with captions and hashtags

Polls

Create interactive polls to engage your audience

Comments

Comment on posts (images supported in nested replies only)

Rich Formatting

AI-optimized content with hooks, CTAs, and hashtags

Content Planning

Feature

Description

Draft Management

Save, edit, and organize drafts with tags

Post Scheduling

Schedule posts for optimal engagement times

Content Calendar

View and manage your scheduled content

Content Analysis

Get AI suggestions to improve engagement

Profile Research

Feature

Description

Profile Viewing

View detailed LinkedIn profiles

Profile Enrichment

Get comprehensive profile data with multi-source fallback

Profile Interests

Discover who/what a person follows (influencers, companies, topics)

Similar Profiles

Find profiles similar to a given person

Profile Articles

Get articles written by any profile

Skills & Endorsements

View skills and endorsement data

Company Research

Feature

Description

Company Search

Search for companies by keywords

Company Details

Get company info, employee counts, and descriptions

Company by Domain

Look up companies by website domain

Organization Insights

Follower counts and engagement data

Analytics & Engagement

Feature

Description

Post Analytics

Reactions, comments, and engagement metrics (via official API)

Content Performance

Analyze what content works best

Optimal Posting Times

Derived insights from your engagement patterns

Hashtag Analysis

Derived insights from your post performance

Engagement Reports

Comprehensive performance reports

Profile Views

Track who's viewing your profile

Messaging & Conversations

Feature

Description

View Conversations

Browse your LinkedIn message threads

Read Messages

Access conversation history with connections

Send Messages

Message your connections directly

Conversation Management

Mark conversations as read

Note: Messaging features are designed for maintaining existing professional relationships. LinkedIn's terms of service prohibit automated mass messaging.

Connections & Networking

Feature

Description

View Invitations

See pending connection requests

Send Requests

Connect with professionals (with optional message)

Manage Invitations

Accept or decline connection requests

Connection Management

Manage your professional network

Best Practice: Connection requests should be personalized and relevant. Sending mass requests violates LinkedIn's terms and damages your professional reputation.

Job Intelligence

Feature

Description

Job Search

Search postings with filters (keywords, location, remote, experience)

Job Details

Get comprehensive job posting information

Skills Analysis

See required skills for positions


Important: Required Accounts & Services

This MCP server cannot function without external account setup. Simply installing the code is not enough. Most features require one or more of the accounts described below. If you skip this section, you will encounter permission errors and non-functional tools.

What You Need (At a Glance)

Account / Service

Cost

What It Unlocks

Required?

LinkedIn Account

Free

Everything — base requirement

Yes

LinkedIn Developer App

Free

Posting, analytics, profile data via OAuth

Yes

RapidAPI Account + API Subscriptions

Free tier available

Profile/company research, search, articles

Highly Recommended

Browser Cookies

Free

Messaging, connections, job search, people search

Optional

Playwright Browser

Free

Browser automation fallback for data retrieval

Optional

Feature-to-Account Mapping

Use this table to determine exactly which accounts you need based on the features you want:

Feature

LinkedIn Developer App

RapidAPI Subscription

Browser Cookies

Create/edit/delete posts

"Share on LinkedIn" product

-

-

Create polls

"Share on LinkedIn" product

-

-

Post images/videos/documents

"Share on LinkedIn" product

-

-

Post scheduling & drafts

"Share on LinkedIn" product

-

-

View your own profile

OAuth (basic scopes)

-

-

Post analytics (official)

"Share on LinkedIn" product

-

-

Comments & reactions

"Community Management API" product

-

-

Ad search & transparency

"Ad Library API" product

-

-

Profile research (others)

-

Yes (Professional Network Data API)

Fallback only

Company research

-

Yes (Professional Network Data API)

Fallback only

People/company search

-

Yes (Pro plan or higher)

Fallback only

Article retrieval

-

Yes (Professional Network Data API)

-

Similar profiles

-

Yes (Professional Network Data API)

-

Profile interests

-

Yes (Professional Network Data API)

-

Messaging (read/send)

-

-

Required

Connection management

-

-

Required

Job search

-

-

Required

Content performance analytics

-

Yes (for post data retrieval)

Fallback only

Step 1: LinkedIn Developer App

This is required for all official API features (posting, analytics, comments).

  1. Go to the LinkedIn Developer Portal

  2. Click "Create app"

  3. Fill in the required details:

    • App name: e.g., "My LinkedIn MCP"

    • LinkedIn Page: You must associate a LinkedIn Company Page. If you don't have one, create a Company Page first (it can be minimal).

    • Privacy policy URL: Your website URL or LinkedIn profile URL

  4. Request API Products (under the "Products" tab):

    Product

    How to Get It

    What It Enables

    Share on LinkedIn

    Click "Request access" — instant approval

    Creating posts, images, polls, scheduling

    Sign In with LinkedIn using OpenID Connect

    Click "Request access" — instant approval

    OAuth authentication, profile data

    Community Management API

    Click "Request access" — requires LinkedIn review (may take days)

    Comments, reactions, mentions

    Ad Library API

    Click "Request access" — requires LinkedIn review

    Searching LinkedIn ads

  5. Go to the "Auth" tab:

    • Copy your Client ID and Client Secret (you'll need these later)

    • Under "OAuth 2.0 settings", add this redirect URL: http://localhost:8765/callback

Note on Community Management API: This product requires LinkedIn to review and approve your application. Without it, commenting on posts and adding reactions will not work. You can still use all other posting features while you wait for approval.

Step 2: RapidAPI Account

This is required for profile research, company lookups, search, and article retrieval. Without it, these features fall back to unreliable cookie-based methods that are prone to LinkedIn's bot detection.

  1. Create a free RapidAPI account at rapidapi.com/signup

  2. Subscribe to the Professional Network Data API (primary data source — 55 endpoints):

    • Go to: Professional Network Data API

    • Click "Subscribe" and select a plan:

      Plan

      Price

      What You Get

      Basic

      Free (limited requests)

      Profile lookups, company data, posts, articles

      Pro

      $50/month

      All Basic features + search, higher limits

      Ultra

      $175/month

      Higher rate limits

      Mega

      $500/month

      Highest rate limits

    • The Basic (free) plan is sufficient to get started with profile and company lookups.

  3. (Optional) Subscribe to the Fresh LinkedIn Data API (secondary/fallback data source):

  4. Copy your RapidAPI key:

    • Go to any subscribed API page on RapidAPI

    • Your API key appears in the "Header Parameters" section as X-RapidAPI-Key

    • This single key works for all APIs you've subscribed to on RapidAPI

Important: The same RapidAPI key is used for both the Professional Network Data API and the Fresh LinkedIn Data API. You only need one RapidAPI account, but you must subscribe to each API product separately.

Step 3: Browser Cookies (Optional)

Required for: messaging, connections, job search, and people search via LinkedIn's unofficial API.

These features use LinkedIn's internal (unofficial) API, which requires your browser session cookies. This is safe — cookies are stored locally and never sent anywhere except to LinkedIn.

# Extract cookies from your browser (after logging into LinkedIn)
linkedin-mcp-auth extract-cookies --browser chrome

Supported browsers: Chrome, Arc, Brave, Edge, Firefox, Opera, Opera GX, Vivaldi, Chromium, Safari, LibreWolf.

Note: Browser cookies expire every 24-48 hours. You'll need to re-run the extract command periodically. If messaging or connection features stop working, refresh your cookies first.

Step 4: Playwright (Optional)

Optional browser automation fallback for data retrieval when other methods fail.

playwright install chromium

This installs a headless browser that acts as a last-resort data source if APIs and cookies are unavailable.


Quick Start

Prerequisites

Installation

git clone https://github.com/southleft/linkedin-mcp.git
cd linkedin-mcp

# Install with uv (recommended)
uv venv && source .venv/bin/activate
uv pip install -e .

# Optional: Install browser automation fallback
playwright install chromium

Configuration

Create a .env file in the project root:

# LinkedIn OAuth (Required — from LinkedIn Developer Portal)
LINKEDIN_CLIENT_ID=your_client_id
LINKEDIN_CLIENT_SECRET=your_client_secret
LINKEDIN_API_ENABLED=true

# RapidAPI Key (Recommended — from your RapidAPI dashboard)
# Powers profile/company research, search, and articles
THIRDPARTY_RAPIDAPI_KEY=your_api_key

Note: Without the RapidAPI key, profile and company lookups fall back to cookie-based methods which are unreliable and prone to LinkedIn's bot detection. See Step 2: RapidAPI Account for setup instructions.

Authentication

# Authenticate with LinkedIn (opens browser for OAuth flow)
linkedin-mcp-auth oauth

# Optional: Include Community Management API scope for comments/reactions
linkedin-mcp-auth oauth --community-management

# Optional: Extract cookies for messaging, connections, and job search
linkedin-mcp-auth extract-cookies --browser chrome

# Verify your setup
linkedin-mcp-auth status

Connect to Claude Desktop

Add the following to your Claude Desktop config file:

Platform

Config Location

macOS

~/Library/Application Support/Claude/claude_desktop_config.json

Windows

%APPDATA%\Claude\claude_desktop_config.json

Linux

~/.config/Claude/claude_desktop_config.json

Complete configuration example:

{
  "mcpServers": {
    "linkedin": {
      "command": "/path/to/linkedin-mcp/.venv/bin/python",
      "args": ["-m", "linkedin_mcp.main"],
      "cwd": "/path/to/linkedin-mcp",
      "env": {
        "LINKEDIN_CLIENT_ID": "your_client_id",
        "LINKEDIN_CLIENT_SECRET": "your_client_secret",
        "LINKEDIN_API_ENABLED": "true",
        "THIRDPARTY_RAPIDAPI_KEY": "your_api_key",
        "PYTHONPATH": "/path/to/linkedin-mcp/src",
        "LOG_LEVEL": "INFO"
      }
    }
  }
}

Critical: Claude Desktop does not read .env files—all environment variables must be explicitly passed in the config.

After updating the config:

  1. Quit Claude Desktop completely

  2. Reopen Claude Desktop

  3. The LinkedIn MCP server will connect automatically

Connect to Claude Code

Add to ~/.claude.json:

{
  "mcpServers": {
    "linkedin-mcp": {
      "type": "stdio",
      "command": "/path/to/linkedin-mcp/.venv/bin/python",
      "args": ["-m", "linkedin_mcp.main"],
      "cwd": "/path/to/linkedin-mcp",
      "env": {
        "LINKEDIN_CLIENT_ID": "your_client_id",
        "LINKEDIN_CLIENT_SECRET": "your_client_secret",
        "LINKEDIN_API_ENABLED": "true",
        "THIRDPARTY_RAPIDAPI_KEY": "your_api_key",
        "PYTHONPATH": "/path/to/linkedin-mcp/src"
      }
    }
  }
}

Run /mcp in Claude Code to connect.


Usage Examples

Content Creator Workflow

You: "Create a LinkedIn post about the importance of continuous learning in tech"

Claude: Here's a draft optimized for engagement:

"In tech, the moment you stop learning is the moment you start falling behind.

Every new framework, language, or methodology is an opportunity to expand your toolkit and thinking.

The best engineers I know aren't just skilled—they're perpetually curious.

What are you learning this week?

#ContinuousLearning #TechCareers #GrowthMindset"

Should I post this now, schedule it, or save as a draft?

Content Planning

You: "Save this as a draft for my product launch and schedule it for Tuesday 9am"

Claude: Done! I've:
1. Saved your draft titled "Product Launch"
2. Scheduled it for Tuesday, 9:00 AM (your timezone)

You can view your drafts anytime or adjust the schedule.

Profile Research

You: "Look up the CEO of Microsoft on LinkedIn"

Claude: Found Satya Nadella's profile:
- Chairman and CEO at Microsoft
- Focus on cloud computing and AI transformation
- Author and thought leader in technology

Would you like me to find similar profiles or see their recent articles?

Company Research

You: "Look up information about anthropic.com"

Claude: Found Anthropic:
- AI safety company
- Headquarters in San Francisco
- Focus on AI research and safety

Would you like more details or to search for employees?

Available Tools

See CAPABILITIES.md for the complete tool reference with 83 tools across 14 categories.

Content Creation

Tool

Description

create_post(text, visibility)

Publish a text post

create_image_post(text, image_path, alt_text)

Post with an image

create_poll(question, options, duration_days)

Create an interactive poll

create_comment(post_urn, text)

Comment on a post

delete_post(post_urn)

Remove a published post

Draft Management

Tool

Description

create_draft(content, title, tags)

Save content for later

list_drafts(tag)

View all saved drafts

get_draft(draft_id)

Get a specific draft

update_draft(draft_id, content, title, tags)

Edit a draft

delete_draft(draft_id)

Remove a draft

publish_draft(draft_id, visibility)

Publish a saved draft

analyze_draft_content(content, industry)

Get AI suggestions

Scheduling

Tool

Description

schedule_post(content, scheduled_time, timezone)

Schedule for future

list_scheduled_posts(status)

View scheduled posts

get_scheduled_post(job_id)

Get schedule details

update_scheduled_post(job_id, content, time)

Modify scheduled post

cancel_scheduled_post(job_id)

Cancel a scheduled post

Profile Research

Tool

Description

get_my_profile()

Get your LinkedIn profile

get_profile(profile_id)

View any LinkedIn profile

get_profile_contact_info(profile_id)

Get contact details

get_profile_skills(profile_id)

Get skills and endorsements

get_profile_interests(profile_id)

Get interests (influencers, companies, topics)

get_similar_profiles(profile_id, limit)

Find similar profiles

get_profile_articles(profile_id, limit)

Get articles written by profile

get_auth_status()

Check authentication status

get_rate_limit_status()

Monitor API usage

Company Research

Tool

Description

search_people(keywords, limit, keyword_title)

Find professionals

search_companies(keywords, limit)

Search for companies

get_company(public_id)

Get company details

get_company_by_domain(domain)

Look up company by website domain

get_article(article_url)

Get full article content

get_organization_followers(organization_id)

Get follower count

Analytics

Tool

Description

get_feed(limit)

Get your LinkedIn feed

get_profile_posts(profile_id, limit)

Get posts from a profile

get_profile_views()

Get your profile view statistics

get_post_reactions(post_urn)

Get reactions on a post

get_post_comments(post_urn)

Get comments on a post

analyze_engagement(post_urn)

Deep engagement analysis

analyze_content_performance(profile_id)

Content patterns

analyze_optimal_posting_times(profile_id)

Best times to post

analyze_hashtag_performance(profile_id)

Hashtag effectiveness

generate_engagement_report(profile_id)

Full engagement report

Messaging

Tool

Description

get_conversations(limit)

List all message conversations

get_conversation(conversation_urn)

Get messages from a conversation

get_conversation_details(profile_urn)

Get conversation ID for a profile

send_message(conversation_urn, text)

Send a message to a conversation

mark_conversation_as_seen(conversation_urn)

Mark conversation as read

Connections

Tool

Description

get_invitations(limit)

Get pending connection requests

send_connection_request(profile_id, message)

Send a connection request

reply_invitation(invitation_urn, action)

Accept or reject an invitation

remove_connection(profile_id)

Remove a connection

Tool

Description

search_jobs(keywords, location, remote, ...)

Search job postings

get_job(job_id)

Get detailed job information

get_job_skills(job_id)

Get required skills for a job


CLI Commands

# Authentication
linkedin-mcp-auth status              # Check auth status
linkedin-mcp-auth oauth               # Authenticate via OAuth
linkedin-mcp-auth oauth --force       # Force re-authentication
linkedin-mcp-auth extract-cookies     # Extract session cookies
linkedin-mcp-auth logout --all        # Clear all credentials

# Server
linkedin-mcp                          # Start MCP server
python -m linkedin_mcp                # Alternative server start

Configuration Reference

Variable

Default

Description

LINKEDIN_CLIENT_ID

-

OAuth Client ID (required for posting)

LINKEDIN_CLIENT_SECRET

-

OAuth Client Secret (required for posting)

LINKEDIN_API_ENABLED

false

Enable API features

THIRDPARTY_RAPIDAPI_KEY

-

API key for enhanced profile data

MCP_TRANSPORT

stdio

Transport: stdio, streamable-http

MCP_HOST

127.0.0.1

HTTP server host

MCP_PORT

8000

HTTP server port

LOG_LEVEL

INFO

Logging level


Limitations

Feature

Status

Notes

Text/Image/Poll Posts

Supported

Via Official LinkedIn API

Article Link Shares

Supported

External URLs with metadata

Comments

Supported

Requires Community Management API approval

Direct Messages

Supported

Via unofficial API (requires cookies)

Connection Requests

Supported

Via unofficial API (requires cookies)

Job Search

Supported

Via unofficial API (requires cookies)

Native LinkedIn Articles

Not Available

LinkedIn API limitation

Newsletters

Not Available

No API access

Note: Features marked "requires cookies" use LinkedIn's unofficial API. These work reliably but may require periodic cookie refresh (every 24-48 hours). Run linkedin-mcp-auth extract-cookies to refresh.


Troubleshooting

"Profile lookup returns error"

Ensure THIRDPARTY_RAPIDAPI_KEY is set in your Claude Desktop config:

"env": {
  "THIRDPARTY_RAPIDAPI_KEY": "your_api_key",
  ...
}

Important: Claude Desktop does not read .env files. You must add the key directly to the config's env section.

"LinkedIn client not initialized"

linkedin-mcp-auth status    # Check configuration
linkedin-mcp-auth oauth     # Re-authenticate

"Application context not initialized"

Reconnect the MCP server:

  • Claude Desktop: Quit and reopen the app

  • Claude Code: Run /mcp to reconnect

Posts not appearing

  • Verify OAuth: linkedin-mcp-auth status

  • Ensure "Share on LinkedIn" product is enabled in Developer Portal

Comments failing with permission error

  • Comments require the "Community Management API" product

  • Apply for access in your LinkedIn Developer Portal

Search returns empty results

  • Search relies on session cookies which expire after ~24 hours

  • Refresh cookies: linkedin-mcp-auth extract-cookies --browser chrome

  • Note: Profile and company lookups use the RapidAPI fallback and are unaffected


Security

  • OAuth tokens: Stored securely in system keychain

  • Session cookies: Encrypted local storage

  • Credentials: Environment variables only

  • No data collection: Everything runs locally


Development

# Install dev dependencies
uv pip install -e ".[dev]"

# Run tests
pytest tests/ -v

# Linting
ruff check src/ && ruff format src/

# Type checking
mypy src/linkedin_mcp

Architecture

Intelligent API Fallback

Under the hood, the server uses a multi-source architecture that automatically falls back through APIs ordered by reliability:

Priority

Source

Reliability

1

Professional Network Data API

Highest - 55 endpoints

2

Fresh LinkedIn Data API

High - profiles & search

3

Marketing API

High - organizations (official)

4

Enhanced HTTP Client

Medium - anti-detection

5

Headless Browser

Medium - slowest but reliable

6

Unofficial API

Lowest - cookie-based, prone to blocking

This ensures high availability, automatic recovery from failures, and best-effort data retrieval.


License

MIT License - see LICENSE for details.


Acknowledgments


Built for professionals who value authentic engagement over automation.

Available Tools

85 tools
add_profile_skillA

Add a skill to your profile.

Requires Playwright browser automation to be enabled.

Args: skill_name: Name of the skill to add

Returns success status.

Inputs: skill_name (required). Returns: object

analyze_content_performanceB

Analyze content performance patterns for a profile.

Args: profile_id: LinkedIn public ID post_limit: Number of posts to analyze (default: 20, max: 50)

Returns content analysis with type distribution, engagement patterns, and recommendations.

Inputs: profile_id (required), post_limit. Returns: object

analyze_draft_contentC

Analyze draft content and get suggestions for improvement.

Args: content: Draft post content to analyze industry: Optional industry for targeted hashtag suggestions

Returns content analysis with score, suggestions, and recommended hashtags.

Inputs: content (required), industry. Returns: object

analyze_engagementC

Perform deep engagement analysis on a specific post.

Args: post_urn: LinkedIn post URN follower_count: Author's follower count for rate calculation (optional)

Returns comprehensive engagement metrics, reaction distribution, and quality score.

Inputs: post_urn (required), follower_count. Returns: object

analyze_hashtag_performanceC

Analyze hashtag usage and performance.

Args: profile_id: LinkedIn public ID post_limit: Number of posts to analyze (default: 30, max: 50)

Returns hashtag frequency, engagement correlation, and recommendations.

Inputs: profile_id (required), post_limit. Returns: object

analyze_my_content_performanceB

Analyze your content performance comprehensively.

Provides detailed analysis of your posting patterns, engagement metrics, best performing content types, and optimal posting times.

Args: post_limit: Number of posts to analyze (default: 30, max: 50)

Returns detailed performance analysis with content breakdown, timing insights, and recommendations.

Inputs: post_limit. Returns: object

analyze_optimal_posting_timesB

Analyze optimal posting times based on engagement patterns.

Args: profile_id: LinkedIn public ID post_limit: Number of posts to analyze (default: 30, max: 50)

Returns optimal posting times by hour and day with engagement averages.

Inputs: profile_id (required), post_limit. Returns: object

analyze_post_audienceC

Analyze the audience engaging with a specific post.

Args: post_urn: LinkedIn post URN

Returns audience demographics based on commenters' profiles.

Inputs: post_urn (required). Returns: object

batch_get_profilesA

Get multiple LinkedIn profiles efficiently.

Args: profile_ids: Comma-separated list of profile public IDs (max 10)

Returns profiles with basic info and success/failure status for each.

Inputs: profile_ids (required). Returns: object

cancel_scheduled_postB

Cancel a scheduled post.

Args: job_id: ID of the scheduled post to cancel

Returns success status.

Inputs: job_id (required). Returns: object

check_browser_automation_statusB

Check if browser automation is available for profile updates.

Returns availability status and feature capabilities.

Inputs: no named parameters. Returns: object

create_commentA

Create a comment on a LinkedIn post using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Args: post_urn: The URN of the post to comment on (e.g., "urn:li:share:123456" or "urn:li:activity:123456") text: The comment text content (max 1250 characters) parent_comment_urn: Optional URN of parent comment for nested replies image_path: Optional image source (only for nested replies) - can be: - Absolute path to local file (JPG, PNG, GIF) - URL to image (http:// or https://) - Base64-encoded image (data:image/png;base64,...)

Returns the created comment details including comment ID.

Note: LinkedIn only allows images in nested comments (replies to other comments), not in top-level comments directly on posts.

Note: Commenting requires the "Community Management API" product from LinkedIn, which has a separate approval process. The "Share on LinkedIn" product only allows creating posts, not comments. If you receive a permission error, you'll need to apply for Community Management API access in your Developer Portal.

Inputs: post_urn (required), text (required), parent_comment_urn, image_path. Returns: object

create_document_postA

Create a LinkedIn post with a document (PDF, PPTX, DOCX) using the Official API.

Documents appear as carousel-style slideshows in the LinkedIn feed. Great for sharing presentations, guides, reports, etc.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Supported formats: PDF (recommended), PPTX, DOCX Maximum file size: 100MB

Args: text: Post text content (max 3000 characters) document_path: Document source - can be: - Absolute path to local file (PDF, PPTX, DOCX) - URL to document (http:// or https://) title: Optional title for the document (defaults to filename) visibility: Post visibility - PUBLIC or CONNECTIONS

Returns the created post details including post URN and document URN.

Inputs: text (required), document_path (required), title, visibility. Returns: object

create_draftB

Create a content draft for later publishing.

Args: content: Draft content title: Optional title for organization tags: Comma-separated tags for categorization

Returns the created draft details.

Inputs: content (required), title, tags. Returns: object

create_image_postA

Create a LinkedIn post with an image using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Args: text: Post text content (max 3000 characters) image_path: Image source - can be: - Absolute path to local file (JPG, PNG, GIF) - URL to image (http:// or https://) - Base64-encoded image (data:image/png;base64,...) alt_text: Accessibility text describing the image (recommended) visibility: Post visibility - PUBLIC or CONNECTIONS

Returns the created post details including post URN and image URN.

Inputs: text (required), image_path (required), alt_text, visibility. Returns: object

create_pollA

Create a LinkedIn poll using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Args: question: Poll question (also displayed as post text, max 140 characters) options: Comma-separated poll options (2-4 options, each max 140 characters) duration_days: Poll duration - 1, 3, 7, or 14 days (default: 7) visibility: Post visibility - PUBLIC or CONNECTIONS

Returns the created poll post details.

Inputs: question (required), options (required), duration_days, visibility. Returns: object

create_postA

Create a new LinkedIn post using the Official API (recommended) or unofficial API.

Uses the Official LinkedIn API with w_member_social scope when available. This is the TOS-compliant method that requires enabling "Share on LinkedIn" product.

Args: text: Post content (max 3000 characters) visibility: Post visibility - PUBLIC or CONNECTIONS

Returns the created post details including post URN.

Inputs: text (required), visibility. Returns: object

create_reactionA

Add a reaction to a LinkedIn post or comment using the Official API.

Requires "Community Management API" product enabled in your LinkedIn Developer app.

Args: target_urn: The URN of the post or comment to react to (e.g., "urn:li:share:123456", "urn:li:activity:123456", "urn:li:comment:(urn:li:activity:123,456)") reaction_type: Type of reaction to add. Options: - LIKE (👍 Like) - default - PRAISE or CELEBRATE (👏 Celebrate) - EMPATHY or LOVE (❤️ Love) - INTEREST or INSIGHTFUL (💡 Insightful) - APPRECIATION or SUPPORT (🙏 Support) - ENTERTAINMENT or FUNNY (😄 Funny)

Returns the created reaction details.

Note: The MAYBE reaction type is deprecated and no longer supported.

Inputs: target_urn (required), reaction_type. Returns: object

create_video_postA

Create a LinkedIn post with a video using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

LinkedIn supports video uploads up to 10 minutes for most users. Supported formats: MP4 (recommended), MOV Maximum file size: 200MB Recommended specs: 1080p, H.264 codec, AAC audio, 30fps

Args: text: Post text content (max 3000 characters) video_path: Video source - can be: - Absolute path to local file (MP4, MOV) - URL to video (http:// or https://) title: Optional title for the video visibility: Post visibility - PUBLIC or CONNECTIONS

Returns the created post details including post URN and video URN. Note: Video may take a few minutes to process before appearing in the feed.

Inputs: text (required), video_path (required), title, visibility. Returns: object

debug_contextA

Debug tool to check the internal state of the MCP server.

Returns information about:

  • Whether LinkedIn client is initialized

  • Settings configuration

  • Cookie file status

  • Initialization errors

Inputs: no named parameters. Returns: object

delete_commentA

Delete a comment from a LinkedIn post using the Official API.

Requires "Community Management API" product enabled in your LinkedIn Developer app.

Args: post_urn: The URN of the post containing the comment (e.g., "urn:li:share:123456" or "urn:li:activity:123456") comment_id: The ID or URN of the comment to delete

Returns success status.

Note: You can only delete comments that you have authored.

Inputs: post_urn (required), comment_id (required). Returns: object

delete_draftB

Delete a content draft.

Args: draft_id: ID of the draft to delete

Returns success status.

Inputs: draft_id (required). Returns: object

delete_postA

Delete a LinkedIn post using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Args: post_urn: The URN of the post to delete (e.g., "urn:li:share:123456")

Returns success status.

Inputs: post_urn (required). Returns: object

delete_reactionA

Remove a reaction from a LinkedIn post or comment using the Official API.

Requires "Community Management API" product enabled in your LinkedIn Developer app.

Args: target_urn: The URN of the post or comment to remove reaction from (e.g., "urn:li:share:123456", "urn:li:activity:123456")

Returns success status.

Note: This removes your reaction from the specified content.

Inputs: target_urn (required). Returns: object

edit_postA

Edit/update an existing LinkedIn post using the Official API.

Requires "Share on LinkedIn" product enabled in your LinkedIn Developer app.

Args: post_urn: The URN of the post to edit (e.g., "urn:li:share:123456") text: New text content for the post (optional, max 3000 characters) image_path: Path to new image file to replace existing media (optional) alt_text: Alt text for the new image (optional)

Returns: Success status with updated fields information.

Note: At least one of 'text' or 'image_path' must be provided. This uses LinkedIn's PARTIAL_UPDATE method to update only specified fields.

Inputs: post_urn (required), text, image_path, alt_text. Returns: object

generate_engagement_reportC

Generate a comprehensive engagement report for a profile.

Args: profile_id: LinkedIn public ID post_limit: Number of posts to analyze (default: 20)

Returns a full engagement report with content analysis, timing, and recommendations.

Inputs: profile_id (required), post_limit. Returns: object

generate_my_content_calendarA

Generate a content calendar based on your performance data.

Creates a data-driven posting schedule that optimizes for your best performing days, times, and content types.

Args: weeks: Number of weeks to plan (default: 4, max: 12) posts_per_week: Target posts per week (default: 3, max: 7)

Returns content calendar with suggested dates, times, and content prompts.

Inputs: weeks, posts_per_week. Returns: object

get_articleA

Get the full content of a LinkedIn article.

Uses the Professional Network Data API to fetch the complete article content, author information, and engagement metrics.

Args: article_url: Full URL of the LinkedIn article

Returns: Article content with title, body, author info, and engagement data

Inputs: article_url (required). Returns: object

get_auth_statusA

Get LinkedIn authentication status for both official and unofficial APIs.

Returns detailed status including:

  • Official API status (OAuth token expiry, available features)

  • Unofficial API status (cookie freshness, available features)

  • Recommended actions if not authenticated

Inputs: no named parameters. Returns: object

get_cache_statsB

Get cache statistics and performance metrics.

Returns cache size, hit rate, and memory usage.

Inputs: no named parameters. Returns: object

get_comments_officialA

Get comments on a LinkedIn post using the Official API.

Requires "Community Management API" product enabled in your LinkedIn Developer app.

Args: post_urn: The URN of the post (e.g., "urn:li:share:123456" or "urn:li:ugcPost:123456") start: Pagination start index (default: 0) count: Number of comments to return (default: 50, max: 100)

Returns list of comments with: - id: Comment ID - urn: Full comment URN (use this as parent_comment_urn to reply) - actor_urn: URN of the comment author - actor_name: Name of the comment author (if available) - text: Comment text content - parent_comment: URN of parent comment if this is a reply - created_at: Timestamp when comment was created

Use the returned comment URN as parent_comment_urn in create_comment to reply to a comment.

Inputs: post_urn (required), start, count. Returns: object

get_companyB

Get detailed company information.

Args: public_id: Company's public identifier (URL slug, e.g., 'microsoft')

Returns company details including description, industry, employee count, etc.

Inputs: public_id (required). Returns: object

get_company_by_domainA

Get company information by website domain.

Uses the Professional Network Data API to look up a company by its website domain (e.g., "anthropic.com" → Anthropic).

Args: domain: Company website domain (e.g., "anthropic.com")

Returns: Company information including name, industry, size, and LinkedIn URL

Inputs: domain (required). Returns: object

get_company_updatesB

Get recent posts/updates from a company page.

Args: public_id: Company's public identifier (URL slug) limit: Maximum updates to return (default: 10, max: 50)

Returns list of company posts/updates.

Inputs: public_id (required), limit. Returns: object

get_conversationC

Get full message history for a specific conversation.

Args: conversation_id: Conversation ID (from get_conversations results)

Returns conversation details with full message history.

WARNING: Uses unofficial API.

Inputs: conversation_id (required). Returns: object

get_conversation_detailsA

Get conversation ID and details for a specific profile.

Useful for finding the conversation ID to send a message to someone.

Args: profile_id: LinkedIn profile ID or URN

Returns conversation details including conversation ID.

WARNING: Uses unofficial API.

Inputs: profile_id (required). Returns: object

get_conversationsB

Get your LinkedIn messaging conversations.

Args: limit: Maximum conversations to return (default: 20)

Returns list of conversations with participants and last message preview.

WARNING: Uses unofficial API. May trigger LinkedIn bot detection.

Inputs: limit. Returns: object

get_draftC

Get a specific draft by ID.

Args: draft_id: ID of the draft

Returns the draft details.

Inputs: draft_id (required). Returns: object

get_feedB

Get the authenticated user's LinkedIn feed.

Args: limit: Maximum number of feed items to return (default: 10, max: 50) use_cache: Whether to use cached data if available (default: True)

Returns recent feed posts with engagement data.

Inputs: limit, use_cache. Returns: object

get_invitationsA

Get pending connection invitations you've received.

Args: limit: Maximum invitations to return (default: 50)

Returns list of pending invitations with sender info.

Note: LinkedIn API only supports fetching received invitations. Sent invitations are not available through this endpoint.

WARNING: Uses unofficial API.

Inputs: limit. Returns: object

get_jobA

Get detailed information about a specific job posting.

Args: job_id: LinkedIn job ID (from search results or job URL)

Returns job details including description, requirements, company info, etc.

WARNING: Uses unofficial API.

Inputs: job_id (required). Returns: object

get_job_skillsB

Get skills required for a job posting.

Args: job_id: LinkedIn job ID

Returns list of required and preferred skills for the job.

WARNING: Uses unofficial API.

Inputs: job_id (required). Returns: object

get_my_post_analyticsA

Get analytics for your own posts using the Official API.

Uses the r_member_postAnalytics scope (Community Management API) to get accurate impression counts, engagement metrics, and reach data.

Args: post_urns: List of specific post URNs to analyze. If not provided, will fetch your recent posts automatically. limit: If no URNs provided, analyze this many recent posts (default: 10)

Returns analytics including impressions, reactions, comments, shares, and engagement rate.

Inputs: post_urns, limit. Returns: object

get_my_posting_recommendationsA

Get personalized posting recommendations based on your content performance.

Analyzes your posting history to provide data-driven recommendations on content types, timing, and engagement strategies.

Args: post_limit: Number of posts to analyze for recommendations (default: 30)

Returns recommendations prioritized by potential impact.

Inputs: post_limit. Returns: object

get_my_postsA

Get your own LinkedIn posts.

Uses the data provider to retrieve your authored posts with metadata. Returns post URNs that can be used with get_my_post_analytics.

Args: count: Number of posts to retrieve (max 100)

Returns list of your posts with URNs, content, and timestamps.

Inputs: count. Returns: object

get_my_profileA

Get the authenticated user's LinkedIn profile.

Returns profile data including:

  • Basic info (name, email, picture)

  • LinkedIn member ID

Uses the Official LinkedIn API (OAuth 2.0) when available for reliable results. Falls back to unofficial API if official client is not configured.

Inputs: no named parameters. Returns: object

get_network_statsB

Get statistics about the authenticated user's LinkedIn network.

Returns network size, growth indicators, and connection insights.

Inputs: no named parameters. Returns: object

get_organization_followersA

Get follower count for an organization using the Community Management API.

This tool uses the official LinkedIn Community Management API which provides accurate follower counts for organizations you have admin access to.

Args: organization_id: LinkedIn organization URN ID (numeric, e.g., '12345678')

Returns follower count and organization details.

Note: Requires Community Management API access and admin permissions for the organization.

Inputs: organization_id (required). Returns: object

get_post_analyticsA

Get analytics for a specific post.

Args: post_urn: LinkedIn post URN

Returns engagement metrics including reactions, comments, and shares. Note: View count requires Partner API access.

Inputs: post_urn (required). Returns: object

get_post_commentsC

Get comments on a specific post.

Args: post_urn: LinkedIn post URN limit: Maximum comments to return (default: 50)

Returns list of comments with author info.

Inputs: post_urn (required), limit. Returns: object

get_post_reactionsB

Get reactions/likes on a specific post.

Args: post_urn: LinkedIn post URN (e.g., "urn:li:activity:123456789")

Returns list of users who reacted and reaction types.

Inputs: post_urn (required). Returns: object

get_profileA

Get comprehensive LinkedIn profile data with multi-source enrichment.

Uses the Profile Enrichment Engine to aggregate data from multiple endpoints in parallel, providing the most complete profile information available.

Args: profile_id: LinkedIn public ID (e.g., "johndoe") or URN use_cache: Whether to use cached data if available (default: True) include_activity: Include recent activity/posts (default: True) include_network: Include network stats like connections/followers (default: True) include_badges: Include member badges like Premium status (default: True)

Returns comprehensive profile data including:

  • Basic info (name, headline, location, photo)

  • Contact information (if available)

  • Skills and endorsements

  • Network information (connections, followers, distance)

  • Member badges (Premium, Creator, etc.)

  • Recent activity summary

  • Enrichment metadata showing data sources used

Inputs: profile_id (required), use_cache, include_activity, include_network, +1 more. Returns: object

get_profile_articlesA

Get articles written by a LinkedIn profile.

Uses the Professional Network Data API to fetch articles (long-form content) published by the specified profile.

Args: profile_id: LinkedIn public ID (e.g., "johndoe") limit: Maximum number of articles to return (default: 20)

Returns: List of articles with title, content preview, and engagement metrics

Inputs: profile_id (required), limit. Returns: object

get_profile_completenessA

Calculate profile completeness score with improvement suggestions.

Returns:

  • Completeness score (0-100)

  • Completed vs total sections

  • Specific suggestions for improvement

Inputs: no named parameters. Returns: object

get_profile_contact_infoB

Get contact information for a LinkedIn profile.

Args: profile_id: LinkedIn public ID

Returns contact info including email, phone, websites, and social profiles.

Inputs: profile_id (required). Returns: object

get_profile_interestsA

Get profile interests including influencers, companies, groups, and topics.

This data is unique to the Professional Network Data API and provides insights into what/who a person follows on LinkedIn.

Args: profile_id: LinkedIn public ID (e.g., "johndoe")

Returns: Profile interests organized by category (influencers, companies, groups, topics)

Inputs: profile_id (required). Returns: object

get_profile_postsB

Get posts from a specific LinkedIn profile.

Args: profile_id: LinkedIn public ID or URN limit: Maximum number of posts to return (default: 10, max: 50) use_cache: Whether to use cached data if available (default: True)

Returns posts with engagement metrics (likes, comments, shares).

Inputs: profile_id (required), limit, use_cache. Returns: object

get_profile_sectionsA

Get all editable profile sections with current content.

Returns overview of profile sections including:

  • Basic info (name, headline, location)

  • About/Summary

  • Experience count

  • Education count

  • Skills overview

Inputs: no named parameters. Returns: object

get_profile_skillsB

Get skills and endorsements for a LinkedIn profile.

Args: profile_id: LinkedIn public ID

Returns skills categorized by endorsement count with top endorsers.

Inputs: profile_id (required). Returns: object

get_profile_viewsA

Get profile view statistics for the authenticated user.

Returns profile view data including view count and viewer information (if available based on your LinkedIn subscription).

WARNING: Uses unofficial API.

Inputs: no named parameters. Returns: object

get_rate_limit_statusB

Get current rate limit status.

Returns remaining API calls and rate limit information.

Inputs: no named parameters. Returns: object

get_scheduled_postC

Get a specific scheduled post.

Args: job_id: ID of the scheduled post

Returns the scheduled post details.

Inputs: job_id (required). Returns: object

get_schoolB

Get school/university information.

Args: public_id: School's public identifier (URL slug)

Returns school details including name, description, follower count, etc.

Inputs: public_id (required). Returns: object

get_similar_profilesB

Get profiles similar to a given profile.

Uses the Professional Network Data API to find similar profiles based on industry, role, skills, and other factors.

Args: profile_id: LinkedIn public ID (e.g., "johndoe") limit: Maximum number of similar profiles to return (default: 10)

Returns: List of similar profiles with relevance scoring

Inputs: profile_id (required), limit. Returns: object

list_draftsB

List all content drafts.

Args: tag: Optional tag to filter by

Returns list of drafts sorted by last update.

Inputs: tag. Returns: object

list_scheduled_postsB

List all scheduled posts.

Args: status: Filter by status (pending, published, failed, cancelled)

Returns list of scheduled posts.

Inputs: status. Returns: object

mark_conversation_as_seenB

Mark a conversation as read/seen.

Args: conversation_urn: Conversation URN ID

Returns success status.

WARNING: Uses unofficial API.

Inputs: conversation_urn (required). Returns: object

publish_draftB

Publish a draft as a LinkedIn post.

Args: draft_id: ID of the draft to publish visibility: Post visibility - PUBLIC, CONNECTIONS, or LOGGED_IN

Returns the published post details.

Inputs: draft_id (required), visibility. Returns: object

remove_connectionA

Remove an existing LinkedIn connection.

Args: profile_id: LinkedIn profile public ID of the connection to remove

Returns success status.

WARNING: This action is IRREVERSIBLE. The person will need to re-request connection and you'll need to accept. Uses unofficial API.

Inputs: profile_id (required). Returns: object

reply_invitationA

Accept or reject a connection invitation.

Args: invitation_id: Invitation ID (from get_invitations results) shared_secret: Shared secret (from get_invitations results) action: 'accept' or 'reject'

Returns success status.

WARNING: Uses unofficial API.

Inputs: invitation_id (required), shared_secret (required), action. Returns: object

schedule_postB

Schedule a post for future publishing.

Args: content: Post content scheduled_time: ISO format datetime (e.g., "2024-12-25T10:00:00") visibility: Post visibility - PUBLIC, CONNECTIONS, or LOGGED_IN timezone: Timezone for the scheduled time (default: UTC)

Returns the scheduled post details with job_id.

Inputs: content (required), scheduled_time (required), visibility, timezone. Returns: object

search_adsA

Search for ads in the LinkedIn Ad Library.

The Ad Library provides transparency into ads running on LinkedIn. At least one of keyword or advertiser must be provided.

Requires "LinkedIn Ad Library" product enabled in your LinkedIn Developer app.

Args: keyword: Search term to find in ad content advertiser: Company/advertiser name to search for country: ISO 3166-1 alpha-2 country code (e.g., "US", "GB", "DE") count: Number of results to return (default 25, max 100)

Returns: List of ads matching the search criteria with details including: - Advertiser and payer information - Ad content (text, images, videos) - Impression data and targeting parameters

Inputs: keyword, advertiser, country, count. Returns: object

search_ads_by_advertiserA

Search for all ads by a specific advertiser/company.

Requires "LinkedIn Ad Library" product enabled in your LinkedIn Developer app.

Args: advertiser_name: Name of the advertiser/company to search for country: Optional country filter (ISO 3166-1 alpha-2 code) count: Number of results to return (default 25, max 100)

Returns: List of ads from the specified advertiser with full details.

Inputs: advertiser_name (required), country, count. Returns: object

search_ads_by_keywordA

Search for ads containing a specific keyword.

Requires "LinkedIn Ad Library" product enabled in your LinkedIn Developer app.

Args: keyword: Search term to find in ad content country: Optional country filter (ISO 3166-1 alpha-2 code) count: Number of results to return (default 25, max 100)

Returns: List of ads matching the keyword with full details.

Inputs: keyword (required), country, count. Returns: object

search_companiesB

Search for companies on LinkedIn.

Args: keywords: Search keywords limit: Maximum results to return (default: 10, max: 50)

Returns list of matching companies.

Search priority:

  1. Fresh Data API (requires Pro plan $45/mo for search-companies endpoint)

  2. linkedin-api (cookie-based, may be blocked by LinkedIn bot detection)

Inputs: keywords (required), limit. Returns: object

search_jobsA

Search for job postings on LinkedIn.

Args: keywords: Search keywords (e.g., 'Python Developer', 'Product Manager') location_name: Location (e.g., 'San Francisco Bay Area', 'New York') job_type: Job type filter - F=Full-time, P=Part-time, C=Contract, T=Temporary, I=Internship experience: Experience level - 1=Internship, 2=Entry, 3=Associate, 4=Mid-Senior, 5=Director, 6=Executive remote: Remote options - 1=On-site, 2=Remote, 3=Hybrid distance: Distance from location in miles listed_at: Max seconds since job was posted (default: 86400 = 24 hours) limit: Maximum results to return (default: 10, max: 50)

Returns list of matching job postings.

WARNING: Uses unofficial API. May trigger LinkedIn bot detection with heavy use.

Inputs: keywords, location_name, job_type, experience, +4 more. Returns: object

search_peopleA

Search for people on LinkedIn.

Args: keywords: General search keywords limit: Maximum results to return (default: 10, max: 50) keyword_title: Filter by job title (e.g., 'VP Engineering', 'Product Manager') keyword_company: Filter by company name

Note: Location/region filters are not supported by the underlying API.

Returns list of matching profiles with name, title, location, and profile URL.

Search priority:

  1. Fresh Data API (requires Pro plan $45/mo for search-leads endpoint)

  2. linkedin-api (cookie-based, may be blocked by LinkedIn bot detection)

Inputs: keywords, limit, keyword_title, keyword_company. Returns: object

send_connection_requestA

Send a connection request to a LinkedIn profile.

Args: profile_id: LinkedIn profile public ID (e.g., 'john-doe') message: Optional personalized message (max ~300 characters)

Returns success status and request details.

WARNING: Uses unofficial API. May trigger LinkedIn bot detection. LinkedIn limits connection requests. Use responsibly.

Inputs: profile_id (required), message. Returns: object

send_messageA

Send a LinkedIn message to one or more recipients.

Args: recipients: List of LinkedIn profile public IDs (e.g., ['john-doe', 'jane-smith']) text: Message content to send

Returns success status and message details.

WARNING: Uses unofficial API. May trigger LinkedIn bot detection. Sending too many messages may result in account restrictions. Use responsibly and respect LinkedIn's terms of service.

Inputs: recipients (required), text (required). Returns: object

update_draftB

Update a content draft.

Args: draft_id: ID of the draft to update content: New content (optional) title: New title (optional) tags: New comma-separated tags (optional)

Returns the updated draft.

Inputs: draft_id (required), content, title, tags. Returns: object

update_profile_headlineA

Update profile headline.

Requires Playwright browser automation to be enabled.

Args: headline: New headline text (max 220 characters)

Returns success status.

Inputs: headline (required). Returns: object

update_profile_summaryA

Update profile summary/about section.

Requires Playwright browser automation to be enabled.

Args: summary: New summary text (max 2600 characters)

Returns success status.

Inputs: summary (required). Returns: object

update_scheduled_postB

Update a scheduled post.

Args: job_id: ID of the scheduled post content: New content (optional) scheduled_time: New ISO format datetime (optional) visibility: New visibility (optional)

Returns the updated scheduled post.

Inputs: job_id (required), content, scheduled_time, visibility. Returns: object

upload_background_photoA

Upload a new background/banner photo.

Requires Playwright browser automation to be enabled.

Args: photo_path: Absolute path to the photo file (JPG, PNG)

Returns success status.

Inputs: photo_path (required). Returns: object

upload_profile_photoA

Upload a new profile photo.

Requires Playwright browser automation to be enabled.

Args: photo_path: Absolute path to the photo file (JPG, PNG)

Returns success status.

Inputs: photo_path (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.3/5.0

    Scored across 85 tools

    Disambiguation2/5

    The tool set suffers from significant ambiguity with many overlapping purposes. For example, there are multiple content analysis tools (analyze_content_performance, analyze_my_content_performance, generate_engagement_report) with unclear distinctions, and multiple post creation tools (create_post, create_image_post, create_video_post, create_document_post) that could cause confusion about which to use for specific media types. The sheer number of tools (85) exacerbates this problem, making it difficult for an agent to reliably select the right tool.

    Naming Consistency4/5

    Naming is mostly consistent with a clear verb_noun pattern throughout (e.g., get_profile, create_post, analyze_content_performance). There are minor deviations like 'debug_context' (noun_verb) and 'list_drafts' (verb_plural_noun), but the overall convention is readable and predictable. The consistency helps despite the large number of tools.

    Tool Count1/5

    With 85 tools, this is an extreme mismatch for a LinkedIn-focused server. The count is excessive, creating overwhelming complexity and likely including many niche or redundant tools. A well-scoped server for this domain should have 15-30 tools at most; 85 indicates poor coherence and will confuse agents trying to navigate the surface.

    Completeness5/5

    The tool set is remarkably complete for the LinkedIn domain, covering nearly every conceivable operation: profile management (get, update, skills), content creation (posts, comments, reactions, drafts), analysis (performance, engagement, hashtags), search (people, companies, jobs, ads), messaging, connections, and scheduling. There are no obvious gaps; it provides full CRUD/lifecycle coverage across all major LinkedIn features.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers