LinkedIn Data Gateway Service

This LinkedIn MCP endpoint enables advanced assistants like Claude to interface securely with your LinkedIn access credentials. It grants capabilities to query professional profiles, retrieve organizational summaries, obtain curated job recommendations, or execute keyword-based searches—all operable via a containerized environment on your local machine.

Deployment Strategies

https://github.com/user-attachments/assets/eb84419a-6eaf-47bd-ac52-37bc59c83680

Operational Scenarios

Enumerate the career opportunities recommended specifically for my profile.

Perform an in-depth background examination of this professional record: https://www.linkedin.com/in/stickerdaniel/

Acquire the complete dossier on this organization for potential collaboration review: https://www.linkedin.com/company/inframs/

Provide targeted recommendations for optimizing my curriculum vitae against the requirements of this job description: https://www.linkedin.com/jobs/view/4252026496

Functionality & Operational Readiness

[!TIP] - Profile Data Retrieval (get_person_profile): Extract granular details from a LinkedIn profile, encompassing employment chronology, educational background, skill sets, and network size. - Enterprise Data Extraction (get_company_profile): Secure comprehensive organizational intelligence directly from a specified LinkedIn company entity name. - Job Specification Access (get_job_details): Fetch precise data pertaining to a specific job posting via its LinkedIn identifier. - Opportunity Indexing (search_jobs): Execute targeted searches for employment roles utilizing customizable parameters such as topical keywords and geographic location. - Personalized Job Suggestions (get_recommended_jobs): Access system-generated job matches tailored to the user's professional attributes. - Session Cleanup (close_session): Gracefully terminate the underlying browser session and deallocate utilized system resources.

[!NOTE] Status as of July 2025: All integrated functionalities are verified operational and under active maintenance. Should any anomaly be detected, kindly submit a report via the GitHub issues portal.

🐳 Docker Deployment (Recommended - Universal)

Prerequisite: Ensure the Docker runtime environment is installed and operational.

Setup Procedure

Client Configuration Snippet:

{ "mcpServers": { "linkedin": { "command": "docker", "args": [ "run", "--rm", "-i", "-e", "LINKEDIN_COOKIE", "stickerdaniel/linkedin-mcp-server:latest" ], "env": { "LINKEDIN_COOKIE": "li_at=YOUR_COOKIE_VALUE" } } } }

Obtaining the LinkedIn Authentication Token

🌐 Chrome DevTools Procedure

1. Navigate to LinkedIn and successfully log in. 2. Invoke Chrome Developer Tools (F12 or Inspect Element). 3. Navigate to the **Application** tab > **Storage** section > **Cookies** > Filter for **https://www.linkedin.com**. 4. Locate the cookie entry labeled `li_at`. 5. Carefully replicate the value from the **Value** field (this constitutes your active LinkedIn session token). 6. Integrate this copied value as the `LINKEDIN_COOKIE` within your configuration settings.

🐳 Docker Token Acquisition Method

**Execute the server binary with the `--get-cookie` directive:** bash docker run -it --rm \ stickerdaniel/linkedin-mcp-server:latest \ --get-cookie Extract the resulting token from the output stream and assign it to the `LINKEDIN_COOKIE` environment variable in your client configuration. If the process terminates due to a CAPTCHA challenge, revert to the manual DevTools method described above.

[!NOTE] Session tokens typically remain valid for approximately 30 days. When expiration occurs, simply procure a fresh li_at token and substitute the outdated value in your client configuration. Numerous browser extensions are available to streamline the process of copying this necessary credential.

Docker Configuration Reference

🔧 Configuration Details

