Employee Discovery

Get all employees from a company using LinkedIn and website data

Get Company Employees

Retrieve all employees from a company using LinkedIn company data and/or website information. This is particularly useful for finding decision-makers and building contact lists.

Method

services.company.getEmployees(params);

Parameters

given_company_id · number

Internal company ID

linkedinCompanyUrl · string

LinkedIn company page URL

website · string

Company website (useful for smaller businesses that may not have employees on LinkedIn)

options · object

Filtering options for employees

Show Options Properties

onlyHigherLevel · boolean

Whether to only return higher-level executives

department · string

Filter by specific department. Options: - "C-Suite" - "Finance & Accounting" - "Human Resources" - "Legal" - "Administrative" - "Engineering and Technical" - "Sales" - "Customer Service" - "Product"

• "Project Management" - "Marketing" - "Design" - "Operations" - "Research" - "Trades" - "Consulting" - "Medical" - "Real Estate" - "Education" - "Other"

Provide at least one of: given_company_id, linkedinCompanyUrl, or website

Returns

Returns a Promise with an array of employee profile objects. Each employee object has the same structure as the LinkedIn person enrich response.

Response Fields

Each employee object includes:

full_name · string

Employee’s full name

job_title · string

Current job title

headline · string

LinkedIn headline

websites_linkedin · string

LinkedIn profile URL

department · string

Department classification

management_level · string

Management level (e.g., “Senior”, “Manager”, “Director”)

is_decision_maker · 0 | 1

Whether the person is classified as a decision maker

experience · array

Full work experience history

education · array

Education history

skills · string[]

Listed skills

Plus all other fields from the person LinkedIn enrich response.

Examples

Get All Employees

const employees = await services.company.getEmployees({
   linkedinCompanyUrl: "https://linkedin.com/company/acme",
   website: "acme.com",
});

console.log(`Found ${employees.length} employees`);

employees.forEach((emp) => {
   console.log(`${emp.full_name} - ${emp.job_title}`);
});

Get C-Suite Executives Only

const executives = await services.company.getEmployees({
   linkedinCompanyUrl: "https://linkedin.com/company/acme",
   options: {
      onlyHigherLevel: true,
      department: "C-Suite",
   },
});

executives.forEach((exec) => {
   console.log(`${exec.full_name} - ${exec.job_title}`);
   console.log(`LinkedIn: ${exec.websites_linkedin}`);
});

Get Sales Team

const salesTeam = await services.company.getEmployees({
   website: "acme.com",
   options: {
      department: "Sales",
   },
});

console.log(`Sales team size: ${salesTeam.length}`);

Get Decision Makers

const employees = await services.company.getEmployees({
   linkedinCompanyUrl: "https://linkedin.com/company/acme",
});

const decisionMakers = employees.filter((emp) => emp.is_decision_maker === 1);

console.log(`Found ${decisionMakers.length} decision makers`);

decisionMakers.forEach((dm) => {
   console.log(`${dm.full_name} - ${dm.job_title} (${dm.management_level})`);
});

Get Engineering Leaders

const engineers = await services.company.getEmployees({
   linkedinCompanyUrl: "https://linkedin.com/company/tech-startup",
   options: {
      department: "Engineering and Technical",
      onlyHigherLevel: true,
   },
});

engineers.forEach((eng) => {
   console.log(`${eng.full_name} - ${eng.job_title}`);
   console.log(`Skills: ${eng.skills?.join(", ")}`);
});

Use Cases

Build Contact List for Outreach

async function buildSalesContactList(companyUrl: string) {
   // Get sales and marketing employees
   const employees = await services.company.getEmployees({
      linkedinCompanyUrl: companyUrl,
      options: {
         department: "Sales",
      },
   });

   // Get contact info for each
   const contacts = await Promise.all(
      employees.map(async (emp) => {
         const contactInfo = await services.person.contact.get({
            linkedinUrl: emp.websites_linkedin,
            required: ["email", "phone"],
         });

         return {
            name: emp.full_name,
            title: emp.job_title,
            email: contactInfo.work_emails[0] || contactInfo.personal_emails[0],
            phone: contactInfo.work_phones[0],
            linkedin: emp.websites_linkedin,
         };
      })
   );

   return contacts.filter((c) => c.email); // Only return those with email
}

Analyze Company Structure

async function analyzeCompanyStructure(companyUrl: string) {
   const employees = await services.company.getEmployees({
      linkedinCompanyUrl: companyUrl,
   });

   // Count by department
   const deptCounts = employees.reduce((acc, emp) => {
      const dept = emp.department || "Unknown";
      acc[dept] = (acc[dept] || 0) + 1;
      return acc;
   }, {} as Record<string, number>);

   // Count by management level
   const levelCounts = employees.reduce((acc, emp) => {
      const level = emp.management_level || "Individual Contributor";
      acc[level] = (acc[level] || 0) + 1;
      return acc;
   }, {} as Record<string, number>);

   return {
      totalEmployees: employees.length,
      byDepartment: deptCounts,
      byLevel: levelCounts,
      decisionMakers: employees.filter((e) => e.is_decision_maker === 1).length,
   };
}

Find Hiring Managers

async function findHiringManagers(companyUrl: string, department: string) {
   const employees = await services.company.getEmployees({
      linkedinCompanyUrl: companyUrl,
      options: {
         department: department as any,
         onlyHigherLevel: true,
      },
   });

   // Filter for managers and directors
   const hiringManagers = employees.filter((emp) => {
      const level = emp.management_level?.toLowerCase() || "";
      return level.includes("manager") || level.includes("director") || level.includes("head");
   });

   return hiringManagers.map((hm) => ({
      name: hm.full_name,
      title: hm.job_title,
      linkedin: hm.websites_linkedin,
      experience: hm.total_experience_duration,
   }));
}

Best Practices

Use Both Sources: Provide both linkedinCompanyUrl and website for maximum coverage. Website data helps find employees at smaller companies who may not be active on LinkedIn.

Large Companies: For very large companies (10,000+ employees), consider using filters to narrow results. Retrieving all employees can be slow and expensive.

Data Freshness: Employee data reflects current LinkedIn profiles. People may have changed roles or companies since the data was last updated.

Department Filtering

When filtering by department, use these exact values:

• C-Suite: CEO, CTO, CFO, COO, etc.
• Engineering and Technical: Software engineers, developers, IT
• Sales: Sales representatives, account executives
• Marketing: Marketing managers, content creators
• Product: Product managers, product designers
• Finance & Accounting: Accountants, financial analysts
• Human Resources: HR managers, recruiters
• Operations: Operations managers, logistics
• Customer Service: Support staff, customer success

Performance Considerations

// Good: Filter at query time
const executives = await services.company.getEmployees({
   linkedinCompanyUrl: companyUrl,
   options: {
      onlyHigherLevel: true,
   },
});

// Less efficient: Get all then filter
const allEmployees = await services.company.getEmployees({
   linkedinCompanyUrl: companyUrl,
});
const executives = allEmployees.filter((e) => e.is_decision_maker === 1);