> ## Documentation Index
> Fetch the complete documentation index at: https://www.outx.ai/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# LinkedIn People Search API - Search LinkedIn Profiles

> Search LinkedIn profiles by keywords, job title, company, location, industry, and more using the OutX LinkedIn Search API. A reliable alternative to LinkedIn Sales Navigator.

<script type="application/ld+json">
  {`{
    "@context": "https://schema.org",
    "@type": "WebAPI",
    "name": "OutX LinkedIn Search Profiles API",
    "url": "https://api.outx.ai/linkedin-agent/search-profiles",
    "description": "Search LinkedIn profiles by keywords, title, company, location, industry, and more via API. A Sales Navigator alternative.",
    "documentation": "https://outx.ai/docs/linkedin-api/search-profiles",
    "provider": {
      "@type": "Organization",
      "name": "OutX.ai",
      "url": "https://www.outx.ai"
    }
    }`}
</script>

The Search Profiles endpoint creates an async task to search LinkedIn for people matching your criteria. Provide one or more search filters and receive a task ID to poll for the matching profiles.

## Endpoint

```
POST https://api.outx.ai/linkedin-agent/search-profiles
```

## Request Body

At least one filter field is required.

<ParamField body="keywords" type="string">
  General keyword search across name, headline, and profile text
</ParamField>

<ParamField body="title" type="string">
  Filter by job title (e.g., `"VP of Engineering"`)
</ParamField>

<ParamField body="company" type="string">
  Filter by current company name (e.g., `"Google"`)
</ParamField>

<ParamField body="first_name" type="string">
  Filter by first name
</ParamField>

<ParamField body="last_name" type="string">
  Filter by last name
</ParamField>

<ParamField body="geo_urn" type="string[]">
  Array of LinkedIn geographic URNs to filter by location (e.g., `["103644278"]` for United States)
</ParamField>

<ParamField body="current_company" type="string[]">
  Array of LinkedIn company URNs to filter by current employer
</ParamField>

<ParamField body="industry" type="string[]">
  Array of LinkedIn industry URNs to filter by industry
</ParamField>

<ParamField body="past_company" type="string[]">
  Array of LinkedIn company URNs to filter by past employer
</ParamField>

<ParamField body="school" type="string">
  Filter by school or university name (e.g., `"MIT"`)
</ParamField>

<ParamField body="profile_language" type="string[]">
  Array of language codes to filter by profile language (e.g., `["en"]`)
</ParamField>

<ParamField body="count" type="number">
  Number of profiles to return. Defaults to `25`, maximum `50`.
</ParamField>

<Tip>
  You can combine multiple filters for more precise results. For example, pass both `title` and `geo_urn` to find "Software Engineers in San Francisco". At least one filter must have a value, sending an empty body will return a `400` error.
</Tip>

## Response

The endpoint returns immediately with a task ID. The search is executed asynchronously.

<ResponseField name="success" type="boolean">
  Whether the task was created successfully
</ResponseField>

<ResponseField name="api_agent_task_id" type="string">
  UUID to poll for results via [Get Task Status](/linkedin-api/get-task-status)
</ResponseField>

<ResponseField name="message" type="string">
  Human-readable confirmation
</ResponseField>

<ResponseExample>
  ```json Response theme={null}
  {
    "success": true,
    "api_agent_task_id": "550e8400-e29b-41d4-a716-446655440000",
    "message": "Profile search task created successfully"
  }
  ```
</ResponseExample>

## Polling for Results

After creating the task, poll the [Get Task Status](/linkedin-api/get-task-status) endpoint until the status is `completed`:

```
GET https://api.outx.ai/linkedin-agent/get-task-status?api_agent_task_id=550e8400-e29b-41d4-a716-446655440000
```

### Completed Response

When the task finishes, `task_output` contains the matching profiles:

```json theme={null}
{
  "success": true,
  "data": {
    "id": "550e8400-e29b-41d4-a716-446655440000",
    "status": "completed",
    "task_input": {
      "task_type": "agent_search_profiles",
      "filters": {
        "title": "VP of Engineering",
        "company": "Google"
      },
      "count": 25
    },
    "task_output": {
      "profiles": [
        {
          "full_name": "Jane Smith",
          "headline": "VP of Engineering at Google",
          "location": "San Francisco, CA",
          "profile_slug": "jane-smith-abc123",
          "profile_urn": "ACoAABCDEFG",
          "connection_degree": 2,
          "image_url": "https://media.licdn.com/dms/image/..."
        },
        {
          "full_name": "John Doe",
          "headline": "VP Engineering | AI & Infrastructure at Google",
          "location": "Mountain View, CA",
          "profile_slug": "johndoe",
          "profile_urn": "ACoAAHIJKLMN",
          "connection_degree": 3,
          "image_url": null
        }
      ],
      "total_count": 2
    }
  }
}
```

## Code Examples

