How to enrich people lists with Linkup

Enrich contact lists with professional profiles, career history, social presence, and verified data for sales, recruiting, and research workflows.

In This Guide

Professional Profile Enrichment

Full LinkedIn profile extraction and career history

Sales Prospecting Enrichment

Role details, responsibilities, and buying signals

Recruiting Candidate Enrichment

Skills, experience depth, and career trajectory

Investor & Board Research

Investment focus, portfolio, and thesis

Event Attendee Enrichment

Quick verification and context for follow-up

Expert & Speaker Identification

Find subject matter experts on specific topics

Overview

People enrichment powers everything from sales prospecting to recruiting pipelines to investor research. Whether you have a list of names from an event, a CRM export, or a target account list, Linkup can systematically gather professional backgrounds, current roles, social presence, and public activity for each person.

Why Linkup for people enrichment?

deep search

Can find LinkedIn profiles, then extract structured professional data

structured output

Returns consistent data across hundreds or thousands of records

agentic retrieval

Cross-references multiple sources (LinkedIn, company sites, news, publications)

disambiguation

Handles variations in names and disambiguates common names using company context

Configuration

Recommended settings for people enrichment

Parameter	Value	Why
`depth`	`deep`	People research requires finding profiles, then scraping details
`outputType`	`structured`	Consistent format for CRM/ATS import

Use Cases

Practical examples with prompts and schemas

Professional Profile Enrichment

Enrich a list of names with professional background, current role, and career history.

Prompt- Professional Profile

You are a professional research assistant enriching a contact database.

Person: {person_name}
Company (if known): {company}
Title (if known): {title}
Location (if known): {location}

Execute the following research:

1. Search for {person_name}'s LinkedIn profile. Use the company and title to disambiguate if multiple results.

2. From the LinkedIn profile, extract:
   - Current job title and company
   - Professional headline
   - Location
   - Time in current role
   - Previous positions (last 3)
   - Education
   - Skills and endorsements (top 5)

3. Search for {person_name} on the company website ({company_domain}) to find:
   - Official bio
   - Team page listing
   - Any publications or thought leadership

4. Search for any public speaking engagements, podcast appearances, or conference talks by {person_name}.

Return structured professional data. Flag if confidence is low due to name ambiguity.

Sales Prospecting Enrichment

Enrich leads with data relevant to sales outreach—role details, responsibilities, and buying signals.

Prompt- Sales Prospecting

You are a sales intelligence researcher preparing prospect profiles.

Prospect: {person_name}
Company: {company}
Our product category: {product_category}

Research this prospect for sales outreach:

1. Find their LinkedIn profile and extract:
   - Exact current title and reporting structure (if visible)
   - Time in role (new roles = potential buying window)
   - Career trajectory (promoted internally vs. external hire)
   - Relevant skills and areas of responsibility

2. Search for {person_name} at {company} to understand:
   - Their team or department
   - Any public statements about challenges or initiatives in {product_category}
   - Recent projects or announcements they're associated with

3. Search for {person_name} in recent news, podcasts, or conference talks to find:
   - Topics they care about
   - Pain points they've mentioned
   - Initiatives they're driving
Skip if you don't find any

4. Search for any content they've authored (blog posts, LinkedIn articles, publications). Skip if you don't find any.

Return insights useful for personalized outreach.

Recruiting Candidate Enrichment

Enrich candidate profiles with skills, experience depth, and career trajectory.

Prompt- Candidate Enrichment

You are a recruiting research assistant evaluating candidates.

Candidate: {candidate_name}
Target role: {target_role}
Required skills: {required_skills}
Company they're at: {current_company}

Research this candidate:

1. Find their LinkedIn profile and extract:
   - Complete work history with durations
   - Education and certifications
   - Skills (especially matching {required_skills})
   - Recommendations or endorsements

2. Search for their contributions in the professional community:
   - GitHub profile and repositories (if technical role)
   - Published articles or blog posts
   - Conference talks or presentations
   - Open source contributions

