# LinkedIn Jobs Scraper & Search API — Remote Jobs & Hiring (`gauravlabs/linkedin-jobs-api`) Actor

Search LinkedIn job listings by keyword, location ID, company and remote/hybrid filters. Collect job titles, company names, posting dates, URLs and salary text when available. Export deduplicated JSON, CSV or Excel. Search listings only; no full descriptions.

- **URL**: https://apify.com/gauravlabs/linkedin-jobs-api.md
- **Developed by:** [Gaurav Kumar Choudhary](https://apify.com/gauravlabs) (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

$2.00 / 1,000 job listings

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 Jobs Scraper & Search API

### At a glance

- Collect: LinkedIn job-search listings with available company, location and posting metadata.
- Input: use the runnable example below or the prefilled Input form.
- Output: the default dataset supports JSON/CSV/Excel export; see output modes below.
- Billing: $2 per 1,000 unique delivered job listings. Up to 25 listings per fetched page; counts vary. No startup fee. Platform usage may be additional.
- Limits: No full job descriptions, recruiter contacts, applicant enrichment or complete-index guarantee.

Search LinkedIn job listings and export structured hiring data for recruitment
research, remote job discovery, company hiring monitoring and labor-market analysis.
Filter by job keywords, location ID, company, posting date and workplace type.
Collect job titles, company names, locations, source URLs and salary text when
available, with duplicate job IDs removed within each run.

This is a **search-listing API**, not a full job-description or enrichment service.
It is independent and not an official LinkedIn API or LinkedIn-affiliated product.
Pricing: **$2 per 1,000 delivered unique job listings**, with no startup fee.

### What can you use it for?

- Discover remote, hybrid or on-site jobs matching a role and geographic market.
- Research company hiring activity and recruiting opportunities.
- Collect advertised salary text, job titles and locations for market analysis.
- Schedule repeated searches with Apify and compare exported datasets yourself.
- Feed structured job listings into dashboards, spreadsheets and API workflows.

### Quick start: collect up to 25 jobs

Enter a keyword such as `software engineer`, choose a location ID, optionally add
filters, then start the Actor. Open the dataset to inspect results or export JSON,
CSV or Excel from Apify. No LinkedIn login or cookies are requested in Actor input.

```json
{
  "keywords": "software engineer",
  "geo_code": 103644278,
  "sort_by": "Most recent",
  "maxItems": 25,
  "maxPages": 1,
  "maxProviderCredits": 2
}
```

`103644278` is the United States location ID. For another location, use the
`geoId` value in a LinkedIn jobs search URL. Results depend on source availability.

### Remote software engineering jobs posted this week

```json
{
  "keywords": "software engineer",
  "geo_code": 103644278,
  "onsite_remotes": ["Remote"],
  "date_posted": "Past week",
  "maxItems": 100,
  "maxPages": 4,
  "maxProviderCredits": 8
}
```

### Microsoft marketing jobs in the United States

```json
{
  "keywords": "marketing",
  "geo_code": 103644278,
  "company_ids": [1035],
  "sort_by": "Most relevant",
  "maxItems": 25,
  "maxPages": 1,
  "maxProviderCredits": 2
}
```

### Search filters and pagination

| Input | Purpose |
| --- | --- |
| `keywords` | Required job title or search keywords |
| `geo_code` | Numeric LinkedIn location ID |
| `company_ids` | Company IDs; `1035` is Microsoft |
| `date_posted` | Any time, Past month, Past week or Past 24 hours |
| `onsite_remotes` | Remote, Hybrid and/or On-site |
| `experience_levels` | Internship, Entry level, Associate, Mid-Senior level, Director or Executive |
| `job_types` | Full-time, Part-time, Contract, Temporary, Internship or Other |
| `easy_apply` | Request Easy Apply listings when true |
| `under_10_applicants` | Request this filter; applicant counts are not returned |
| `sort_by` | Most recent or Most relevant |
| `maxItems` | Maximum unique saved jobs, from 1 to 1,000 |
| `maxPages` | Maximum search pages, from 1 to 40 |
| `maxProviderCredits` | Run-level operational budget; 2 credits per attempted page |
| `start` | Starting offset in multiples of 25: 0, 25, 50, etc. |

Advanced filters also accept industry IDs, title IDs and supported job functions.
Empty filter arrays mean no restriction; matching depends on the source.
Increase both `maxPages` and `maxProviderCredits` for larger searches: four pages
require a budget of at least eight credits. These service credits are an operational
limit, not an Apify dollar price or a free allowance.

Three limits apply: unique output rows, search pages and estimated service credits.
Each attempted page reserves 2 credits. Pages may return fewer than 25 listings.
No automatic retries. Repeated or short pages stop pagination. Results reflect
fetched pages, not a guaranteed complete LinkedIn job index.

### Output: one row per unique job listing

Illustrative sample based on the successful live test:

```json
{
  "jobId": "4474183659",
  "jobUrl": "https://www.linkedin.com/jobs/view/4474183659/",
  "title": "Channel Mktg Mgr",
  "company": "Microsoft",
  "companyUrl": "https://www.linkedin.com/company/microsoft",
  "location": "Istanbul, Istanbul, Türkiye",
  "postedTime": "2026-10-01 12:44:35",
  "workplaceType": "On-site",
  "query": "marketing",
  "geoCode": 92000000,
  "pageOffset": 0,
  "recordType": "job_listing",
  "fetchedAt": "2026-10-09T18:32:21.263611+00:00"
}
```

Optional fields are omitted when unavailable. `salaryText`, when present, is source
text rather than a normalized estimate. `postedTime` retains source text;
`fetchedAt` is the UTC collection timestamp, not a guarantee of source freshness.

One dataset row per unique job listing. SUMMARY contains page counts, conservative
credit estimates, stop reason and sanitized error codes. No raw response or request
headers are exported. Empty searches are valid and return zero rows. An upstream
failure marks the run failed; already saved partial results remain available.

### Use as a LinkedIn job search API

Once you have access to the Actor, call it with your own Apify token:

```bash
curl --request POST \
  --url 'https://api.apify.com/v2/acts/gauravlabs~linkedin-jobs-api/run-sync-get-dataset-items' \
  --header 'Authorization: Bearer YOUR_APIFY_TOKEN' \
  --header 'Content-Type: application/json' \
  --data '{"keywords":"marketing","geo_code":103644278,"maxItems":25,"maxPages":1,"maxProviderCredits":2}'
```

For larger searches, start an asynchronous run and retrieve its dataset after
completion. Apify scheduling and platform integrations can connect results to
workflows such as n8n and Make; these are not custom integrations bundled here.

### Frequently asked questions

#### Does it return full job descriptions?

No. Full descriptions, detailed enrichment, applicant counts, recruiter contacts
and email discovery are not included.

#### Can I collect all matching jobs?

No completeness guarantee is offered. Each page returns up to 25 jobs; availability,
your limits, short/repeated pages or request failures can reduce the output.

#### Are repeated searches deduplicated?

Job IDs are deduplicated within a single run. Cross-run deduplication and new-job
alerts are not built in; compare exported IDs in your own workflow. There is no
resume or double-charge guarantee.

#### What happens on a failed request?

There are no automatic retries. A service error marks the run failed, and already
saved rows remain available. Inspect SUMMARY and report the run ID to the developer.

#### Has this been live-tested?

A one-page smoke test returned 25 unique Microsoft marketing listings. This is
a limited functional check, not an uptime or performance benchmark.

#### What is the price?

Each delivered unique job listing costs $0.002 on every Apify plan. There is no
startup fee. For example, 25 delivered listings cost $0.05 and 100 cost $0.20 in
Actor result charges. Apify platform usage may be additional depending on your
plan. Empty results, error summaries and within-run duplicates are not billed as
job results. Repeated runs can deliver and charge for the same listings again.
Previously delivered results remain available and charged if a later page fails.
Full job descriptions and job-details enrichment are not included in this price.

Use only with appropriate access and redistribution permissions. Availability and
field completeness are not guaranteed. No source-website login or cookies are used
by this integration.

### Support

For bugs or specific workflow requirements, contact the developer through Apify.
Include the run ID, non-sensitive input and expected output. Never send API keys.
Field availability may change; no availability or completeness guarantee is offered.

### Minimal API example

Store your own Apify token in `APIFY_TOKEN`; never paste it into public input or code. This example uses the same small input as the prefilled form.

```python
import os
import requests

response = requests.post(
    "https://api.apify.com/v2/acts/gauravlabs~linkedin-jobs-api/run-sync-get-dataset-items",
    headers={"Authorization": "Bearer " + os.environ["APIFY_TOKEN"]},
    json={"keywords":"software engineer"},
    timeout=300,
)
response.raise_for_status()
print(response.json())
```

For large batches, start an asynchronous run with `/runs`, wait for its final status, and retrieve its default dataset. HTTP success when starting a run does not prove the extraction succeeded.

#### Minimal output shape (illustrative)

The following shows one documented field, not a fresh result or a promised yield. Inspect the output reference above for the complete schema.

```json
{
  "recordType": "job"
}
```

### Practical workflow and accuracy notes

Use `onsite_remotes`, `experience_levels`, `company_ids` and other documented filters for targeted searches. Use `maxPages` and `maxProviderCredits` together for pagination; up to 25 results per page is a maximum, not a promise. This price covers search listings only, not job-detail enrichment. Compare jobId in your own scheduled workflow for new-job tracking.

# Actor input Schema

## `keywords` (type: `string`):

Search title or keywords. Boolean syntax is passed through; matching depends on the source.

## `geo_code` (type: `integer`):

LinkedIn geographic ID. Example 103644278 = United States. Find another ID in LinkedIn's jobs search URL geoId parameter.

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

Maximum unique rows saved. Actual count depends on availability and page/credit limits.

## `maxPages` (type: `integer`):

Each page requests up to 25 listings. Increase maxProviderCredits along with this limit.

## `maxProviderCredits` (type: `integer`):

Conservatively reserves 2 credits per HTTP attempt. This is a run-level cap, not a monthly or per-account free allowance.

## `date_posted` (type: `string`):

Restrict listing recency.

## `sort_by` (type: `string`):

Order matching jobs by recency or relevance.

## `onsite_remotes` (type: `array`):

Optional workplace filters; empty means no restriction.

## `experience_levels` (type: `array`):

Optional experience filters; empty means no restriction.

## `job_types` (type: `array`):

Optional employment filters; empty means no restriction.

## `company_ids` (type: `array`):

Optional numeric LinkedIn company IDs. Example 1035 = Microsoft.

## `industries` (type: `array`):

Optional numeric industry IDs from the source search filters.

## `title_ids` (type: `array`):

Optional numeric title IDs; leave empty unless known.

## `functions` (type: `array`):

Optional job functions; empty means no restriction.

## `easy_apply` (type: `boolean`):

When true, request Easy Apply listings only.

## `under_10_applicants` (type: `boolean`):

When true, request listings with fewer than 10 applicants.

## `start` (type: `integer`):

Use multiples of 25: 0, 25, 50, etc.

## `requestTimeoutSecs` (type: `integer`):

No automatic retries, to avoid unexpected credit consumption.

## Actor input object example

```json
{
  "keywords": "software engineer",
  "geo_code": 103644278,
  "maxItems": 25,
  "maxPages": 1,
  "maxProviderCredits": 2,
  "date_posted": "Any time",
  "sort_by": "Most recent",
  "onsite_remotes": [],
  "experience_levels": [],
  "job_types": [],
  "company_ids": [],
  "industries": [],
  "title_ids": [],
  "functions": [],
  "easy_apply": false,
  "under_10_applicants": false,
  "start": 0,
  "requestTimeoutSecs": 60
}
```

# Actor output Schema

## `results` (type: `string`):

No description

## `summary` (type: `string`):

No description

# 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 = {
    "keywords": "software engineer"
};

// Run the Actor and wait for it to finish
const run = await client.actor("gauravlabs/linkedin-jobs-api").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 = { "keywords": "software engineer" }

# Run the Actor and wait for it to finish
run = client.actor("gauravlabs/linkedin-jobs-api").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 '{
  "keywords": "software engineer"
}' |
apify call gauravlabs/linkedin-jobs-api --silent --output-dataset

```

## MCP server setup

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

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/3507XXNSERV31laco/builds/UGDCpt67D622EVJKe/openapi.json