Built-in tool

LinkedIn company employees

List the people who work at a company on LinkedIn, by job title if you like, up to the number you set.

26 creditsNo API key needed

Endpoint

Parameters

NameTypeRequiredNote
currentCompaniesstring · requiredstringrequired

LinkedIn company URL (e.g. https://www.linkedin.com/company/microsoft)

Example: https://www.linkedin.com/company/microsoft

currentJobTitlesarray · optionalarrayoptional

Optional. One job title per row — only employees whose CURRENT title matches one of them are returned. Leave empty to return employees of every title. Up to 70.

Example: VP of Sales

maxLeadsstring · optionalstringoptional

Maximum number of employees to return. Each batch of 25 uses one API page.

One of: 50 (50 leads), 100 (100 leads), 250 (250 leads), 500 (500 leads), 1000 (1,000 leads), 2500 (2,500 leads)

Default: 50

continuationstring · optionalstringoptional

Continuation returned by a previous call. Pass it unchanged with the same search filters to fetch the next batch. Each call has its own paid request budget.

Response schema

{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "elements"
  ],
  "properties": {
    "note": {
      "type": "string"
    },
    "hasMore": {
      "type": "boolean",
      "description": "True only when the provider still had reachable data and this execution stopped early. A managed Agent must treat this as an incomplete batch, never as completion."
    },
    "elements": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "linkedinUrl",
          "jobTitle",
          "employerVerified"
        ],
        "properties": {
          "premium": {
            "type": "boolean"
          },
          "jobTitle": {
            "type": "string",
            "description": "Job title this person holds at the company that was looked up, taken from the matching `currentPositions[].title`. Empty string when the provider returned no title."
          },
          "lastName": {
            "type": "string"
          },
          "location": {
            "type": "object",
            "properties": {
              "linkedinText": {
                "type": "string"
              }
            },
            "additionalProperties": true
          },
          "firstName": {
            "type": "string"
          },
          "pictureUrl": {
            "type": "string"
          },
          "linkedinUrl": {
            "type": "string"
          },
          "openProfile": {
            "type": "boolean"
          },
          "currentPositions": {
            "type": "array",
            "items": {
              "type": "object",
              "properties": {
                "title": {
                  "type": "string"
                },
                "companyName": {
                  "type": "string"
                }
              },
              "additionalProperties": true
            }
          },
          "employerVerified": {
            "type": "boolean",
            "description": "True when one of this person's current positions is at the requested company's LinkedIn page. False only when the company itself could not be resolved — then nobody was filtered, and the person should be confirmed before paid enrichment or outreach."
          }
        },
        "additionalProperties": true
      }
    },
    "nextPage": {
      "type": "integer",
      "exclusiveMinimum": 0
    },
    "returned": {
      "type": "number",
      "description": "How many records this run returned, after any `limit` was applied. ONE EXCEPTION: on a chat preview — where `truncated` is true — this is the count actually FETCHED while `elements` carries only a short sample of them, so the two deliberately disagree. Read `truncated` before comparing this against the array length; in a workflow it is never set and the two always match. Matches the other LinkedIn data tools, whose `meta.returned` is the fetched count on a truncated preview too."
    },
    "truncated": {
      "type": "boolean"
    },
    "stopReason": {
      "enum": [
        "cancelled",
        "provider-error",
        "empty-page-stall",
        "caller-limit",
        "presentation-preview",
        "cursor-stall",
        "runtime-page-window",
        "time-budget"
      ],
      "type": "string"
    },
    "suggestion": {
      "type": "string"
    },
    "totalCount": {
      "type": "number",
      "description": "How many records the search MATCHES, per the provider — the grand total, routinely in the millions while the endpoint will only serve about a thousand of them. Do NOT compare it with the row count to decide whether a run was complete, and do not paginate towards it: use `servableCount` for what is actually reachable. Absent when the provider sent no count."
    },
    "totalPages": {
      "type": "number"
    },
    "pagesScraped": {
      "type": "number"
    },
    "servableCount": {
      "type": "number",
      "description": "How many records this endpoint will serve across all its pages — the real ceiling on what any number of runs can reach, which the provider caps well below `totalCount` on most search endpoints. Absent when the provider sent no count."
    },
    "totalElements": {
      "type": "number",
      "description": "DEPRECATED — despite the name this is the count RETURNED by this run, not a grand total, so it equals your `limit` on a limited run. Kept at that value so existing flows do not change meaning. Use `returned` for this number, `totalCount` for how many records match, or `servableCount` for how many are reachable."
    },
    "nextPaginationToken": {
      "type": "string"
    },
    "employerVerification": {
      "type": "object",
      "required": [
        "status",
        "excludedCount"
      ],
      "properties": {
        "status": {
          "enum": [
            "verified",
            "unverified"
          ],
          "type": "string"
        },
        "company": {
          "type": "object",
          "required": [
            "ids",
            "universalNames",
            "names"
          ],
          "properties": {
            "ids": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "names": {
              "type": "array",
              "items": {
                "type": "string"
              }
            },
            "universalNames": {
              "type": "array",
              "items": {
                "type": "string"
              }
            }
          },
          "additionalProperties": false
        },
        "excluded": {
          "type": "array",
          "items": {
            "type": "object",
            "required": [
              "name",
              "reason"
            ],
            "properties": {
              "name": {
                "type": "string"
              },
              "title": {
                "type": "string"
              },
              "reason": {
                "enum": [
                  "no_company_page",
                  "different_company"
                ],
                "type": "string"
              },
              "linkedinUrl": {
                "type": "string"
              },
              "statedEmployer": {
                "type": "string"
              }
            },
            "additionalProperties": false
          }
        },
        "excludedCount": {
          "type": "number"
        }
      },
      "description": "ENG-19396: how the returned people were checked against the requested company. `verified` means every returned person currently works there and `excludedCount` people the search matched by name only (or at another company) were removed. `unverified` means the company could not be resolved and nothing was filtered.",
      "additionalProperties": false
    }
  },
  "additionalProperties": true
}

Get started

How to use this tool

  1. Connect your AI

    Add Connie to ChatGPT, Claude or Slack once, and this tool comes with it. There’s no API key or account to set up.

  2. Ask for the outcome

    Describe what you need in plain words. Your AI runs this tool when the job calls for it, along with any others it needs.

  3. Make it a workflow

    Add it as a step in a workflow that runs the same way every time, on a schedule or when something happens.

  4. Stay in control

    Choose whether it runs on its own or asks first. When it asks, you see an Allow or Deny card before any credits are spent.