3. Search for any news mentions or awards.

4. Assess career trajectory:
   - Company tier (startups vs. enterprises)

Return a candidate profile with fit assessment for {target_role}.

Investor & Board Research

Research investors, board members, or advisors for due diligence or outreach.

Prompt- Investor Research

You are an investor research assistant.

Person: {person_name}
Known affiliation: {affiliation}
Context: {research_context}

Research this investor/board member:

1. Find their LinkedIn profile for:
   - Current and past board positions
   - Investment firm affiliations
   - Operational roles (if any)
   - Education and background

2. Search for their investment portfolio:
   - Companies they've invested in or serve on boards
   - Sectors they focus on
   - Stage preferences (seed, Series A, growth, etc.)

3. Search for interviews, podcasts, or articles where they discuss:
   - Investment thesis
   - What they look for in companies
   - Sectors they're excited about

4. Search for news about their recent activities:
   - Recent investments announced
   - Board appointments
   - Fund announcements

5. Search for any public contact information or preferred outreach channels.

Return a comprehensive investor profile.

Event Attendee Enrichment

Quickly enrich a list of people from an event, webinar, or conference.

Prompt- Event Attendee

You are a research assistant enriching event attendee data.

Attendee: {attendee_name}
Company (from registration): {company}
Title (from registration): {title}
Event: {event_name}

Quickly enrich this attendee record:

1. Verify and expand the registration data:
   - Confirm current company and title via LinkedIn
   - Get full company name (registration often has abbreviations)
   - Get their LinkedIn URL

2. Add context useful for follow-up:
   - Seniority level
   - Department/function
   - Company size and industry
   - Location

3. If available, find:
   - Professional photo URL
   - Brief professional summary

Keep research focused—prioritize speed for batch processing.
Return essential fields only.

Expert & Speaker Identification

Find and research experts or potential speakers on specific topics.

Prompt- Expert Identification

You are a research assistant identifying subject matter experts.

Topic: {topic}
Industry context: {industry}
Geographic preference: {geography}
Purpose: {purpose}

Find experts on {topic}:

1. Search for people who have:
   - Published articles or research on {topic}
   - Given conference talks on {topic}
   - Been quoted in media about {topic}
   - Written books on {topic}
   - Active thought leadership (LinkedIn posts, blogs)

2. For each expert found, research:
   - Current role and organization
   - Credentials and background relevant to {topic}
   - Examples of their work/content on this topic
   - Speaking history (conferences, podcasts)
   - Contact availability (speaker bureau, direct, etc.)

3. Assess their fit:
   - Depth of expertise
   - Public speaking experience
   - Availability indicators
   - Audience relevance

Return a ranked list of potential experts with rationale.

Best Practices

✓ Do's

✓
Always provide disambiguation context — Include company name, title, or location to find the right person
✓
Use Standard for getting profile, Deep for context — Extracting further context requires multiple steps
✓
Include confidence scoring — Not all matches are certain; surface this to downstream systems
✓
Handle "not found" gracefully — Some people have minimal online presence; don't fail the whole batch
✓
Cross-reference multiple sources — LinkedIn + company website + news gives a more complete picture
✓
Request structured output — People enrichment at scale needs consistent schemas for import

✗ Don'ts

✗
Don't search for common names without context — "John Smith" alone is useless; always include company or other identifiers
✗
Don't assume LinkedIn has everything — Senior executives often have sparse LinkedIn profiles; check company sites
✗
Don't over-enrich for the use case — Event follow-up needs less data than sales prospecting; match depth to purpose

Handling Name Disambiguation

Name ambiguity is the biggest challenge in people enrichment. Here's how to handle it:

Disambiguation Strategies

Strong disambiguation (high confidence):
- Full name + current company + title
- Full name + company name + company domain
- Full name + LinkedIn URL (For Maximum Confidence)

