LinkedIn MCP Pro Max
Integrates OpenAI's API for AI-powered content generation, used to create LinkedIn posts, resumes, and cover letters.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@LinkedIn MCP Pro Max search for data scientist jobs at Google"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Quick Start
1. Prerequisites
Ensure you have uv installed:
curl -LsSf https://astral.sh/uv/install.sh | sh2. Installation & Setup
Method A: Automated Setup (Recommended)
chmod +x scripts/setup.sh
./scripts/setup.shThe script handles dependency syncing, .env bootstrapping, and stealth browser provisioning.
Method B: Manual Setup
uv sync
uv run python -m patchright install chromium
cp .env.example .envEdit .env with your LinkedIn credentials:
LINKEDIN_EMAIL="your-email@example.com"
LINKEDIN_PASSWORD="your-secure-password"
LINKEDIN_USERNAME="your-profile-slug"4. First-Run Authentication
uv run linkedin-mcp-pro-max --login5. Connect to Claude Desktop (or any MCP client)
Add to your claude_desktop_config.json:
{
"mcpServers": {
"linkedin-mcp-pro-max": {
"command": "/home/naimul/.local/bin/uv",
"args": [
"--directory",
"/home/naimul/linkedin-mcp-pro-max",
"run",
"linkedin-mcp-pro-max"
]
}
}
}Related MCP server: linkedin-mcp-pro
The MCP Toolkit (14 Unified Tools)
Category | Tool | Actions | Description |
Profile |
|
| Manage deep profile data, AI analysis, and identity updates |
|
| Manage professional experience entries | |
|
| Manage education entries | |
|
| Manage skills on your profile | |
| - | Get detailed corporate metadata and insights | |
Jobs & Intel |
|
| Discover, analyze, and apply for job postings |
|
| Manage internal job application tracking | |
Content |
| - | Publish AI-generated posts autonomously |
|
| Engage with feed posts via URL | |
Documents |
| - | Generate a professional resume from your profile |
| - | Target your resume to match a specific Job ID | |
| - | Create a personalized contextual cover letter | |
| - | View all available document templates | |
System |
|
| Manage the MCP server lifecycle |
Architecture
Built on Clean Architecture with a one-way dependency rule and a Unified Component Registry that eliminates all manual wiring.
[tools/] → [services/] → [browser/actors/ + browser/scrapers/]
ctx.my_svc manager.my_actor / manager.my_scraperDirectory Structure
src/
├── app.py # Composition root — auto-wires from registry
├── helpers/
│ └── registry.py # Unified discovery engine (ServiceMeta, ActorMeta, ScraperMeta)
├── tools/ # MCP tool definitions (@mcp.tool) — auto-discovered
├── services/ # Business logic layer — auto-wired via SERVICE markers
├── browser/
│ ├── actors/ # Write operations (UI interaction) — auto-registered
│ ├── scrapers/ # Read operations (data extraction) — auto-registered
│ ├── manager.py # Orchestrator — auto-instantiates actors/scrapers
│ └── helpers/ # Low-level browser utilities (driver, sniffer, dom)
├── api/ # LinkedIn internal API client
├── db/ # Database repositories
├── schema/ # Pydantic domain models
├── config/ # Settings and environment
└── providers/ # AI provider wrappers (OpenAI, Claude)The Zero-Config Flow
At startup, helpers/registry.py scans services/, browser/actors/, and browser/scrapers/ automatically:
discover_all()
├── services/*.py → SERVICE = ServiceMeta(...) → injected into AppContext
├── browser/actors/* → ACTOR = ActorMeta(...) → instantiated in BrowserManager
└── browser/scrapers/ → SCRAPER = ScraperMeta(...) → instantiated in BrowserManagerNo manual registration. No editing app.py or manager.py.
Adding New Features
For the complete development pipeline, debugging guide, and working examples, see the Tool Development Guide.
A full feature (scraper + service + tool) requires exactly 3 new files. No existing file is modified.
1. Browser Scraper — src/browser/scrapers/my_feature.py
from helpers.registry import ScraperMeta
class MyFeatureScraper:
def __init__(self, page): ...
async def scrape(self): ...
SCRAPER = ScraperMeta(attr="my_feature_scraper", cls=MyFeatureScraper)2. Service — src/services/my_feature.py
from helpers.registry import ServiceMeta
class MyFeatureService:
def __init__(self, browser=None): ...
async def do_work(self): ...
SERVICE = ServiceMeta(attr="my_feature", cls=MyFeatureService, deps=["browser"], lazy=True)3. Tool — src/tools/my_feature.py
from app import mcp, get_ctx
@mcp.tool()
async def my_feature_tool(param: str) -> str:
"""Description the AI reads to decide when to use this tool."""
ctx = await get_ctx()
await ctx.initialize_browser()
result = await ctx.my_feature.do_work()
return json.dumps(result)app.py, manager.py, services/__init__.py, tools/__init__.py — never touched.
uv run linkedin-mcp-pro-max # Start MCP server
uv run linkedin-mcp-pro-max --login # Autonomous headless login
uv run linkedin-mcp-pro-max --status # Check authentication status
uv run linkedin-mcp-pro-max --logout # Clear session and cookiesDocumentation
Document | Description |
Full pipeline: creating tools, services, actors, scrapers. Debugging guide. | |
Service layer conventions and dependency rules | |
Actor conventions and browser interaction patterns | |
Pydantic model conventions |
Available Tools
14 toolsapplicationA
Manage tracked job applications locally.
Args: action: 'list', 'track', or 'update', job_id: LinkedIn job ID, job_title: Job title, company: Company name, status: Application status (interested/applied/interviewing/offered/rejected/withdrawn). For 'list', filters results. notes: Optional notes, url: Optional job URL,
allowed_args_for_action = { "list": ["status"], "track": ["job_id", "job_title", "company", "status", "notes", "url"], "update": ["job_id", "status", "notes"] }
Inputs: action (required), url, notes, job_id, +3 more. Returns: result
companyB
Get company information from LinkedIn.
Args: company_id: LinkedIn company ID or URL slug,
Inputs: company_id (required). Returns: result
create_linkedin_postA
Generate and publish a new LinkedIn post using an internal AI writer.
The AI will craft a complete, publish-ready post based on the topic you provide. Optionally, a second AI pass generates a detailed visual prompt which is sent to the image generation engine to create and attach a professional image to the post.
Full pipeline (when include_image=True): 1. LLM writes the post text (topic + tone + optional CTA). 2. LLM writes a rich, detailed image generation prompt. 3. Image generator (Flux / Gemini) creates the image. 4. Browser uploads image + posts text together on LinkedIn.
Args: topic: What the post should be about (e.g., 'why clean code matters', 'lessons from 6 months of remote work'). tone: Writing style — 'professional' (default), 'storytelling', or 'thought-leader'. include_cta: If True (default), end with a question or call-to-action. include_image: If True, generate and attach an AI image to the post. Requires IMAGE_GEN_API_BASE to be configured. If image generation fails, the post is published text-only.
Returns: JSON string with: - status: 'success' or 'error' - generated_post: The complete text that was published. - character_count: Length of the published post. - topic: Echo of the original topic for traceability. - image_prompt: (if include_image) The prompt used for image gen. - image_url: (if include_image) Local path of the generated image. - image_warning: (if include_image failed) Reason why image was skipped. - message: Human-readable confirmation.
Inputs: topic (required), tone, include_cta, include_image. Returns: result
educationB
Manage education entries on your LinkedIn profile.
Args: action: 'add', 'update', or 'delete', school: School/University name, degree: Degree (e.g. 'Bachelor of Science'), field_of_study: Field of study (optional), grade: Grade/GPA (optional), start_year: Start year string (e.g. '2018'), end_year: End year string (e.g. '2022'), description: Description of your studies (optional), education_id: The ID of the education entry (required for 'update'),
Inputs: action (required), degree (required), school (required), grade, +5 more. Returns: result
experienceA
Manage experience entries on your LinkedIn profile.
Args: action: 'add', 'update', or 'delete', title: Job title (e.g. 'Software Engineer'), company: Company name, position_id: The ID of the position (required for 'update'), employment_type: Type (e.g. 'Full-time', 'Contract'), location: City/Country, description: Role description, start_month: Month name (e.g. 'January'), start_year: Year string (e.g. '2023'), end_month: End Month name (e.g. 'December'), end_year: End Year string (e.g. '2024'), is_current: Whether this is your current role,
allowed_args_for_action = { "add": ["title", "company", "employment_type", "location", "description", "start_month", "start_year", "end_month", "end_year", "is_current"], "update": ["position_id", "title", "company", "employment_type", "location", "description", "start_month", "start_year", "end_month", "end_year", "is_current"], "delete": ["title", "company"] }
Inputs: title (required), action (required), company (required), end_year, +8 more. Returns: result
generate_cover_letterA
Generate a personalized cover letter for a specific job posting.
Args: profile_id: LinkedIn profile ID or 'me' for self job_id: LinkedIn job ID template: Template name (professional, concise) output_format: Output format (html, md, pdf)
Inputs: job_id (required), profile_id (required), template, output_format. Returns: result
generate_resumeA
Generate a professional resume from a LinkedIn profile using AI enhancement.
Args: profile_id: LinkedIn profile ID or 'me' for self template: Template name (modern, professional) output_format: Output format (html, md, pdf)
Inputs: profile_id (required), template, output_format. Returns: result
interact_with_postA
Interact with a specific LinkedIn post (read, like, comment).
Args: post_url: The URL of the LinkedIn post to interact with. action: Strategy to apply: 'read', 'like', or 'comment'. Default is 'read'. comment: The text to post if action is 'comment'.
Inputs: post_url (required), action, comment. Returns: result
jobA
Discover and manage LinkedIn job postings.
Args: action: 'search', 'details', 'recommended', or 'apply', job_id: LinkedIn job ID (required for 'details' and 'apply'), keywords: Search keywords (job title, skills, company), location: Geographic location (city, state, country), job_type: Filter by type: FULL_TIME, PART_TIME, CONTRACT, TEMPORARY, INTERNSHIP, experience_level: Filter: INTERNSHIP, ENTRY_LEVEL, ASSOCIATE, MID_SENIOR, DIRECTOR, EXECUTIVE, remote: Filter for remote jobs only, date_posted: Filter by recency: past-24h, past-week, past-month, page: Page number for pagination (default 1), count: Results per page (1-50, default 20),
allowed_args_for_action = { "search": ["keywords", "location", "job_type", "experience_level", "remote", "date_posted", "page", "count"], "details": ["job_id"], "recommended": ["count"], "apply": ["job_id"] }
Inputs: action (required), page, count, job_id, +6 more. Returns: result
list_templatesA
List all available templates for resumes and cover letters.
Args: template_type: Template type to list: 'resume', 'cover_letter', or 'all'
Inputs: template_type. Returns: result
profileB
Manage LinkedIn profiles.
Args: action: The profile action to perform ('get', 'analyze', 'update', 'update_cover_image'). profile_id: LinkedIn profile ID (username slug) or 'me' for self (for 'get' and 'analyze'). headline: New profile headline (for 'update'). summary: New profile 'About' summary (for 'update'). image_path: Absolute path to the image file (for 'update_cover_image').
allowed_args_for_action = { "get": ["profile_id"], "analyze": ["profile_id"], "update": ["headline", "summary"], "update_cover_image": ["image_path"] }
Inputs: action (required), summary, headline, image_path, +1 more. Returns: result
serverC
Manage the MCP server.
Args: action: The server action to perform ('restart'), reason: Optional reason for the restart,
allowed_args_for_action = { "restart": ["reason"] }
Inputs: action (required), reason. Returns: result
skillsA
Manage skills on your LinkedIn profile.
Args: action: 'add' or 'delete', skill_name: Name of the skill (e.g. 'Python', 'Machine Learning'),
Inputs: action (required), skill_name (required). Returns: result
tailor_resumeA
Generate a resume tailored to a specific job posting.
Args: profile_id: LinkedIn profile ID or 'me' for self job_id: LinkedIn job ID to tailor the resume for template: Template name (modern, professional) output_format: Output format (html, md, pdf)
Inputs: job_id (required), profile_id (required), template, output_format. Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 14 tools
Most tools have clearly distinct purposes (e.g., interact_with_post vs create_linkedin_post, job vs application). Some minor overlap exists between generate_resume and tailor_resume, but descriptions clarify the distinction. Profile and its sub-section tools (experience, skills, education) are logically separated but could be slightly ambiguous.
Naming conventions are mixed: some tools are verb_noun (create_linkedin_post, generate_resume, list_templates), while others are bare nouns (job, profile, company, experience, skills, education, server, application). This inconsistency makes the tool set feel less predictable, even though the noun tools share a pattern of action-based arguments.
With 14 tools, the server covers a broad but well-scoped set of LinkedIn features (posts, jobs, profiles, resumes, applications). The count is within the ideal 3-15 range and each tool addresses a meaningful function without redundancy.
The server covers core LinkedIn workflows: profile management (experience, skills, education), job search/apply, post creation/interaction, and resume/cover letter generation. Minor gaps exist, such as no post deletion or edit, and no direct messages/connections, but these are not critical for the apparent job-seeker focus.
Maintenance
Related MCP Connectors
Managed LinkedIn MCP server for AI agents: search, connect, message and enrich on accounts you own.
The LinkedIn API for AI agents. Search, inbox, posts and outreach over MCP.
A hosted LinkedIn MCP server for your own account. Paste one address into Claude, ChatGPT, Cursor or n8n to read your inbox, send messages and invitations, and search people. Free to start. Not made by LinkedIn.
LinkedIn outreach MCP server — 19 tools for AI agents to prospect, sequence, and manage contacts.
Related MCP Servers
- AlicenseAqualityDmaintenanceFully featured MCP server that provides automation tools for LinkedIn, supporting browser-based scraping and API-based operations for content management, media uploads, and reactions.64MIT
- AlicenseAqualityCmaintenanceSelf-hosted, ban-safe MCP server for LinkedIn that provides 22 tools for profiles, search, jobs, posts, connections, and messages. Integrates with any MCP-compatible client like Claude Desktop.581MIT
- AlicenseNot gradedqualityDmaintenanceAI-powered LinkedIn automation server for content generation, profile/company data extraction, and connection request automation, integrating with MCP clients like Claude Desktop.MIT
- AlicenseNot gradedqualityDmaintenanceMCP server for programmable LinkedIn automation via Playwright, offering 20 tools for profile management, messaging, feed interaction, and job searching through real browser automation.18 npmMIT