Click on "Install 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 Server search for software engineer jobs in San Francisco"
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.
A Model Context Protocol (MCP) server for LinkedIn. Search people, companies, and jobs, scrape profiles, and retrieve structured JSON data from any MCP-compatible AI client.
https://github.com/user-attachments/assets/50cd8629-41ee-4261-9538-40dc7d30294e
Built with FastMCP, Patchright, and a clean hexagonal architecture.
Category | Tools |
People |
|
Companies |
|
Jobs |
|
Feed |
|
Browser |
|
The get_person_profile tool supports granular section scraping. Request only the sections you need:
Main profile (always included) — name, headline, location, followers, connections, about, profile image
Experience — title, company, dates, duration, description, company logo
Education — school, degree, dates, description, school logo
Contact info — email, phone, websites, birthday, LinkedIn URL
Interests — people, companies, and groups followed
Honors and awards — title, issuer, description
Languages — language name and proficiency level
Posts — recent activity with reactions and timestamps
Recommendations — received and given, with author details
About (always included) — overview, website, industry, size, headquarters, specialties, logo
Posts — recent feed posts with engagement metrics
Jobs — current open positions
The search_jobs tool supports the following filters:
Filter | Values |
|
|
|
|
|
|
|
|
|
|
|
|
The apply_for_job tool automates the "Easy Apply" process for a given job. It will intelligently cycle through the application steps and submit the application. If it encounters a required custom question it cannot answer, it will securely close the dialog and notify the client that manual completion is required.
The share_post tool publishes text directly to your LinkedIn feed. Standard MCP architecture dictates that content generation should remain in your LLM client (e.g. Claude Desktop).
To generate viral, high-engagement posts, simply prompt Claude with your desired template. For example:
"Claude, generate a high engagement LinkedIn post about how I failed my first MCP server project. Use the 'LoRA + API synthetic pairs' viral template and include relevant hashtags. Once you generate it, use the
share_posttool to publish it."
All tools utilize a robust, structured JSON error schema. If an error occurs (e.g., session expired, rate limit hit), the server returns a detailed message that MCP clients like Claude can easily interpret:
{
"error": "RATE_LIMIT_EXCEEDED",
"message": "[search_jobs] LinkedIn rate limit detected. Please wait ~5 minutes before retrying.",
"retryable": true,
"timestamp": "2026-03-21T17:15:00.000000+00:00"
}Related MCP server: LinkedIn MCP
Python 3.12 or later
uv package manager
A LinkedIn account for authentication
git clone https://github.com/[Your GitHub Username]/linkedin-mcp-server.git
cd linkedin-mcp-server
uv syncThis project uses Patchright (a patched fork of Playwright) for browser automation. You need to install the browser binaries before first use:
uv run patchright installWindows users: If the command above fails with
program not found, run instead:uv run python -m patchright install
uv run linkedin-mcp-server --loginA browser window will open. Log in to LinkedIn and the session will be persisted locally at ~/.linkedin-mcp-server/browser-data.
stdio transport (default — for Claude Desktop, Cursor, and similar clients):
uv run linkedin-mcp-serverHTTP transport (for remote clients, the MCP Inspector, etc.):
uv run linkedin-mcp-server --transport streamable-http --host 0.0.0.0 --port 8000Add to your MCP configuration file:
{
"mcpServers": {
"linkedin": {
"command": "uv",
"args": [
"--directory", "/path/to/linkedin-mcp-server",
"run", "linkedin-mcp-server"
]
}
}
}npx @modelcontextprotocol/inspectorThen connect to http://localhost:8000/mcp if using HTTP transport.
Configuration follows a strict precedence chain: CLI args > environment variables > .env file > defaults.
Argument | Description | Default |
|
|
|
| Host for HTTP transport |
|
| Port for HTTP transport |
|
|
|
|
| Run browser in headless mode |
|
| Show browser window (visible mode) | — |
| Open browser for LinkedIn login | — |
| Clear stored credentials | — |
| Check session status | — |
Create a .env file in the project root:
# Server
LINKEDIN_TRANSPORT=stdio
LINKEDIN_HOST=127.0.0.1
LINKEDIN_PORT=8000
LINKEDIN_LOG_LEVEL=WARNING
# Browser
LINKEDIN_HEADLESS=true
LINKEDIN_SLOW_MO=0
LINKEDIN_TIMEOUT=10000
LINKEDIN_VIEWPORT_WIDTH=1280
LINKEDIN_VIEWPORT_HEIGHT=720
LINKEDIN_CHROME_PATH=
LINKEDIN_USER_AGENT=
LINKEDIN_USER_DATA_DIR=~/.linkedin-mcp-server/browser-dataThe project follows a hexagonal (ports and adapters) architecture with strict layer separation:
src/linkedin_mcp_server/
├── domain/ # Core business logic — zero external dependencies
│ ├── models/ # Data models (Person, Company, Job, Search)
│ ├── parsers/ # HTML to structured data parsers
│ ├── exceptions.py # Domain exceptions
│ └── value_objects.py # Immutable configuration and content objects
├── ports/ # Abstract interfaces
│ ├── auth.py # Authentication port
│ ├── browser.py # Browser automation port
│ └── config.py # Configuration port
├── application/ # Use cases — orchestration layer
│ ├── scrape_person.py
│ ├── scrape_company.py
│ ├── scrape_job.py
│ ├── search_people.py
│ ├── search_jobs.py
│ └── manage_session.py
├── adapters/ # Concrete implementations
│ ├── driven/ # Infrastructure adapters (browser, auth, config)
│ └── driving/ # Interface adapters (CLI, MCP tools, serialization)
└── container.py # Dependency injection composition rootPorts and adapters — Domain logic is fully decoupled from infrastructure. The browser engine, MCP framework, and configuration source can all be swapped independently.
Dependency injection — A single Container class acts as the composition root and is the only place that imports concrete adapter classes.
Structured JSON output — LinkedIn HTML is parsed into typed Python dataclasses, then serialized to JSON for reliable LLM consumption.
Session persistence — Browser state is saved to disk, so authentication is required only once.
uv sync --group dev
uv run pre-commit installuv run pytestWith coverage:
uv run pytest --cov=linkedin_mcp_serverThis project uses Ruff for both linting and formatting. Pre-commit hooks will run these automatically on each commit.
# Lint
uv run ruff check .
# Lint and auto-fix
uv run ruff check . --fix
# Format
uv run ruff format .This project is licensed under the MIT License. See the LICENSE file for details.
Contributions are welcome. Please read the contributing guide for details on the development workflow and submission process.
This tool is intended for personal and educational use. Scraping LinkedIn may violate their Terms of Service. Use responsibly and at your own risk. The authors are not responsible for any misuse or consequences arising from the use of this software.
Attempt to Easy Apply for a job on LinkedIn.
This will navigate to the job page, click Easy Apply if available, and try to submit the application by clicking 'Next'/ 'Review' and 'Submit application'. If custom required fields are present, it will decline and return a message.
Args: job_id: LinkedIn job ID
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of disclosure. It describes the navigation steps, click actions, and the case of failing due to custom required fields. This provides good transparency about the tool's behavior, though it omits prerequisites like login status or potential side effects (e.g., submitting an application).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise with two paragraphs: the first clearly states the main action and steps, the second lists arguments. It is front-loaded and avoids unnecessary detail, though the second paragraph could be integrated more smoothly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, clear action) and the presence of an output schema, the description covers the main behavioral aspects, including a failure mode. It lacks context about prerequisites (e.g., session state) and return value details, but these are partially addressed by the implicit context and output schema.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. However, it only restates the parameter name and type ('LinkedIn job ID') without adding meaningful context like how to obtain the job_id (e.g., from search results) or its format. The added value is minimal.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it attempts to Easy Apply for a job on LinkedIn, specifying the verb 'apply', the resource 'job', and the method 'Easy Apply'. It distinguishes itself from sibling tools like get_job_details (view) and search_jobs (search) by focusing on the application action.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implicitly indicates when to use (when wanting to apply for a job) but does not explicitly provide guidance on when to use this tool versus alternatives, nor does it state conditions or prerequisites (e.g., logged-in session). The context is implied from the action, but no direct usage guidelines are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Check if the current LinkedIn session is authenticated and valid.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It states the function (check authentication validity) but does not disclose whether it causes side effects or what the output format is. For a zero-parameter tool, this is minimally adequate.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single, clear sentence with 8 words, front-loading the core purpose. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given a simple check with no parameters, the description is sufficient. The output schema exists externally, so return value details are not required here.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
There are no parameters, so baseline 4 applies. The description correctly indicates no input is needed.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('check') and resource ('session authenticated and valid'), clearly distinguishing this from sibling tools like 'start_login' or 'logout_and_cleanup'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives (e.g., start_login, close_browser). It does not mention preconditions or typical workflow context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close the browser instance and release resources. Credentials are preserved.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must disclose behavioral traits. It notes that credentials are preserved, but omits other side effects like session invalidation or resource cleanup scope. This is insufficient for safety-critical browser management.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two concise sentences with no redundancy. The first sentence states the primary action, the second adds a key behavioral detail (credential preservation). Every word earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and an existing output schema, the description covers the essential purpose and a behavioral note. It does not explain return values, but the output schema covers that. Slightly limited for a cleanup tool, but adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has no parameters (schema coverage 100% trivially). Description adds no parameter information, but none is needed. Baseline 4 for zero-parameter tools applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states 'Close the browser instance and release resources,' with a clear verb and resource. It distinguishes from sibling tools like check_session_status and logout_and_cleanup by focusing on the browser instance itself.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives like logout_and_cleanup. The description does not indicate prerequisites, context, or exclusions, leaving the agent to infer usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Verify if a URL is accessible by LinkedIn's crawler (bot).
This checks for missing Open Graph (OG) tags, bot blocking (WAF/Cloudflare), and other common issues that cause link preview failures on LinkedIn.
Args: url: The absolute URL to diagnose (e.g., https://example.com).
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so the description must fully disclose behavior. It explains what it checks but does not state side effects (e.g., network requests, read-only nature, rate limits). This lack of safety or impact detail limits transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise, starting with a one-sentence summary, followed by bullet points of checks, and a clear parameter definition. Every sentence adds value without redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given an output schema exists (not shown), the description covers the tool's purpose and diagnostic areas. It omits return format details but provides sufficient context for typical use.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description's 'Args' section adds valuable meaning: specifies the URL format and provides an example. This compensates for the schema lacking descriptions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool verifies URL accessibility by LinkedIn's crawler, listing specific checks (OG tags, bot blocking). This verb-resource pair is distinct from sibling tools which focus on jobs, profiles, etc.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explicitly states the tool's purpose: diagnosing link preview failures. While it doesn't list when not to use or alternatives, the sibling tools are unrelated, making the usage context clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get recent posts from a company's LinkedIn feed.
Args: company_name: LinkedIn company name (e.g., 'google', 'stripe', 'openai')
| Name | Required | Description | Default |
|---|---|---|---|
| company_name | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It fails to disclose behavioral traits such as authentication requirements, result limits, pagination, or rate limits. The description is too minimal for a read operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the purpose. However, it could include more detail without becoming verbose, given the simplicity of the tool.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With an output schema present, the description does not need to explain return values. However, it lacks context about prerequisites (e.g., logged-in session) and usage scope, which are relevant given sibling tools like start_login.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds meaning beyond the schema by providing example values (e.g., 'google', 'stripe', 'openai') for the company_name parameter, which has 0% schema description coverage. However, it does not explain the exact format or validity rules.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the verb 'get' and the resource 'recent posts from a company's LinkedIn feed'. It provides examples of company names, distinguishing it from sibling tools like get_company_profile or get_job_details.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool vs alternatives, no prerequisites or exclusions. Sibling tools are listed but not compared, leaving the agent to infer usage context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a specific company's LinkedIn profile.
Args: company_name: LinkedIn company name (e.g., 'google', 'stripe', 'openai') sections: Comma-separated list of extra sections to scrape. The about page is always included. Available sections: posts, jobs Default (None) scrapes only the about page.
| Name | Required | Description | Default |
|---|---|---|---|
| sections | No | ||
| company_name | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits. It mentions that the about page is always included and sections are extra, but does not discuss side effects, authorization needs, rate limits, or data mutability. The behavioral disclosure is minimal.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and front-loaded with the purpose. The Args section is structured but could be slightly more compact. Overall, it efficiently conveys the key information without unnecessary words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has an output schema (not shown but present), the description need not explain return values. However, it lacks usage guidelines and behavioral transparency. For a two-parameter tool, it covers input adequately but leaves gaps in completeness regarding when to use and behavioral context.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, yet the description adds clear meaning: company_name is illustrated with examples ('google', 'stripe'), and sections are explained with its possible values ('posts, jobs') and default behavior. This adds significant value beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Get a specific company's LinkedIn profile.' It uses a specific verb ('Get') and resource ('company's LinkedIn profile'), which distinguishes it from siblings like get_job_details or get_person_profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides parameter details but lacks explicit guidance on when to use this tool versus alternatives like get_company_posts. No context on prerequisites, limitations, or when-not-to-use is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get job details for a specific job posting on LinkedIn.
Args: job_id: LinkedIn job ID (e.g., '3912045678', '4108763210')
| Name | Required | Description | Default |
|---|---|---|---|
| job_id | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are absent, so description bears full burden. It only states 'get job details' without disclosing behavioral traits like auth needs, rate limits, or whether it's a read-only operation.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Very concise with the main purpose front-loaded. Only two sentences plus parameter description. No wasted words, though some users may prefer slightly more structure.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple one-parameter tool with an output schema, the description is adequate but lacks detail about what fields are returned in the job details. Context signals show an output schema exists, reducing the need for return value explanation, but completeness is still middling.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, but the description adds meaningful information for the job_id parameter with examples of valid IDs (e.g., '3912045678'), which adds value beyond the schema's type string.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
Clearly states verb 'get' and resource 'job details for a specific job posting on LinkedIn'. It is specific and distinguishes from sibling tools like search_jobs and apply_for_job.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance on when to use this tool versus alternatives (e.g., search_jobs or get_person_profile). No mention of prerequisites or context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get a specific person's LinkedIn profile.
Args: linkedin_username: LinkedIn username (e.g., 'satyanadella', 'jeffweiner08') sections: Comma-separated list of extra sections to scrape. The main profile page is always included. Available sections: experience, education, interests, honors, languages, contact_info, posts Default (None) scrapes only the main profile page.
| Name | Required | Description | Default |
|---|---|---|---|
| sections | No | ||
| linkedin_username | Yes |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It describes that the main profile is always included and sections are optional, but does not disclose potential behaviors like error handling, rate limits, or data volatility. This is adequate but not comprehensive.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is clear and front-loaded with the purpose, but the Args section is slightly verbose. Each sentence adds value, but could be slightly more concise without losing information.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers parameters well and the tool has an output schema, so return values are not needed. It lacks behavioral or error context, but for a simple data retrieval tool, it is reasonably complete. Minor gaps remain.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, meaning the schema itself provides no descriptions. The description adds significant meaning: examples for linkedin_username, a list of available sections with their behavior, and default behavior. This fully compensates for the schema gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the tool retrieves a specific person's LinkedIn profile, using a clear verb+resource structure. It distinguishes itself from siblings like 'search_people' and 'get_company_profile' by focusing on an individual profile.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides parameter usage details (linkedin_username format, sections options) but does not explicitly state when to use or avoid this tool relative to alternatives. It implies use for a specific person, which is clear, but lacks direct guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Close the browser and completely wipe all stored LinkedIn credentials, cookies, and profile data for privacy.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It discloses the key behaviors: closing browser and wiping credentials, cookies, and profile data. However, it lacks details on side effects (e.g., irreversibility, effect on other sessions) or what the return value indicates.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is concise and front-loaded with the core action. Every word adds value, and there is no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters and existence of an output schema (which is assumed to cover return values), the description is complete for a simple tool. It covers the essential purpose and scope without omission.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so baseline is 4. The description adds meaning beyond the schema by explaining the action and scope, which is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action (close browser and wipe) and the resource (LinkedIn credentials, cookies, profile data). It distinguishes itself from the sibling 'close_browser' by including the cleanup step, providing specific verb+resource+scope.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage for privacy when logging out completely, but it does not explicitly state when to use this tool over alternatives like 'close_browser' or 'check_session_status'. No when-not-to-use or context is provided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for jobs on LinkedIn.
Returns job_ids that can be passed to get_job_details for full info.
Args: keywords: Search keywords (e.g., 'backend developer', 'devops engineer') location: Optional location filter (e.g., 'Austin', 'Singapore') max_pages: Maximum number of result pages to load (1-10, default 3) date_posted: Filter by posting date (past_hour, past_24_hours, past_week, past_month) job_type: Filter by job type, comma-separated (full_time, part_time, contract, temporary, volunteer, internship, other) experience_level: Filter by experience level, comma-separated (internship, entry, associate, mid_senior, director, executive) work_type: Filter by work type, comma-separated (on_site, remote, hybrid) easy_apply: Only show Easy Apply jobs (default false) sort_by: Sort results (date, relevance)
| Name | Required | Description | Default |
|---|---|---|---|
| sort_by | No | ||
| job_type | No | ||
| keywords | Yes | ||
| location | No | ||
| max_pages | No | ||
| work_type | No | ||
| easy_apply | No | ||
| date_posted | No | ||
| experience_level | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description must cover behavioral aspects. It explains that the tool returns job IDs but does not disclose rate limits, authentication needs, or whether it reads existing data without modification. This is a basic but acceptable level.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a brief summary, return value note, and then a param list. It is slightly lengthy but each line adds value. Could be tightened slightly.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the high parameter count (9) and many filter options, the description covers purpose, return value, and all parameters thoroughly. It lacks information about pagination or search scope but is otherwise complete for an agent.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0% description coverage, but the description provides detailed guidance for each parameter, including example values for keywords and enumerated options for filters like job_type, experience_level, etc. This adds significant meaning beyond the raw schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Search for jobs on LinkedIn.' It also mentions that the return value (job_ids) can be passed to get_job_details, which differentiates it from other search tools like search_people.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use this tool (for job searching) and how to follow up with get_job_details. However, it does not explicitly state when not to use it or compare with alternatives like search_people.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Search for people on LinkedIn.
Args: keywords: Search keywords (e.g., 'product manager', 'ML engineer at Meta') location: Optional location filter (e.g., 'London', 'Berlin')
| Name | Required | Description | Default |
|---|---|---|---|
| keywords | Yes | ||
| location | No |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility for behavioral disclosure. It fails to mention authentication needs, rate limits, or any behavioral traits beyond the search action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is very short and front-loaded, with no wasted words. It follows a docstring format, making it easy to parse, though slightly more structure could improve readability.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the existence of an output schema, the description doesn't need to explain return values. However, it omits details like pagination, sorting, or result limits, leaving gaps for a search tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
With 0% schema description coverage, the description compensates by providing concrete examples for both keywords and location, adding meaningful usage context beyond the bare schema definitions.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states 'Search for people on LinkedIn' with a specific verb and resource. It provides example keywords, distinguishing it from sibling tools like get_person_profile which targets a specific person.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies usage through examples but does not explicitly state when to use or avoid this tool, nor does it mention alternatives among siblings. Basic context is present but no exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Launch an interactive browser window to log in to LinkedIn. The user will complete the login in the pop-up window.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description must carry the full behavioral burden. It discloses the interactive nature and user involvement, but lacks details on what happens after login (e.g., session management, return values, or whether the browser remains open).
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two concise sentences with no redundant information. It is front-loaded with the action and clearly conveys the key points.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool has no parameters and an output schema exists, the description provides essential context. It could benefit from mentioning what the output contains (e.g., session token) but overall is complete enough for a simple login tool.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has 0 parameters (100% coverage), so no parameter documentation is needed. Baseline 4 is appropriate as the description adds no parameter info but does not need to.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states the action 'Launch an interactive browser window' and the resource 'log in to LinkedIn'. It clearly distinguishes from sibling tools like check_session_status and logout_and_cleanup by specifying the login process.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description clearly indicates that the tool initiates an interactive login requiring user action in the pop-up. It implies this is the first step before other actions like get_person_profile, but does not explicitly mention prerequisites or when not to use it.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0apply_for_jobcheck_session_statusclose_browserdiagnose_linkget_company_postsget_company_profileget_job_detailsget_person_profilelogout_and_cleanupsearch_jobssearch_peopleshare_poststart_loginEach tool targets a distinct function: jobs, people, companies, session management, posting, and link diagnosis. No two tools have overlapping purposes; even session-related tools have clear boundaries (e.g., close_browser vs logout_and_cleanup).
All tool names follow a consistent verb_noun snake_case pattern (e.g., get_job_details, search_people, check_session_status). Verbs are descriptive and nouns clearly indicate the resource or action.
13 tools cover core LinkedIn operations without being excessive. Each tool serves a clear purpose, and the count feels well-scoped for a practical MCP server.
The set covers job search, profile retrieval, company info, posting, and session management, but lacks personalized features like viewing the user's own profile, managing connections, or retrieving applied jobs. These gaps limit full automation of LinkedIn workflows.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Managed LinkedIn MCP server for AI agents: search, connect, message and enrich on accounts you own.
Hosted MCP server for LinkedIn: 31 tools for profiles, search, messaging, posts, enrichment.
Live LinkedIn data for AI agents: profiles, companies, jobs, posts, email finding. No account risk.
Give AI agents the LinkedIn tools to find, qualify, engage, and follow up with prospects.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Dev-Anandhan/LinkedIn-MCP-server-Dev-Anandhan_-'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