Moderate disambiguation (verify results):
- Full name + company name only
- Full name + location + industry

Weak disambiguation (likely multiple matches):
- Full name only
- Common name + large company

Prompt- Disambiguation Pattern

When searching for {person_name} at {company}:

1. Search for "{person_name}" AND "{company}" on LinkedIn
2. Verify the profile matches:
   - Company name matches (accounting for subsidiaries)
   - Title is plausible for the context
   - Location is consistent (if known)
3. If multiple matches, return all with confidence scores
4. If no confident match, flag for manual review

Do not guess—return "not_found" if uncertain.

Integration Patterns

Batch Enrichment Pipeline

Input: CSV/list of people with available context
Pre-process: Normalize names, extract company domains, flag minimal context records
Enrich: Call Linkup for each person with consistent schema
Post-process: Score match confidence, deduplicate, flag low-confidence matches
Output: Enriched records ready for CRM/ATS import

Real-Time Enrichment

Trigger: New lead, candidate, or contact created
Enrich: Call Linkup with available context
Hydrate: Populate record with returned data
Score: Set confidence level on record
Route: High confidence → auto-update; Low confidence → review queue

Progressive Enrichment

Start lightweight: LinkedIn URL, verified title and company, location

Next step: Full professional history, content and interests, buying signals

Additional: Recent news and activity, shared connections, personalization hooks

Pro Tip

For high-volume enrichment, implement a queue system with rate limiting to stay within API limits while maximizing throughput.

Sample Integration Code

people_enrichment.py

import requests
import json
from typing import Optional, List
from dataclasses import dataclass
from enum import Enum

class MatchConfidence(Enum):
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    NOT_FOUND = "not_found"

@dataclass
class PersonInput:
    name: str
    company: Optional[str] = None
    title: Optional[str] = None
    location: Optional[str] = None
    linkedin_url: Optional[str] = None