**Communication Protocols:** - **Default (stdio)**: Standard stream-based inter-process communication for local deployments. - **Streamable HTTP**: Protocol tailored for clients accessing the service via a network interface. **Command Line Arguments:** - `--log-level {DEBUG,INFO,WARNING,ERROR}` - Controls verbosity of system output (default: WARNING). - `--no-lazy-init` - Forces immediate LinkedIn authentication upon startup, bypassing call-wait initialization. - `--transport {stdio,streamable-http}` - Specifies the data exchange mechanism. - `--host HOST` - IP address binding for HTTP listener (default: 127.0.0.1). - `--port PORT` - Network port for HTTP endpoint (default: 8000). - `--path PATH` - URI path segment for the HTTP interface (default: /mcp). - `--get-cookie` - Initiates an attempt to authenticate using credentials to extract the session cookie. - `--cookie {cookie}` - Allows direct provision of an existing LinkedIn session token. - `--user-agent {user_agent}` - Permits specification of a custom User-Agent string to mitigate bot detection measures. **HTTP Mode Example (For web-interface clients):** bash docker run -it --rm \ -e LINKEDIN_COOKIE="li_at=YOUR_COOKIE_VALUE" \ -p 8080:8080 \ stickerdaniel/linkedin-mcp-server:latest \ --transport streamable-http --host 0.0.0.0 --port 8080 --path /mcp **Validation via MCP Inspector:** 1. Acquire and launch the MCP Inspector utility via `bunx @modelcontextprotocol/inspector`. 2. Within the Inspector UI, select **Streamable HTTP** as the Communication Type. 3. Configure the endpoint URL to `http://localhost:8080/mcp`. 4. Establish the connection. 5. Proceed to execute functional tool validations.

❗ Troubleshooting Guidance