<RequestExample>
  ```bash cURL theme={null}
  # Search by title and company
  curl -X POST \
    "https://api.outx.ai/linkedin-agent/search-profiles" \
    -H "Content-Type: application/json" \
    -H "x-api-key: YOUR_API_KEY" \
    -d '{
      "title": "VP of Engineering",
      "company": "Google",
      "count": 25
    }'

  # Poll for results
  curl -X GET \
    "https://api.outx.ai/linkedin-agent/get-task-status?api_agent_task_id=TASK_ID" \
    -H "x-api-key: YOUR_API_KEY"
  ```

  ```javascript JavaScript theme={null}
  async function searchProfiles(filters) {
    // Create the search task
    const response = await fetch(
      "https://api.outx.ai/linkedin-agent/search-profiles",
      {
        method: "POST",
        headers: {
          "Content-Type": "application/json",
          "x-api-key": "YOUR_API_KEY",
        },
        body: JSON.stringify(filters),
      }
    );

    const { api_agent_task_id } = await response.json();

    // Poll for results
    while (true) {
      const statusRes = await fetch(
        `https://api.outx.ai/linkedin-agent/get-task-status?api_agent_task_id=${api_agent_task_id}`,
        { headers: { "x-api-key": "YOUR_API_KEY" } }
      );

      const result = await statusRes.json();
      if (result.data.status === "completed") {
        return result.data.task_output;
      }

      await new Promise((r) => setTimeout(r, 5000));
    }
  }

  const results = await searchProfiles({
    title: "VP of Engineering",
    company: "Google",
    count: 25,
  });
  console.log(results.profiles);
  ```

  ```python Python theme={null}
  import requests
  import time

  def search_profiles(filters):
      headers = {
          "Content-Type": "application/json",
          "x-api-key": "YOUR_API_KEY",
      }

      # Create the search task
      response = requests.post(
          "https://api.outx.ai/linkedin-agent/search-profiles",
          headers=headers,
          json=filters,
      )
      task_id = response.json()["api_agent_task_id"]

      # Poll for results
      while True:
          result = requests.get(
              "https://api.outx.ai/linkedin-agent/get-task-status",
              headers={"x-api-key": "YOUR_API_KEY"},
              params={"api_agent_task_id": task_id},
          ).json()

          if result["data"]["status"] == "completed":
              return result["data"]["task_output"]

          time.sleep(5)

  results = search_profiles({
      "title": "VP of Engineering",
      "company": "Google",
      "count": 25,
  })
  print(results["profiles"])
  ```
</RequestExample>

## Error Responses

| Status | Error                                                                     | Description                                                                                        |
| ------ | ------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------- |
| `400`  | `At least one search filter is required (keywords, title, company, etc.)` | No filter fields were provided in the request body                                                 |
| `401`  | `Missing API Key` / `Invalid API Key`                                     | API key is missing or invalid                                                                      |
| `403`  | `Plugin installation required...`                                         | No team member has an active Chrome extension. See [Authentication](/api-reference/authentication) |

## FAQ

<AccordionGroup>
  <Accordion title="What data does each profile in the results include?">
    Each profile in the search results typically includes: full name, headline, location, profile slug, profile URN, connection degree (1st, 2nd, or 3rd+), and profile image URL. The profile slug and URN can be used with other API endpoints such as [Fetch Profile](/linkedin-api/fetch-profile) and [Send Message](/linkedin-api/send-message).
  </Accordion>

  <Accordion title="What is the maximum number of results I can request?">
    The `count` parameter is capped at **50 profiles per request**. If you pass a value greater than 50, it will be clamped to 50. The default is 25 if `count` is not specified.
  </Accordion>

  <Accordion title="How do I find LinkedIn geo_urn, industry, or company URN values?">
    LinkedIn URNs for geography, industry, and company can be found by inspecting LinkedIn Voyager API requests in your browser's developer tools when performing a search on LinkedIn. Common geo URNs: `103644278` (United States), `101165590` (United Kingdom), `102713980` (India).
  </Accordion>

  <Accordion title="Should I space out search requests?">
    Yes. OutX is a proxy and does not rate-limit requests on your behalf. Each search is executed as a real LinkedIn people search. Running many searches in rapid succession can trigger LinkedIn's activity monitoring. Space requests at least 10–30 seconds apart. See [Rate Limits](/api-reference/rate-limits).
  </Accordion>

  <Accordion title="Can I fetch full profiles for the results?">
    Yes. Each profile in the results includes a `profile_slug`. You can pass that slug to the [Fetch Profile](/linkedin-api/fetch-profile) endpoint to retrieve the full profile data including experience, education, and skills.
  </Accordion>
</AccordionGroup>

## Related

* [Get Task Status](/linkedin-api/get-task-status) - Poll for task results
* [Fetch Profile](/linkedin-api/fetch-profile) - Get full profile data using a slug from search results
* [Send Message](/linkedin-api/send-message) - Message a connection using their profile URN
* [Quick Start](/linkedin-api/quickstart) - End-to-end tutorial

***

## Learn More

* [LinkedIn API Guide](https://www.outx.ai/blog/linkedin-api-guide)
* [How to Scrape LinkedIn Data Safely](https://www.outx.ai/blog/scrape-data-linkedin)
* [LinkedIn Automation Safety Guide](https://www.outx.ai/blog/linkedin-automation-safety-guide-best-practices-2026)