class LinkupPeopleEnrichment:
    """Linkup integration for people list enrichment"""

    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = "https://api.linkup.so/v1/search"

    def _call_linkup(
        self,
        prompt: str,
        schema: dict,
        depth: str = "deep"
    ) -> dict:
        response = requests.post(
            self.base_url,
            headers={"Authorization": f"Bearer {self.api_key}"},
            json={
                "q": prompt,
                "depth": depth,
                "outputType": "Structured",
                "StructuredSchema": json.dumps(schema)
            }
        )
        return response.json()

    def enrich_professional_profile(self, person: PersonInput) -> dict:
        """Full professional enrichment"""

        context_parts = []
        if person.company:
            context_parts.append(f"Company: {person.company}")
        if person.title:
            context_parts.append(f"Title: {person.title}")
        if person.location:
            context_parts.append(f"Location: {person.location}")
        context_str = "\n".join(context_parts) if context_parts else "No additional context"

        prompt = f"""
        Research this person for professional profile enrichment:

        Name: {person.name}
        {context_str}

        1. Find their LinkedIn profile (use company/title to disambiguate).
        2. Extract: current position, previous roles (last 3), education, skills.
        3. Search for their bio on their company website.
        4. Find any public speaking, articles, or thought leadership.

        Return structured profile. Flag confidence level based on name match certainty.
        """

        schema = {
            "type": "object",
            "properties": {
                "match_confidence": {"type": "string"},
                "linkedin_url": {"type": "string"},
                "full_name": {"type": "string"},
                "headline": {"type": "string"},
                "current_position": {
                    "type": "object",
                    "properties": {
                        "title": {"type": "string"},
                        "company": {"type": "string"},
                        "duration": {"type": "string"}
                    }
                },
                "location": {"type": "string"},
                "previous_positions": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "title": {"type": "string"},
                            "company": {"type": "string"},
                            "duration": {"type": "string"}
                        }
                    }
                },
                "education": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "school": {"type": "string"},
                            "degree": {"type": "string"}
                        }
                    }
                },
                "skills": {"type": "array", "items": {"type": "string"}},
                "public_activity": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "type": {"type": "string"},
                            "title": {"type": "string"},
                            "url": {"type": "string"}
                        }
                    }
                }
            }
        }

        return self._call_linkup(prompt, schema)

    def enrich_for_sales(
        self,
        person: PersonInput,
        product_category: str
    ) -> dict:
        """Sales-focused enrichment with buying signals"""

        prompt = f"""
        Research this prospect for sales outreach:

        Name: {person.name}
        Company: {person.company}
        Title: {person.title}
        Our product category: {product_category}

        1. Find LinkedIn profile - extract title, seniority, time in role.
        2. Search for them at {person.company} for team/department context.
        3. Find any public statements about challenges in {product_category}.
        4. Find content they've authored.

        Return insights for personalized outreach.
        """

        schema = {
            "type": "object",
            "properties": {
                "linkedin_url": {"type": "string"},
                "title": {"type": "string"},
                "seniority": {"type": "string"},
                "department": {"type": "string"},
                "time_in_role": {"type": "string"},
                "new_to_role": {"type": "boolean"},
                "buying_signals": {
                    "type": "array",
                    "items": {
                        "type": "object",
                        "properties": {
                            "signal": {"type": "string"},
                            "source": {"type": "string"}
                        }
                    }
                },
                "topics_of_interest": {"type": "array", "items": {"type": "string"}},
                "outreach_hooks": {"type": "array", "items": {"type": "string"}}
            }
        }

        return self._call_linkup(prompt, schema)

    def enrich_event_attendee(self, person: PersonInput) -> dict:
        """Lightweight enrichment for event follow-up"""

        prompt = f"""
        Quickly verify and enrich this event attendee:

        Name: {person.name}
        Company (from registration): {person.company}
        Title (from registration): {person.title}

        1. Confirm current company and title via LinkedIn.
        2. Get LinkedIn URL.
        3. Add: seniority level, department, company industry.

        Keep focused—essential fields only.
        """

        schema = {
            "type": "object",
            "properties": {
                "match_confidence": {"type": "string"},
                "linkedin_url": {"type": "string"},
                "verified_name": {"type": "string"},
                "verified_title": {"type": "string"},
                "verified_company": {"type": "string"},
                "seniority": {"type": "string"},
                "department": {"type": "string"},
                "location": {"type": "string"},
                "company_industry": {"type": "string"}
            }
        }

        return self._call_linkup(prompt, schema, depth="standard")

    def batch_enrich(
        self,
        people: List[PersonInput],
        enrichment_type: str = "professional"
    ) -> List[dict]:
        """Batch enrich a list of people"""

        results = []
        for person in people:
            try:
                if enrichment_type == "professional":
                    result = self.enrich_professional_profile(person)
                elif enrichment_type == "event":
                    result = self.enrich_event_attendee(person)
                else:
                    result = self.enrich_professional_profile(person)

                results.append({
                    "input": person.__dict__,
                    "result": result,
                    "status": "success"
                })
            except Exception as e:
                results.append({
                    "input": person.__dict__,
                    "error": str(e),
                    "status": "error"
                })

        return results

# Example usage
if __name__ == "__main__":
    enricher = LinkupPeopleEnrichment(api_key="your-api-key")

    # Single enrichment
    person = PersonInput(
        name="Jane Smith",
        company="Acme Corp",
        title="VP Engineering"
    )
    profile = enricher.enrich_professional_profile(person)

    # Sales enrichment
    sales_profile = enricher.enrich_for_sales(
        person=person,
        product_category="developer tools"
    )

    # Batch enrichment
    attendees = [
        PersonInput(name="John Doe", company="TechCo", title="CTO"),
        PersonInput(name="Jane Smith", company="StartupX", title="CEO"),
    ]
    batch_results = enricher.batch_enrich(attendees, enrichment_type="event")

python