**Docker Environment Issues:** - Verify successful installation of [Docker](https://www.docker.com/get-started/). - Confirm Docker daemon activity: Execute `docker ps`. **Authentication Failures:** - Validate that the provided LinkedIn token is current and accurately transcribed. - Adhere to the principle of single active session per token; concurrent use (e.g., browser open alongside a running container) often triggers invalidation. - For `--get-cookie` attempts, watch for prompts requiring confirmation via the LinkedIn mobile application. - High frequency of login attempts can trigger CAPTCHAs. If this occurs, await a cooldown period or utilize the local setup instructions below to run in non-headless mode for manual intervention.

📦 Claude Desktop (DXT Extension)

Prerequisites: Installation of Claude Desktop and Docker.

One-Step Installation for Claude Desktop Users: 1. Retrieve the latest DXT extension package. 2. Initiate the installation by double-clicking the downloaded file within the Claude Desktop environment. 3. Input and save your active LinkedIn session token within the extension's configuration interface.

Obtaining the LinkedIn Authentication Token

🌐 Chrome DevTools Procedure

1. Access LinkedIn and authenticate. 2. Launch Chrome Developer Tools (F12 or Inspect). 3. Navigate to **Application** > **Storage** > **Cookies** > **https://www.linkedin.com**. 4. Locate the cookie key named `li_at`. 5. Copy the corresponding **Value** (this is the required session token). 6. Utilize this data point as the `LINKEDIN_COOKIE` setting within your configuration framework.

🐳 Docker Token Acquisition Method

**Execute the server binary with the `--get-cookie` directive:** bash docker run -it --rm \ stickerdaniel/linkedin-mcp-server:latest \ --get-cookie Capture the token from the terminal output and configure it as `LINKEDIN_COOKIE` in your client settings. Fallback to manual inspection if CAPTCHA protection intervenes.

[!NOTE] The security validity of this token generally spans 30 days. A renewal of the li_at value is necessary upon its expiration. Browser cookie management extensions can significantly expedite this retrieval step.

DXT Extension Support

❗ Troubleshooting Guidance

**Docker Environment Issues:** - Ensure prerequisite [Docker](https://www.docker.com/get-started/) installation is complete. - Check operational status via `docker ps`. **Authentication Failures:** - Confirm token integrity and correct entry in the DXT settings. - Avoid concurrent usage of the same token across multiple active sessions. - `--get-cookie` may require manual authentication confirmation via the mobile application. - Excessive login attempts may trigger rate limiting/CAPTCHAs; allow time or switch to local debugging mode for manual resolution.

🚀 uvx Deployment (Quick Installation - Universal)

Prerequisites: Ensure you have the uv package manager installed on your system.

Installation Command Set

Execute directly against the GitHub source repository:

bash

Direct execution of the latest version from GitHub

uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server --help

Execution incorporating your LinkedIn token

uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server --cookie "li_at=YOUR_COOKIE_VALUE"

Obtaining the LinkedIn Authentication Token

🌐 Chrome DevTools Procedure

1. Access LinkedIn and complete the login sequence. 2. Open Chrome's Inspection Tools (F12 or right-click Inspect). 3. Navigate to **Application** > **Storage** > **Cookies** > Locate **https://www.linkedin.com**. 4. Isolate the cookie designated as `li_at`. 5. Copy the complete string from the **Value** attribute (this is the required authorization key). 6. Incorporate this value as the `LINKEDIN_COOKIE` within your configuration object.

🚀 uvx Token Retrieval Utility

**Invoke the server utility with the `--get-cookie` flag:** bash uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server \ linkedin-mcp-server --get-cookie Copy the token outputted to the console and use it to populate the `LINKEDIN_COOKIE` setting in your deployment configuration. If a CAPTCHA challenge prevents automated retrieval, employ the standard DevTools method.

[!NOTE] The session token's operational lifetime is generally capped at 30 days. Refreshing this value in your setup is required upon expiration. Utilizing dedicated cookie manager browser extensions can expedite this credential extraction.

uvx Configuration Reference

🔧 Configuration Details

**Client Configuration JSON Structure:** { "mcpServers": { "linkedin": { "command": "uvx", "args": [ "--from", "git+https://github.com/stickerdaniel/linkedin-mcp-server", "linkedin-mcp-server" ], "env": { "LINKEDIN_COOKIE": "li_at=YOUR_COOKIE_VALUE" } } } } **Communication Protocols:** - **Default (stdio)**: Standard stream-based IPC for local execution. - **Streamable HTTP**: Protocol setup for web-based clients. **CLI Arguments:** - `--log-level {DEBUG,INFO,WARNING,ERROR}` - Logging verbosity control (default: WARNING). - `--no-lazy-init` - Forces immediate authentication upon service initialization. - `--transport {stdio,streamable-http}` - Defines connection method. - `--host HOST` - HTTP server binding address (default: 127.0.0.1). - `--port PORT` - HTTP server listener port (default: 8000). - `--path PATH` - HTTP endpoint URI segment (default: /mcp). - `--get-cookie` - Triggers login flow to extract and output the session token. - `--cookie {cookie}` - Accepts an explicit LinkedIn token via argument. - `--user-agent {user_agent}` - Allows overriding the default User-Agent string for stealth. **Basic Execution Examples:** bash # Execution relying on an environment variable for the token LINKEDIN_COOKIE="YOUR_COOKIE_VALUE" uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server # Execution supplying the token via a command-line flag uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server --cookie "YOUR_COOKIE_VALUE" # Running with verbose logging enabled uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server --log-level DEBUG # Token extraction utility call uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server --get-cookie **HTTP Interface Setup (For remote clients):** bash uvx --from git+https://github.com/stickerdaniel/linkedin-mcp-server linkedin-mcp-server \ --transport streamable-http --host 127.0.0.1 --port 8080 --path /mcp **Testing with the MCP Inspector Tool:** 1. Install and initialize the inspector: bunx @modelcontextprotocol/inspector. 2. In the inspector interface, select **Streamable HTTP** for the Transport Type. 3. Configure the connection endpoint as `http://localhost:8080/mcp`. 4. Activate the connection. 5. Perform functional tests on the exposed endpoints.

❗ Troubleshooting Guidance

**Installation Failures:** - Confirm `uv` installation integrity: `curl -LsSf https://astral.sh/uv/install.sh | sh`. - Verify the `uv` version: `uv --version` (must be 0.4.0 or newer). **Credential Issues:** - Ensure the LinkedIn token is valid and supplied via either the `--cookie` argument or the `LINKEDIN_COOKIE` environmental variable. - Strictly limit concurrent use of a single authentication token. **Authentication Process Failures:** - The `--get-cookie` mechanism might necessitate manual authorization via the LinkedIn mobile application. - High transaction volume can temporarily trigger security challenges; retry after a brief interval.

🐍 Local Deployment (Development & Contribution)

Prerequisites: Installation of the Chrome web browser and Git.

ChromeDriver Configuration Mandates: 1. Determine Chrome Version: Access Chrome Menu (⋮) → Help → About Google Chrome. 2. Acquire Matching ChromeDriver: Download the appropriate binary from Chrome for Testing. 3. Ensure Path Accessibility: - Place the ChromeDriver executable within a system PATH directory (e.g., /usr/local/bin on Unix-like systems). - Alternatively, explicitly define its location via the environment variable: export CHROMEDRIVER_PATH=/path/to/chromedriver. - If CHROMEDRIVER_PATH is unset, the server attempts automatic detection in standard installation directories.

Initial Setup Steps

bash

1. Clone the repository source code

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

2. Install the UV package manager utility

curl -LsSf https://astral.sh/uv/install.sh | sh uv python # Ensures Python interpreter is available

3. Install required runtime and development dependencies

uv sync uv sync --group dev

4. Register pre-commit validation hooks

uv run pre-commit install

5. Initiate the service manually for first-time configuration

This prompts for LinkedIn credentials; these are then stored securely in the OS credential manager for all future runs until token expiry.

uv run -m linkedin_mcp_server --no-headless --no-lazy-init

Local Setup Reference

🔧 Configuration Options

**Available CLI Flags:** - `--no-headless` - Renders the browser window visible for debugging purposes. - `--log-level {DEBUG,INFO,WARNING,ERROR}` - Sets logging verbosity (default: WARNING). - `--no-lazy-init` - Commands immediate LinkedIn session establishment at launch. - `--get-cookie` - Triggers authentication to obtain and save the session cookie. - `--clear-keychain` - Wipes any previously stored LinkedIn credentials from the system's secure storage. - `--cookie {cookie}` - Provides a specific authentication token directly. - `--user-agent {user_agent}` - Allows overriding the default browser identity string. - `--transport {stdio,streamable-http}` - Selects the IPC method. - `--host HOST` - HTTP server interface binding (default: 127.0.0.1). - `--port PORT` - HTTP service port (default: 8000). - `--path PATH` - HTTP service URI path prefix (default: /mcp). - `--help` - Displays comprehensive usage instructions. **Claude Desktop Integration Configuration:** { "mcpServers": { "linkedin": { "command": "uv", "args": ["--directory", "/path/to/linkedin-mcp-server", "run", "-m", "linkedin_mcp_server"] } } }

❗ Troubleshooting Guidance

**Authentication/Scraping Difficulties:** - Use the `--no-headless` flag to visually monitor interactions (e.g., CAPTCHA appearance, 2FA prompts). - Employ `--no-lazy-init` to ensure LinkedIn connection attempts occur before any tool execution. - Increase logging detail with `--log-level DEBUG` for deeper diagnostic information. - Avoid concurrent usage of the same token/session; closing one connection (browser or container) is critical before starting another process with the same credentials. **ChromeDriver Compatibility Errors:** - Verify version parity between the installed Chrome browser and the downloaded ChromeDriver binary. - Confirm ChromeDriver's location is either in the system PATH or correctly specified via `CHROMEDRIVER_PATH`. **Python Environment Issues:** - Confirm Python interpreter version: `uv python --version` (requires 3.12+). - Rebuild dependencies: `uv sync --reinstall`.

Feel free to open an issue or PR!

Acknowledgements

This component relies on foundational work from LinkedIn Scraper by @joeyism and the FastMCP framework.

⚠️ Usage must strictly adhere to LinkedIn's User Agreement. Automated data harvesting may contravene LinkedIn's stipulations. This utility is designated strictly for private, personal operational use.

Star History

License

This software artifact is distributed under the terms of the Apache License, Version 2.0.

WIKIPEDIA: XMLHttpRequest (XHR) represents an interface implemented via a JavaScript object, offering methods to dispatch HTTP queries from a client-side web browser to a remote server. Its capabilities enable browser-based applications to submit requests post-page load and subsequently process the returned data. XHR is a core constituent of the Ajax programming paradigm. Before its advent, server interaction primarily relied on traditional navigation via hyperlinks and form submissions, which typically resulted in full page reloads.

== Historical Context == The conceptual foundation for XMLHttpRequest originated around 2000 within the development team for Microsoft Outlook. This concept was subsequently integrated into Internet Explorer version 5 (released in 1999). However, the initial invocation syntax did not utilize the standardized XMLHttpRequest identifier; instead, developers employed constructs like ActiveXObject("Msxml2.XMLHTTP") or ActiveXObject("Microsoft.XMLHTTP"). As of Internet Explorer 7 (2006), universal browser support for the XMLHttpRequest constructor name has been achieved. XMLHttpRequest is now the generally accepted standard across all major browser rendering engines, including Mozilla's Gecko (since 2002), Safari 1.2 (2004), and Opera 8.0 (2005).

=== Standardization Milestones === The World Wide Web Consortium (W3C) issued its initial Working Draft specification for the XMLHttpRequest object on April 5, 2006. On February 25, 2008, the W3C released the Level 2 specification draft. Level 2 introduced crucial enhancements such as progress monitoring methods, mechanisms for cross-origin request allowance, and support for handling raw byte streams. By late 2011, the Level 2 feature set was formally merged back into the primary specification document. Development oversight transitioned to the WHATWG near the end of 2012, which now maintains the definitive, continuously updated specification document utilizing Web IDL notation.

== Operational Steps == Sending a data request using XMLHttpRequest conventionally requires a sequence of distinct programming actions.

1. Instantiate an XMLHttpRequest object via its constructor call:
2. Invoke the open() method to define the transaction type (GET, POST, etc.), specify the target URI, and select between synchronous or asynchronous processing mode:
3. For asynchronous transactions, register a callback handler intended to receive notifications upon changes in the request's transactional state:
4. Commence the data transfer by calling the send() method:
5. The application logic processes state transitions within the registered event listener. If the server successfully transmits data, it is typically accessible via the responseText attribute by default. The process concludes when the object transitions to state 4, the terminal ("done") state. Beyond these fundamental steps, XMLHttpRequest affords substantial control over request transmission parameters and response interpretation. Custom HTTP headers can be appended to guide server fulfillment logic, and payload data can be supplied directly within the send() invocation. Responses can be automatically deserialized from JSON into native JavaScript objects or processed incrementally as data chunks arrive, avoiding a wait for the complete payload. Furthermore, requests can be terminated preemptively, or a timeout threshold can be established to enforce failure after a set duration.

== Cross-Domain Resource Access ==

Early in the evolution of the World Wide Web, restrictions were imposed that prevented scripts originating from one domain from arbitrarily initiating HTTP connections to resources on a different domain. This security measure, known as the Same-Origin Policy, was fundamental to mitigating certain types of web-based exploits. The original design of XMLHttpRequest strictly enforced this policy. However, as web applications grew in complexity, the need for controlled cross-domain communication became apparent. This led to the introduction of mechanisms like CORS (Cross-Origin Resource Sharing), which allows servers to explicitly signal their consent to accept requests from specified external origins, thereby enabling the functionality described in the Level 2 specification.