# LinkedIn Jobs Scraper + Direct Apply Links & API (`dev_web_col/company-jobs`) Actor

LinkedIn jobs for recruiting and hiring research, plus the original posting from the company job board: direct apply link, salary and full description.

- **URL**: https://apify.com/dev\_web\_col/company-jobs.md
- **Developed by:** [Diseño Web de Colombia](https://apify.com/dev_web_col) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 job returneds

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## LinkedIn Jobs API + Direct Apply Links

**Every LinkedIn jobs scraper gives you the LinkedIn listing. This one also gives you the original.**

### Call it as an API

One search in, LinkedIn jobs out with the original apply link attached — in a single HTTP call, no polling.

```bash
curl -X POST "https://api.apify.com/v2/acts/dev_web_col~company-jobs/run-sync-get-dataset-items?token=YOUR_TOKEN" \\
  -H "Content-Type: application/json" \\
  -d '{"searchKeyword": "python developer", "location": "Berlin"}'
```

```python
import requests

r = requests.post(
    "https://api.apify.com/v2/acts/dev_web_col~company-jobs/run-sync-get-dataset-items",
    params={"token": "YOUR_TOKEN"},
    json={"searchKeyword": "python developer", "location": "Berlin"},
)
job = r.json()[0]
print(job["title"], job["applyUrl"], job["source"])
```

Single-entity lookup, for calling once per company from your own code:

```bash
curl -X POST "https://api.apify.com/v2/acts/dev_web_col~company-jobs/run-sync-get-dataset-items?token=YOUR_TOKEN" \\
  -H "Content-Type: application/json" -d '{"company": "Stripe"}'
```

`run-sync-get-dataset-items` waits for the run and returns the rows in the same
response. Your token is on the [Integrations page](https://console.apify.com/account/integrations).

### What is this LinkedIn Jobs Scraper?

Search LinkedIn jobs by keyword, location and date, without a login or a cookie. Then, wherever the company runs a public job board, this Actor also fetches the **original posting**: the direct apply link, the salary, and the full description that LinkedIn's copy leaves out.

It works in two modes. Search mode is the normal one — a keyword, a place, a time window. Company mode takes a list of company names and returns every open role at each.

### The cross-reference is the product

LinkedIn shows you a copy. The company's own applicant tracking system has the source. This Actor matches them up against a bundled index of 1,014 validated company job boards.

What that gets you, measured on real runs:

- **The direct apply URL**, so candidates skip LinkedIn's redirect entirely
- **Salary ranges** that LinkedIn's copy usually drops
- **Jobs that are not on LinkedIn at all.** One real run on Stripe, Ramp and Vanta returned **791 jobs, 731 of which had not been posted to LinkedIn**

Every row is tagged with its source, so you always know whether it came from LinkedIn, from the ATS, or from both.

### What you can use it for

| What you want | How to ask for it |
|---|---|
| **Recruiting research** — who is hiring for this role | `searchKeyword` + `location` |
| **Sourcing a specific company** | `company: "Stripe"` — every open role, one call |
| **Job board feed** — listings with working apply links | Read `applyUrl` from the ATS side, not LinkedIn's redirect |
| **Salary benchmarking** | Read `compensationText` where the company publishes it |
| **Hiring data for sales** — accounts staffing up | Group results by company, count roles |
| **Market mapping** — which companies hire in a city | `location` + `postedWithin: "week"` |
| **Remote job aggregation** | `remoteOnly: true` |
| **Finding roles not yet on LinkedIn** | Company mode surfaces ATS-only postings |

Typical jobs: **recruiting** research, building a **job board**, **hiring data**
for sales prospecting, and salary benchmarking.

### What data you get

Job title, company, location, remote flag, posting date, LinkedIn URL, and — where the company was matched to its job board — the direct apply link, salary text, department, employment type and full description. Each row carries a source tag and a flag for whether the ATS match succeeded.

### Input

Every field is optional unless marked required.

| Field | Type | Description |
|---|---|---|
| `searchKeyword` | string | What to search for on LinkedIn, e.g. "python developer", "marketing manager", "nurse". This is the normal way to use the actor. Leave it empty only if you want to target specific companies below instead. |
| `location` | string | City, region or country: Berlin, London, United States, Remote. Leave empty to search worldwide. |
| `postedWithin` | string | Only jobs published recently. The tightest window is the most useful one: it is how you catch a role before the applications pile up. |
| `remoteOnly` | boolean | Keeps only roles LinkedIn flags as remote. |
| `companies` | array | Company names as they appear on LinkedIn: Stripe, Ramp, Vanta. Overrides the search above and returns every open role at those companies. The actor resolves each name to its LinkedIn page and to its own job board automatically — you paste no URLs or IDs. |
| `titleKeyword` | string | Extra filter applied to the job title after fetching, e.g. "senior". Leave empty to keep everything. |
| `sources` | array | Leave empty to use both. LinkedIn alone is faster; the company job board alone avoids LinkedIn entirely and never gets blocked. |
| `maxPagesPerCompany` | integer | Each page is 10 jobs. In search mode this is the total; in company mode it is per company. |
| `maxResults` | integer | Safety cap. You are charged per job returned. |
| `proxyConfiguration` | object | Required for LinkedIn. It blocks datacenter IPs, including Apify's, so runs without a residential proxy return nothing from LinkedIn. |

#### Input sample

```json
{
  "searchKeyword": "python developer",
  "location": "Berlin",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

### Output sample

One real row from an actual run:

```json
{
  "id": "mercor:4431457554",
  "company": "Mercor",
  "title": "Python Developer - Fully Remote | Upto $50/hr",
  "location": "Berlin, Berlin, Germany",
  "source": "linkedin",
  "atsMatch": true,
  "linkedInUrl": "https://de.linkedin.com/jobs/view/python-developer-fully-remote-upto-%2450-hr-at-mercor-4431457554",
  "linkedInPostedAt": "2026-06-24",
  "applyUrl": null,
  "ats": null,
  "department": null,
  "employmentType": null,
  "compensationText": null,
  "postedAt": "2026-06-24",
  "isRemote": null,
  "descriptionText": "",
  "logoUrl": "https://media.licdn.com/dms/image/v2/D560BAQGcXYycU1ExMQ/company-logo_100_100/B56Zs5S_mvJoAU-/0/1766192839354/mercor_ai_logo?e=2147483647&v=beta&t=kdzYrfdTDCtqk7IVgNC_2hgj8o1vFeu3AEFeXdhDaHI"
}
```

### Who uses this

- **Recruiters and sourcers** — see the whole market, then go to the source
- **Job boards and aggregators** — a feed with apply links that actually work
- **Candidates building tools** — skip the LinkedIn redirect, apply direct
- **Sales teams** — hiring signals with the department attached
- **Analysts** — compare what a company posts publicly against what it posts on LinkedIn

### Honest limits

These are real and none of them is fixable by any tool. They are here so you know what you are buying before you run it.

- **A residential proxy is required.** LinkedIn blocks datacenter IPs. The default input already asks for one.
- **The cross-reference only fires for companies in the index**, currently 1,014 of them and weighted toward tech. Rows that do not match still come back, just without the ATS extras.
- **LinkedIn's public search returns roughly 10 jobs per page** and repeats results once it runs out, so very deep paging hits diminishing returns.
- **No recruiter contact details.** This Actor returns job data only, never personal data about the people posting.
- **Salary depends on the company publishing it.** Most do not.

### FAQ

#### Do I need a LinkedIn account or cookies?

No. This Actor uses LinkedIn's public guest job listings, the same ones you see when logged out. You never provide credentials and your account is never involved, so there is nothing to get banned.

#### What does the ATS cross-reference actually add?

The direct apply link, the salary and the full description from the company's own system — plus jobs that are open at the company but were never posted to LinkedIn. On a real three-company run that was 731 extra roles out of 791.

#### Why did only some rows get the direct apply link?

Because the cross-reference needs the company to be in the bundled index of public job boards. Companies outside it still return their LinkedIn data, just without the extras.

#### Can I search by company instead of by keyword?

Yes. Put names in `companies` and you get every open role at each, which is where the enrichment pays off most.

#### How recent can I filter?

Down to the last 24 hours, via `postedWithin`. There are also options for the last week and the last month.

#### Do I need an account or an API key for the source?

No. This Actor only reads public pages and public endpoints, the same ones any
logged-out visitor sees. You never give it credentials, and nothing is done on
your behalf.

#### Is it legal to scrape this data?

Scraping publicly available information is broadly accepted as legal, and this
Actor only ever touches pages that require no login. That said, what you may do
with the data afterwards is a separate question — personal data in particular is
regulated by GDPR and CCPA. If you plan to process personal data, take advice
first. Apify has a good primer: [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/)

#### How much will a run cost me?

You are charged per result, so the cost scales with what you actually get back.
The pricing is shown on this page above the input form. Start with a small run to
see real numbers before you scale up.

#### Can I export to Excel, CSV or Google Sheets?

Yes. Every run's dataset can be downloaded as CSV, Excel, JSON, XML or HTML from
the **Storage** tab, and Apify integrates directly with Google Sheets, Airtable,
Zapier, Make and Slack.

#### Can I run this on a schedule?

Yes. Open the **Schedules** tab and pick an interval — hourly, daily, weekly.
Each run only costs you what it returns.

#### Can I call it from my own code instead of the console?

Yes. Every Actor on Apify is also an API endpoint. There are official clients for
[Python](https://docs.apify.com/api/client/python/) and
[JavaScript](https://docs.apify.com/api/client/js/), plus a plain REST API. The
**API** tab on this page shows ready-made snippets with your input already filled in.

#### Something came back empty. Is it broken?

Usually not. An empty result normally means the filters were too narrow, or the
source genuinely has nothing to return for that query. This Actor is written to
finish successfully and tell you what happened rather than fail — check the run
log, it says which step returned nothing.

### Related Actors

- **ATS Job Scraper** — search the company job boards directly, without LinkedIn
- **ATS Job Monitor** — get only what changed since your last run
- **Company Enrichment** — domains to firmographics, emails and hiring signal

### Where the data comes from

LinkedIn's public guest job listings, plus the public JSON endpoints of Greenhouse, Lever, Ashby and Workable. No login, no cookies, no personal data about recruiters.

# Actor input Schema

## `searchKeyword` (type: `string`):

What to search for on LinkedIn, e.g. "python developer", "marketing manager", "nurse". This is the normal way to use the actor. Leave it empty only if you want to target specific companies below instead.

## `company` (type: `string`):

One company name, for when you call this Actor as an API — every open role at that company, cross-referenced with its own job board. For several companies, use the list below.

## `location` (type: `string`):

City, region or country: Berlin, London, United States, Remote. Leave empty to search worldwide.

## `postedWithin` (type: `string`):

Only jobs published recently. The tightest window is the most useful one: it is how you catch a role before the applications pile up.

## `remoteOnly` (type: `boolean`):

Keeps only roles LinkedIn flags as remote.

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

Several company names at once, one per line. Each returns all of its open roles. Use this for batch runs rather than a live lookup.

## `titleKeyword` (type: `string`):

Extra filter applied to the job title after fetching, e.g. "senior". Leave empty to keep everything.

## `sources` (type: `array`):

Leave empty to use both. LinkedIn alone is faster; the company job board alone avoids LinkedIn entirely and never gets blocked.

## `maxPagesPerCompany` (type: `integer`):

Each page is 10 jobs. In search mode this is the total; in company mode it is per company.

## `maxResults` (type: `integer`):

Safety cap. You are charged per job returned.

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

Required for LinkedIn. It blocks datacenter IPs, including Apify's, so runs without a residential proxy return nothing from LinkedIn.

## Actor input object example

```json
{
  "searchKeyword": "python developer",
  "location": "Berlin",
  "postedWithin": "",
  "remoteOnly": false,
  "companies": [],
  "sources": [],
  "maxPagesPerCompany": 10,
  "maxResults": 2000,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `jobs` (type: `string`):

One dataset item per job.

# 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 = {
    "searchKeyword": "python developer",
    "location": "Berlin",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dev_web_col/company-jobs").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 = {
    "searchKeyword": "python developer",
    "location": "Berlin",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("dev_web_col/company-jobs").call(run_input=run_input)

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

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

```

## CLI example

```bash
echo '{
  "searchKeyword": "python developer",
  "location": "Berlin",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call dev_web_col/company-jobs --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=dev_web_col/company-jobs",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

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