# Linkedin Jobs Company Scraper (`scraperoka/linkedin-jobs-company-scraper`) Actor
🚀 LinkedIn Company Scraper efficiently pulls detailed company data from LinkedIn About pages—website, industry, size, HQ, followers & description. 🏢 Perfect for B2B lead gen, sales research, and recruiting teams. 📈 Save time, boost targeting.
- **URL**: https://apify.com/scraperoka/linkedin-jobs-company-scraper.md
- **Developed by:** [Scraperoka](https://apify.com/scraperoka) (community)
- **Categories:** Lead generation, Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $0.01 / 1,000 results
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 a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):
```bash
npm install apify-client
```
In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):
```bash
pip install apify-client
```
In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):
````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash
In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).
If your project is in a different language, use 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 & Company Scraper 🎯
Manually collecting job postings one by one wastes hours you don’t have. **LinkedIn Jobs & Company Scraper** automates scraping job listings and details at scale. This LinkedIn jobs scraper (and LinkedIn company scraper) is ideal for marketers, recruiters, and growth teams that need LinkedIn job listings scraper tool outputs fast—potentially thousands of job records in minutes from a single run.
---
### What You Get: Sample Output
Here’s a sample record from a single run:
```json
{
"title": "Senior Data Analyst",
"location": "Dhaka, Bangladesh",
"company_name": "ExampleTech Ltd",
"posted_time_ago": "3 weeks ago",
"posted_datetime": "2026-05-13T12:34:56.789012",
"applicants": "23 applicants",
"base_salary": "$80k–$100k per year",
"additional_compensation": "Bonus and incentive",
"seniority_level": "mid_senior",
"employment_type": "full_time",
"job_function": "data",
"industries": "information_technology",
"description_text": "Build and optimize analytics pipelines...\n\nResponsibilities include...",
"description_html": "Build and optimize analytics pipelines...
",
"job_urn": "urn:li:jobPosting:1234567890",
"job_url": "https://www.linkedin.com/jobs/view/1234567890",
"apply_type": "Easy Apply",
"apply_url": "https://www.linkedin.com/jobs/view/1234567890",
"recruiter_name": "Jane Doe",
"recruiter_detail": "Recruiter • Talent Acquisition",
"recruiter_image": "https://example.com/recruiter-image.jpg",
"recruiter_profile": "https://www.linkedin.com/in/janedoe",
"company_profile": "https://www.linkedin.com/company/exampletech/",
"company_logo": "https://example.com/company-logo.png",
"company_id": "99887766"
}
````
| Field | Type | What It Tells You |
|---|---|---|
| `title` | string | The job title so you can sort and prioritize roles instantly |
| `location` | string | Where the role is based (or what location is shown on the listing) |
| `company_name` | string | The company behind the opening for lead building and segmentation |
| `posted_time_ago` | string | A quick freshness indicator like “3 weeks ago” |
| `posted_datetime` | string | A normalized ISO timestamp when available for analytics and trend tracking |
| `applicants` | string | How many applicants are shown for the posting |
| `base_salary` | string | Any base compensation text detected (often useful for qualification) |
| `additional_compensation` | string | Extra benefits/incentives if present on the posting |
| `seniority_level` | string | Seniority classification derived from job criteria items when available |
| `employment_type` | string | Employment type (for example full-time vs contract) when available |
| `job_function` | string | Job function extracted from criteria items |
| `industries` | string | Industry tags extracted from criteria items |
| `description_text` | string | Clean text you can use for keyword matching and scoring |
| `job_url` | string | Direct link to the job posting for verification and bookmarking |
| `apply_type` | string | Whether it’s shown as “External” or “Easy Apply” |
| `recruiter_name` | string | Name of the recruiter/hirer when detected on the job details |
| `company_profile` | string | Company profile link for your LinkedIn company data extraction workflow |
| `company_id` | string | Company identifier when the actor can detect it |
| `description_html` | string | HTML markup of the job description (handy if you need richer parsing) |
Export your dataset as JSON, CSV, or Excel — straight from the Apify dashboard.
***
### Why LinkedIn Jobs & Company Scraper?
There are a lot of ways to pull data from LinkedIn job listings — here’s what sets LinkedIn Jobs & Company Scraper apart.
#### Bulk job detail extraction (not just shallow cards)
This LinkedIn job listings scraper tool fetches job details per posting and returns structured fields like `title`, `company_name`, `description_text`, and more.
#### Output designed for lead generation workflows
If you’re doing LinkedIn jobs and companies data mining, the dataset includes job URLs, company profile links, recruiter fields, and company identifiers—so you can build actionable lists faster.
#### Built-in resilience for real-world scraping
It includes retry handling for blocked or unstable requests and keeps the run moving so you get results even when some pages don’t respond cleanly.
#### Clean, structured JSON ready to analyze
Each result is pushed as a consistent JSON object with predictable keys (for example `job_urn`, `job_url`, `apply_type`, `apply_url`, `recruiter_*`, `company_*`), making it easy to load into spreadsheets, BI tools, or CRMs.
***
### Configuring Your Run
Drop this into your `input.json` to get started:
```json
{
"search_url": "https://www.linkedin.com/jobs/jobs-in-bangladesh",
"max_results": 50
}
```
| Parameter | Required | What It Does |
|---|---:|---|
| `search_url` | ✅ | The LinkedIn jobs search URL you want to scrape from (supports different job search URLs) |
| `max_results` | ✅ | Maximum number of jobs to scrape from the search results |
> Note: The actor code also supports proxy configuration via an input field named `proxyConfiguration`, but it’s not included in the provided actor input schema. If you see `proxyConfiguration` in your Apify UI, you can use it to enable built-in proxy support for more reliable scraping.
***
### Core Capabilities
#### Scrapes job postings into structured fields
LinkedIn Jobs & Company Scraper is built to extract job-specific details such as `title`, `location`, `posted_datetime`, `description_text`, and compensation when available—ideal for people building datasets from public web data.
#### Company and recruiter context included
For LinkedIn company contact scraper and recruiter-related workflows, each record includes `company_name`, `company_profile`, recruiter fields like `recruiter_name`, plus `recruiter_profile` and `recruiter_image` when detected.
#### Uses your search URL + result cap for predictable runs
You control the source via `search_url` and set an explicit cap with `max_results`, which makes LinkedIn jobs scraper with filters workflows easier to operationalize (even when you only have the search URL available).
#### Resilient fetching with retries and fallbacks
When requests are blocked or unstable, the actor handles those cases and retries appropriately, helping avoid “all-or-nothing” failures during longer LinkedIn automation for job scraping runs.
#### Real-time dataset writing (so you keep progress)
Each successfully fetched job detail record is pushed immediately to the dataset, so you can export partial results if you stop a run early.
In short: you get a dataset that’s ready for LinkedIn jobs lead generation, analysis, and outreach building—without manually clicking each job.
***
### Who Gets the Most Out of This
Here’s how different teams put LinkedIn Jobs & Company Scraper to work:
**Recruiters & Talent Sourcers** — Build a shortlist of roles and companies by exporting job titles, locations, and recruiter fields into a spreadsheet, then quickly filter for seniority and employment type.
**Sales Development Representatives** — Use the extracted `company_profile` and `job_url` to create targeted prospect lists and reduce prospecting time when your ICP hires through job postings.
**Market Researchers & Data Analysts** — Turn job description content into structured datasets using `description_text` plus timestamp fields like `posted_datetime` to study hiring trends over time.
**Automation & Integration Developers** — Pull consistent JSON outputs via the Apify platform, then map fields like `apply_type`, `base_salary`, and `recruiter_profile` into your pipeline without custom parsing.
**Growth Teams & HR Operations** — Monitor recurring job openings and keep a “current roles” dataset for internal reporting, competitor benchmarking, and workflow automation using exports from the dataset tab.
***
### Step-by-Step: How to Use It
No coding needed. Here's how to run LinkedIn Jobs & Company Scraper from start to finish:
1. **Open the actor on Apify** — Go to [console.apify.com](https://console.apify.com) and open **LinkedIn Jobs & Company Scraper**.
2. **Enter your inputs** — Set `search_url` to your LinkedIn jobs search URL and choose `max_results` for how many jobs you want to scrape.
3. **Configure proxy support (optional)** — If you need more reliable scraping at higher volume, enable proxy settings available in the Apify interface.
4. **Hit Run and watch the live log** — Monitor progress as job postings are processed and details are fetched.
5. **View results in the dataset tab** — Open the dataset to inspect the JSON records as they’re produced.
6. **Export as JSON, CSV, or Excel** — Use the export options from the Apify dataset UI for downstream use.
The whole process takes under 5 minutes to set up.
***
### Integrations & Export Options
Once your data is collected, LinkedIn Jobs & Company Scraper plugs directly into your existing workflow.
Export your results from the Apify dataset tab as JSON, CSV, or Excel. That makes it straightforward to enrich spreadsheets, dashboards, and lead lists with fields like `job_url`, `company_profile`, and `description_text`.
You can also connect the actor to automation systems using Apify’s capabilities (for example, via the Apify API), and you can use webhook-based patterns supported by Apify workflows to trigger downstream steps (CRM updates, notifications, and more). For the most up-to-date details, refer to the Apify documentation linked from the Apify developer resources: https://apify.com/docs/api
***
### Pricing & Free Trial
LinkedIn Jobs & Company Scraper runs on the Apify platform, which offers a **free tier** — no credit card required to get started. Free tier credits (and paid usage) are handled by Apify’s platform billing model, typically based on Apify compute usage (CU), not per-row fees from your dataset.
For exact current pricing, credits, and plan limits, check the Apify pricing page. Start for free at [apify.com](https://apify.com) and scale when you're ready.
***
### Reliability & Performance
| What We Handle | How |
|---|---|
| Rate limiting and unstable responses | Includes retries and backoff behavior for blocked/failed requests |
| Proxy-assisted reliability | Supports built-in proxy usage if enabled in your run |
| Partial progress capture | Successfully fetched jobs are pushed to the dataset as they’re processed |
| Missing fields on some postings | Returned values may be `null` or omitted depending on what the page provides |
| Scaling to your cap | The run respects your `max_results` limit for predictable output volume |
**Limitations:** This actor works with publicly accessible job details available through the provided search URL. If some postings don’t provide certain data points (like salary or recruiter details), those fields may be missing or empty in the output. For enterprise-scale configurations, contact us to discuss your needs.
For enterprise-scale runs, contact us to discuss custom configurations.
***
### Frequently Asked Questions
#### Is there a free plan or trial?
Yes. Apify provides a free tier so you can run LinkedIn Jobs & Company Scraper for testing before scaling up.
#### Do I need to log in to LinkedIn to use this?
No login is required for the inputs you provide (the actor is designed to scrape job details from publicly available data).
#### How accurate is the data?
The accuracy depends on what’s available on the job postings and job details pages. The actor extracts structured fields like `title`, `company_name`, and `description_text` when they exist in the source content.
#### How many results can I get per run?
You control the maximum number of scraped jobs using `max_results`. The actor stops when it reaches that cap.
#### How often is the data updated / how fresh is it?
Freshness depends on how current the underlying job postings are at the time you run. The dataset includes `posted_time_ago` and a normalized `posted_datetime` field when it can determine the posting time.
#### Is this legal? Does it comply with GDPR / CCPA?
You should use this tool only for lawful purposes and in compliance with applicable regulations (including GDPR and CCPA) and platform rules. The actor collects **publicly available data**, but responsibility for compliant use remains with you.
#### Can I export results to Google Sheets or Excel?
Yes. You can export your dataset from the Apify dashboard, and Excel-friendly formats like CSV and JSON exports make it easy to move data into spreadsheets. You can also connect your results to other tools using Apify-supported automation patterns.
#### Can I run this on a schedule automatically?
Yes. You can schedule actor runs on the Apify platform using supported scheduling capabilities, so your job listings dataset stays updated without manual effort.
#### Can I access this via API?
Yes. Apify actors can be triggered and monitored via the Apify API, and you can fetch results programmatically from the produced dataset. See Apify API docs for details: https://apify.com/docs/api
#### What happens if the actor hits an error?
If some requests fail, the actor uses retry handling for blocked or unstable responses and continues processing where possible. If a fetch fails for a job detail, that job may return no result, but the run can still produce other records you can export.
***
### Need Help or Have a Request?
Got a question about LinkedIn Jobs & Company Scraper or want a new feature added? Reach out at — we actively maintain this actor and welcome feedback. If you’d like enhancements like webhook notifications on completion or additional filtering options, tell us what you need.
***
### Disclaimer & Responsible Use
*LinkedIn Jobs & Company Scraper is the fastest, most reliable way to build structured datasets from public job postings — start your free run today.*
This actor collects **publicly available data** only and does not access private accounts, login-gated content, or password-protected pages. You are responsible for complying with GDPR, CCPA, platform ToS, and any applicable laws. For data removal requests, contact . Use responsibly, ethically, and only for lawful purposes.
# Actor input Schema
## `search_url` (type: `string`):
LinkedIn jobs search URL
## `max_results` (type: `integer`):
Maximum number of jobs to scrape
## Actor input object example
```json
{
"search_url": "https://www.linkedin.com/jobs/jobs-in-bangladesh",
"max_results": 50
}
```
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"search_url": "https://www.linkedin.com/jobs/jobs-in-bangladesh"
};
// Run the Actor and wait for it to finish
const run = await client.actor("scraperoka/linkedin-jobs-company-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = { "search_url": "https://www.linkedin.com/jobs/jobs-in-bangladesh" }
# Run the Actor and wait for it to finish
run = client.actor("scraperoka/linkedin-jobs-company-scraper").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 '{
"search_url": "https://www.linkedin.com/jobs/jobs-in-bangladesh"
}' |
apify call scraperoka/linkedin-jobs-company-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=scraperoka/linkedin-jobs-company-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Linkedin Jobs Company Scraper",
"description": "🚀 LinkedIn Company Scraper efficiently pulls detailed company data from LinkedIn About pages—website, industry, size, HQ, followers & description. 🏢 Perfect for B2B lead gen, sales research, and recruiting teams. 📈 Save time, boost targeting.",
"version": "0.1",
"x-build-id": "q2ObXdnQpbP9VDuWu"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/scraperoka~linkedin-jobs-company-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-scraperoka-linkedin-jobs-company-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
},
"/acts/scraperoka~linkedin-jobs-company-scraper/runs": {
"post": {
"operationId": "runs-sync-scraperoka-linkedin-jobs-company-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor and returns information about the initiated run in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK",
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/runsResponseSchema"
}
}
}
}
}
}
},
"/acts/scraperoka~linkedin-jobs-company-scraper/run-sync": {
"post": {
"operationId": "run-sync-scraperoka-linkedin-jobs-company-scraper",
"x-openai-isConsequential": false,
"summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
"tags": [
"Run Actor"
],
"requestBody": {
"required": true,
"content": {
"application/json": {
"schema": {
"$ref": "#/components/schemas/inputSchema"
}
}
}
},
"parameters": [
{
"name": "token",
"in": "query",
"required": true,
"schema": {
"type": "string"
},
"description": "Enter your Apify token here"
}
],
"responses": {
"200": {
"description": "OK"
}
}
}
}
},
"components": {
"schemas": {
"inputSchema": {
"type": "object",
"required": [
"search_url",
"max_results"
],
"properties": {
"search_url": {
"title": "Search URL",
"type": "string",
"description": "LinkedIn jobs search URL"
},
"max_results": {
"title": "Max Results",
"minimum": 1,
"type": "integer",
"description": "Maximum number of jobs to scrape",
"default": 50
}
}
},
"runsResponseSchema": {
"type": "object",
"properties": {
"data": {
"type": "object",
"properties": {
"id": {
"type": "string"
},
"actId": {
"type": "string"
},
"userId": {
"type": "string"
},
"startedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"finishedAt": {
"type": "string",
"format": "date-time",
"example": "2025-01-08T00:00:00.000Z"
},
"status": {
"type": "string",
"example": "READY"
},
"meta": {
"type": "object",
"properties": {
"origin": {
"type": "string",
"example": "API"
},
"userAgent": {
"type": "string"
}
}
},
"stats": {
"type": "object",
"properties": {
"inputBodyLen": {
"type": "integer",
"example": 2000
},
"rebootCount": {
"type": "integer",
"example": 0
},
"restartCount": {
"type": "integer",
"example": 0
},
"resurrectCount": {
"type": "integer",
"example": 0
},
"computeUnits": {
"type": "integer",
"example": 0
}
}
},
"options": {
"type": "object",
"properties": {
"build": {
"type": "string",
"example": "latest"
},
"timeoutSecs": {
"type": "integer",
"example": 300
},
"memoryMbytes": {
"type": "integer",
"example": 1024
},
"diskMbytes": {
"type": "integer",
"example": 2048
}
}
},
"buildId": {
"type": "string"
},
"defaultKeyValueStoreId": {
"type": "string"
},
"defaultDatasetId": {
"type": "string"
},
"defaultRequestQueueId": {
"type": "string"
},
"buildNumber": {
"type": "string",
"example": "1.0.0"
},
"containerUrl": {
"type": "string"
},
"usage": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "integer",
"example": 1
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
},
"usageTotalUsd": {
"type": "number",
"example": 0.00005
},
"usageUsd": {
"type": "object",
"properties": {
"ACTOR_COMPUTE_UNITS": {
"type": "integer",
"example": 0
},
"DATASET_READS": {
"type": "integer",
"example": 0
},
"DATASET_WRITES": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_READS": {
"type": "integer",
"example": 0
},
"KEY_VALUE_STORE_WRITES": {
"type": "number",
"example": 0.00005
},
"KEY_VALUE_STORE_LISTS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_READS": {
"type": "integer",
"example": 0
},
"REQUEST_QUEUE_WRITES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_INTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"DATA_TRANSFER_EXTERNAL_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
"type": "integer",
"example": 0
},
"PROXY_SERPS": {
"type": "integer",
"example": 0
}
}
}
}
}
}
}
}
}
}
```