get_person_profile

Retrieve structured LinkedIn profile data for a specific person by providing their username to access professional information.

Instructions

Get a specific person's LinkedIn profile.

Args: linkedin_username (str): LinkedIn username (e.g., "stickerdaniel", "anistji")

Returns: Dict[str, Any]: Structured data from the person's profile

Input Schema

TableJSON Schema

Name	Required	Description	Default
`linkedin_username`	Yes

Implementation Reference

linkedin_mcp_server/tools/person.py:37-115 (handler)

The handler function that executes the tool logic: constructs LinkedIn profile URL from username, scrapes data using linkedin_scraper.Person, transforms nested objects (experiences, educations, etc.) into structured dictionaries, and returns comprehensive profile information with error handling.

async def get_person_profile(linkedin_username: str) -> Dict[str, Any]:
    """
    Get a specific person's LinkedIn profile.

    Args:
        linkedin_username (str): LinkedIn username (e.g., "stickerdaniel", "anistji")

    Returns:
        Dict[str, Any]: Structured data from the person's profile
    """
    try:
        # Construct clean LinkedIn URL from username
        linkedin_url = f"https://www.linkedin.com/in/{linkedin_username}/"

        driver = safe_get_driver()

        logger.info(f"Scraping profile: {linkedin_url}")
        person = Person(linkedin_url, driver=driver, close_on_complete=False)

        # Convert experiences to structured dictionaries
        experiences: List[Dict[str, Any]] = [
            {
                "position_title": exp.position_title,
                "company": exp.institution_name,
                "from_date": exp.from_date,
                "to_date": exp.to_date,
                "duration": exp.duration,
                "location": exp.location,
                "description": exp.description,
            }
            for exp in person.experiences
        ]

        # Convert educations to structured dictionaries
        educations: List[Dict[str, Any]] = [
            {
                "institution": edu.institution_name,
                "degree": edu.degree,
                "from_date": edu.from_date,
                "to_date": edu.to_date,
                "description": edu.description,
            }
            for edu in person.educations
        ]

        # Convert interests to list of titles
        interests: List[str] = [interest.title for interest in person.interests]

        # Convert accomplishments to structured dictionaries
        accomplishments: List[Dict[str, str]] = [
            {"category": acc.category, "title": acc.title}
            for acc in person.accomplishments
        ]

        # Convert contacts to structured dictionaries
        contacts: List[Dict[str, str]] = [
            {
                "name": contact.name,
                "occupation": contact.occupation,
                "url": contact.url,
            }
            for contact in person.contacts
        ]

        # Return the complete profile data
        return {
            "name": person.name,
            "about": person.about,
            "experiences": experiences,
            "educations": educations,
            "interests": interests,
            "accomplishments": accomplishments,
            "contacts": contacts,
            "company": person.company,
            "job_title": person.job_title,
            "open_to_work": getattr(person, "open_to_work", False),
        }
    except Exception as e:
        return handle_tool_error(e, "get_person_profile")

linkedin_mcp_server/tools/person.py:29-36 (registration)
The @mcp.tool decorator within register_person_tools registers the get_person_profile handler with metadata annotations defining the tool's title and hints.
```
@mcp.tool(
    annotations=ToolAnnotations(
        title="Get Person Profile",
        readOnlyHint=True,
        destructiveHint=False,
        openWorldHint=True,
    )
)
```
linkedin_mcp_server/server.py:27-30 (registration)
Top-level registration call to register_person_tools(mcp) in the create_mcp_server function, which defines and registers the get_person_profile tool.
```
# Register all tools
register_person_tools(mcp)
register_company_tools(mcp)
register_job_tools(mcp)
```
linkedin_mcp_server/tools/person.py:37-37 (schema)
Function signature defining input schema (linkedin_username: str) and output type (Dict[str, Any]).
```
async def get_person_profile(linkedin_username: str) -> Dict[str, Any]:
```
linkedin_mcp_server/cli.py:69-70 (registration)
Lists 'get_person_profile' as a required tool in the generated Claude Desktop configuration.
```
"requiredTools": [
    "get_person_profile",
```

LinkedIn MCP Server