# LinkedIn Profile & Company Search (X-ray, No Account) (`nextgensda/linkedin-scraper`) Actor

Find LinkedIn profiles and companies by job title, location, company and keywords with Google X-ray search, then read each public page: experience, education, About, posts, company size and HQ. No LinkedIn account, no cookies, no browser. Pay per row found.

- **URL**: https://apify.com/nextgensda/linkedin-scraper.md
- **Developed by:** [Tauqeer Abbas](https://apify.com/nextgensda) (community)
- **Categories:** Lead generation, Social media, Jobs
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 profiles

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## LinkedIn Profile & Company Search (X-ray, No Account)

![LinkedIn Profile & Company Search: X-ray search by title, location and company, public profiles with experience and education, and pay-per-event pricing shown as a receipt](https://api.apify.com/v2/key-value-stores/ctb2ySDTcan577sFw/records/banner-2026-10-28.png?signature=pO14k73oKrKZvOAwICgn)

Find **LinkedIn profiles and companies** by job title, location, company
and keywords, then read each public page: current company, experience,
education, About, followers, posts and websites; for companies, size,
industry, headquarters, specialties, locations and similar companies.

**No LinkedIn account, no cookies.** Searches run on Google
("X-ray search", the recruiters' trick: `site:linkedin.com/in "data
engineer" "Austin"`), and details come from the public pages LinkedIn
shows to anyone. Nothing to log in to, so nothing of yours can be
restricted or banned.

### What it does

| Input | Rows |
|---|---|
| **Job titles, locations, companies, keywords** (people) | one row per person found: name, headline, current company, location, followers, connections, experience, education, About, posts, websites |
| **Keywords, locations, countries** (companies) | one row per company: industry, size, employees on LinkedIn, headquarters and address, type, founded, specialties, website, followers, About, locations, similar and affiliated pages |
| **Your own Google queries** | the same, for any X-ray query you already use |
| **LinkedIn URLs** (profiles, companies) | the public page of each |

### Why this one

- **Pay per person found, not per search page.** No fee for search pages
  that bring nothing new, and duplicates are never charged.
- **More results than one search allows.** Google stops after about 300
  results a search. The actor splits your search into one per title,
  location, company and country, runs them side by side and removes
  duplicates, so synonyms and nearby cities add new people instead of
  repeats.
- **Country filter that means the country.** Pick countries by code (`GB`,
  `DE`, `IN`, `PK`...) and the search covers LinkedIn's site for that
  country, so "UK" can't turn into Ukraine.
- **The headline LinkedIn hides.** Public pages rarely show a member's
  headline; Google's result does. Each row merges both: Google's
  headline with the page's location, company, education and About.
- **No account risk, ever.** No login, no cookies, no session to burn.
- **Reliable search pages.** Google's default results now often ignore
  `site:`; the actor asks for Google's Web results, which keep it, so
  every page stays on LinkedIn.

### Input examples

**Data engineers in Austin and Round Rock (two title variants):**

```json
{
    "titles": ["data engineer", "data engineering"],
    "locations": ["Austin", "Round Rock"],
    "maxItems": 200
}
```

**Product managers in the UK and Germany who mention fintech:**

```json
{
    "titles": ["product manager"],
    "keywords": ["fintech"],
    "countries": ["GB", "DE"],
    "excludeKeywords": ["intern"]
}
```

**Fintech companies in Austin:**

```json
{
    "searchType": "companies",
    "keywords": ["fintech"],
    "locations": ["Austin"]
}
```

**Profiles and companies by URL:**

```json
{
    "startUrls": [
        { "url": "https://www.linkedin.com/in/williamhgates" },
        { "url": "https://www.linkedin.com/company/apify/" }
    ]
}
```

### Output

One row per profile or company; `dataType` says which. `search` holds the
Google result a row came from (query, position, title, snippet), and
`hydrated` says whether the public page was read.

**Profile** (`dataType: "profile"`):

| Field | Example |
|---|---|
| `name`, `first_name`, `last_name` | Jane Doe |
| `headline` | Senior Data Engineer at Acme (from Google) |
| `company`, `current_companies` | Acme |
| `location`, `country` | Austin, Texas, United States; US |
| `followers`, `connections` | 576, 500+ |
| `about` | the first ~250 characters of About |
| `experience` | company, company URL, location, dates where shown |
| `education` | school, school URL, degree, years |
| `posts`, `articles` | URL, date, text, likes |
| `websites`, `services`, `projects`, `languages` | as listed |
| `url`, `public_id`, `image` | https://www.linkedin.com/in/jane-doe |

**Company** (`dataType: "company"`): `name`, `industry`, `size`,
`employees`, `headquarters`, `address`, `type`, `founded`, `specialties`,
`website`, `followers`, `about`, `tagline`, `logo`, `locations`, `people`
(a few employees LinkedIn shows), `similar`, `affiliated`, `posts`, `url`.

### Pricing

Pay per row: platform usage is included, so you never pay Apify compute or
proxy traffic on top.

| Event | Price |
|---|---|
| Run start | $0.002 per GB of memory ($0.008 at the default 4 GB) |
| Search start (once per run that searches) | $0.03 |
| `profile` (a person found) | $2.00 / 1,000 |
| `profile-details` (their public page read) | $2.00 / 1,000 |
| `company` (with its page) | $2.50 / 1,000 |

**Example:** 500 data engineers in Austin with details = $0.008 + $0.03 +
500 × $0.002 + 500 × $0.002 = **$2.04**.

People located outside your locations (with *Only people located there*),
duplicates and profiles that aren't public are never charged. Runs with
LinkedIn URLs only don't pay the search start. Turn off *Read each
profile's public page* to pay only for what Google shows. Your **spending
limit** is always respected.

### Good to know

- **What public pages don't show.** Without an account LinkedIn hides
  experience titles of most members (the companies are there), skills,
  and contact details; About is cut at ~250 characters; some entries
  are masked (`****`). This actor doesn't log in, so it doesn't have them.
- **Search results come from Google's copy** and can lag a profile's
  latest change; the public page (read by default) corrects company and
  location.
- **About 300 results a search.** Add titles, locations or countries to
  find more: each combination is searched on its own.
- **Profiles that aren't public** are skipped with a note in the log and
  aren't charged.

### Use it from your tools

Run it from the Apify API, Make, Zapier, n8n or Google Sheets, or call it
from AI agents through the Apify MCP server. Export to JSON, CSV, Excel or
HTML.

# Actor input Schema

## `searchType` (type: `string`):

What the search finds: people's profiles or company pages.

## `titles` (type: `array`):

Job titles or roles, e.g. "data engineer", "VP of Sales". Each becomes its own search (see Split searches), so synonyms find more people.

## `locations` (type: `array`):

Cities or regions, e.g. "Austin", "Greater London". Google also matches the place in names, schools and past jobs: keep "Only people located there" on to deliver only people whose profile says they live there.

## `strictLocation` (type: `boolean`):

Drop (and don't charge) profiles whose public page shows a location outside your locations: Google also matches the place in names, schools and past jobs. Needs the profile's public page (Read each profile's public page).

## `companies` (type: `array`):

Current or past employers, e.g. "Stripe". For company searches: words in the company's name or page.

## `keywords` (type: `array`):

Words or phrases every result must contain, e.g. "python", "fintech".

## `excludeKeywords` (type: `array`):

Results containing these are left out, e.g. "intern", "recruiter".

## `countries` (type: `array`):

Two-letter country codes (US, GB, DE, IN, PK...). Searches LinkedIn's site for that country, which is more precise than a location word. Each country is its own search.

## `splitQueries` (type: `boolean`):

One Google search per title x location x company x country (Google stops after ~300 results a search, so splitting finds more). Off: one search with OR groups.

## `googleQueries` (type: `array`):

Your own Google X-ray queries, e.g. site:linkedin.com/in "product manager" ("Denver" OR "Boulder"). site:linkedin.com/in (or /company) is added if missing.

## `startUrls` (type: `array`):

Profile (linkedin.com/in/...) or company (linkedin.com/company/...) URLs to read directly.

## `scrapeDetails` (type: `boolean`):

Adds experience, education, About, followers, posts and websites to each profile found (charged as profile details). Off: what Google shows (name, headline, company, location). Company rows always include their page.

## `maxPagesPerQuery` (type: `integer`):

10 results a page; Google rarely goes past ~35 pages.

## `maxItems` (type: `integer`):

The run stops after this many rows.

## `proxyConfiguration` (type: `object`):

For reading public pages. Apify's datacenter proxy is enough. Google searches always go through Apify's Google SERP proxy.

## Actor input object example

```json
{
  "searchType": "profiles",
  "titles": [
    "data engineer"
  ],
  "locations": [
    "Austin"
  ],
  "strictLocation": true,
  "splitQueries": true,
  "scrapeDetails": true,
  "maxPagesPerQuery": 10,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `rows` (type: `string`):

Profiles and companies: name, headline, company, location, industry, size, followers and link.

## `allFields` (type: `string`):

Every field: experience, education, About, posts, articles, websites; company specialties, locations, similar pages; the Google result each row came from.

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "titles": [
        "data engineer"
    ],
    "locations": [
        "Austin"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("nextgensda/linkedin-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "titles": ["data engineer"],
    "locations": ["Austin"],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("nextgensda/linkedin-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "titles": [
    "data engineer"
  ],
  "locations": [
    "Austin"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call nextgensda/linkedin-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,nextgensda/linkedin-scraper"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/lrCM07x4s5RVXEHKd/builds/HaSut3yJ9NiTTYQOo/openapi.json