# ⚡ Fast LinkedIn Jobs Scraper (`galih_rakasiwi/linkedin-job-market-api`) Actor

Fast, login-free LinkedIn job search scraper. Extract enriched job listings, salary estimates, skill demand analytics, and major-matching data into JSON/CSV.

- **URL**: https://apify.com/galih\_rakasiwi/linkedin-job-market-api.md
- **Developed by:** [RD.Galih Rakasiwi](https://apify.com/galih_rakasiwi) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$20.00 / 1,000 job listing results

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/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 Scraper & Market Intelligence

> **Production-grade job market data — no login, no cookies, no friction.**
> Extract enriched job listings, salary estimates, skill-demand analytics, and academic-major-matched opportunities from LinkedIn's public endpoints. Purpose-built for AI pipelines, quantitative recruiting, and labor market intelligence at scale.

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-FF9012?logo=apify\&logoColor=white)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)
[![AI-Ready](https://img.shields.io/badge/AI_Ready-RAG_|_LLM_|_Embeddings-6E3FF3)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)
[![No Login Required](https://img.shields.io/badge/Auth-100%25_Login_Free-16A34A)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)
[![High Speed](https://img.shields.io/badge/Speed-Fast_Mode_5–10x-2563EB)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)
[![Python](https://img.shields.io/badge/Python-3.11%2B-3776AB?logo=python\&logoColor=white)](https://python.org)
[![Pay Per Result](https://img.shields.io/badge/Pricing-Pay_Per_Result-0891B2)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)
[![Pricing](https://img.shields.io/badge/Price-$0.02%2Fjob-059669)](https://apify.com/galih_rakasiwi/linkedin-job-market-api)

***

### Why This Actor Wins in a Crowded Market

Most LinkedIn scrapers in the Apify Store are commoditized — they extract basic title/company/location tuples and call it a day. **This Actor is different.** It was architected from the ground up as a **market intelligence engine**, not just a scraper.

| Capability | Typical LinkedIn Scrapers | This Actor |
|---|---|---|
| **Authentication** | Require cookies / session tokens | ✅ 100% login-free — guest endpoint with session orchestration |
| **Salary Extraction** | No or basic regex | ✅ Multi-currency parser (6 regex patterns + context-aware period detection) |
| **Skill Tagging** | Manual or none | ✅ 125+ technical & soft skills auto-extracted from job descriptions |
| **Analytics Layer** | Not available | ✅ Skill demand ranking, salary distribution, workplace-type breakdown |
| **Academic Major Matching** | Not available | ✅ Curated skill → job-title mapping for 25+ university majors |
| **Speed Modes** | One speed only | ✅ Fast Mode (5–10× faster, search-card data) vs. Full Enrichment |
| **Output Quality** | Inconsistent fields | ✅ 25+ typed fields per job, flat schema, CSV/JSON export ready |
| **AI/LLM Readiness** | Raw HTML or sparse JSON | ✅ Clean structured output, embedding-ready, RAG-pipeline compatible |
| **Resilience** | Often none | ✅ Token-bucket rate limiter, exponential backoff, proxy integration, circuit-breaker patterns |

**The bottom line:** If you need raw job listings, any scraper works. If you need **enriched, analytics-ready labor market data** that feeds directly into an AI pipeline, dashboard, or decision engine — this is the tool.

***

### Key Features

#### 🎯 Multi-Mode Job Scraping

| Mode | What It Does | Best For |
|---|---|---|
| `search` | Single keyword, maximum detail (25+ fields per job) | Targeted job market research |
| `batch_search` | Up to 10 keywords in parallel, results merged & deduplicated | Cross-role market comparison |
| `major_search` | Auto-generates keyword from academic major (e.g., "Teknik Informatika") | University career centers, edtech platforms |
| `analytics` | Runs skill-demand & salary analysis on a keyword — no per-result charge | Labor market intelligence dashboards |

#### 💰 Salary Intelligence

- **6 regex patterns** covering USD (`$102,000 – $159,000`), IDR (`Rp 8.000.000 – Rp 15.000.000`), EUR, GBP, JPY, and bare-number formats
- **Context-aware period detection** — monthly vs. hourly vs. annual, inferred from surrounding text and currency
- **Structured output** — `salary_min`, `salary_max`, `salary_currency`, `salary_period`, `salary_raw`

#### 📊 Skill Demand Analytics

- **125+ technical skills** auto-extracted: programming languages, frameworks, databases, cloud platforms, DevOps tools, ML/AI libraries
- **25+ soft skills** detected: Communication, Leadership, Agile, Scrum, Project Management
- **Aggregated summaries** included at no extra charge when `enableAnalytics: true`

#### 🎓 Academic Major → Job Matching

Curated skill-to-job-title mapping for 25+ Indonesian university majors. Enter `"Teknik Informatika"` and the Actor auto-generates an optimized Boolean search query from the most relevant skills, then returns matching job listings.

#### ⚡ Dual Speed Modes

| Mode | Speed | Fields Returned | Cost Implication |
|---|---|---|---|
| **Full Enrichment** (default) | Normal (~20–35s per query) | 25+ fields: salary, skills, benefits, description, criteria | Same per-result price, richer data |
| **Fast Mode** (`fastMode: true`) | 5–10× faster | Core fields: id, title, company, location, link | Same per-result price, faster throughput |

***

### Input Schema

```json
{
  "mode": "search",
  "keyword": "Data Engineer",
  "location": "Indonesia",
  "maxItems": 25,
  "remoteOnly": false,
  "experienceLevel": "mid",
  "employmentType": "full-time",
  "datePosted": "week",
  "fastMode": false,
  "enableAnalytics": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  },
  "requestTimeoutSecs": 30,
  "debugMode": false
}
```

#### Full Parameter Reference

| Parameter | Type | Default | Description |
|---|---|---|---|
| `mode` | enum | `"search"` | `search`, `batch_search`, `major_search`, or `analytics` |
| `keyword` | string | — | Job title, skill, or Boolean query. Supports `AND`, `OR`, `NOT`, `"exact phrase"` |
| `keywords` | string\[] | `[]` | List of queries for `batch_search` mode (max 10) |
| `majorName` | enum | — | Academic major name for `major_search` mode (25+ options) |
| `location` | string | — | Country, city, or region filter (leave empty for worldwide) |
| `maxItems` | integer | `10` | Results per query (1–25) |
| `remoteOnly` | boolean | `false` | Remote positions only |
| `experienceLevel` | enum | — | `internship`, `entry`, `associate`, `mid`, `senior`, `director`, `executive` |
| `employmentType` | enum | — | `full-time`, `part-time`, `contract`, `temporary`, `internship` |
| `datePosted` | enum | `"month"` | `"24h"`, `"week"`, or `"month"` |
| `fastMode` | boolean | `false` | Skip detail fetch — 5–10× faster, returns core fields only |
| `enableAnalytics` | boolean | `false` | Append a free analytics summary record to the dataset |
| `proxyConfiguration` | object | Residential | Apify proxy settings (highly recommended) |
| `requestTimeoutSecs` | integer | `30` | HTTP request timeout (10–120 seconds) |
| `debugMode` | boolean | `false` | Enable verbose structured logging |

***

### Enriched Output Sample

Every job listing is pushed to your dataset as a single flat record — no nesting surprises, CSV-export-ready on day one.

```json
{
  "id": 4435506324,
  "title": "Data Engineer",
  "company_name": "TechCorp Indonesia",
  "company_industry": "Technology, Information and Internet",
  "company_logo_url": "https://media.licdn.com/dms/image/...",
  "company_linkedin_url": "https://www.linkedin.com/company/techcorp/",
  "location_city": "Jakarta",
  "location_state": "Jakarta",
  "location_country": "Indonesia",
  "location_formatted": "Jakarta, Indonesia",
  "workplace_type": "Hybrid",
  "employment_type": "Full-time",
  "seniority_level": "Mid-Senior level",
  "job_function": "Engineering",
  "industries": ["Technology", "Information Services"],
  "posted_at": "2026-08-06T00:00:00+00:00",
  "posted_time_ago": "3 days ago",
  "applicant_count": 47,
  "salary_min": 15000000.0,
  "salary_max": 25000000.0,
  "salary_currency": "IDR",
  "salary_period": "monthly",
  "salary_raw": "Rp 15.000.000 - Rp 25.000.000",
  "skills": [
    { "name": "Python", "category": "technical" },
    { "name": "SQL", "category": "technical" },
    { "name": "Apache Airflow", "category": "technical" },
    { "name": "Apache Spark", "category": "technical" },
    { "name": "AWS", "category": "technical" },
    { "name": "Communication", "category": "soft" }
  ],
  "benefits": ["BPJS Kesehatan", "BPJS Ketenagakerjaan", "Remote Work Flexibility"],
  "requirements": [
    "3+ years of experience in data engineering",
    "Strong proficiency in Python and SQL",
    "Experience with Apache Airflow or similar orchestration tools"
  ],
  "description_snippet": "We are looking for a Data Engineer to build and maintain our data platform. You will design ETL pipelines...",
  "easy_apply": true,
  "linkedin_url": "https://www.linkedin.com/jobs/view/4435506324",
  "_query_keyword": "Data Engineer",
  "_query_location": "Indonesia",
  "scraped_at": "2026-08-09T06:00:00+00:00"
}
```

> **Analytics Summary** (appended when `enableAnalytics: true` — no extra charge):
>
> ```json
> {
>   "type": "summary",
>   "query_keyword": "Data Engineer",
>   "query_location": "Indonesia",
>   "total_jobs_found": 25,
>   "top_skills": "Python, SQL, Apache Spark, AWS, ETL",
>   "salary_range": "8000000 – 35000000",
>   "workplace_distribution": { "On-site": 12, "Hybrid": 9, "Remote": 4 }
> }
> ```

***

### Quick Integration

#### Python (Apify SDK)

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_APIFY_API_TOKEN")

## Launch the Actor and wait for completion
run = client.actor("galih_rakasiwi/linkedin-job-market-api").call(
    run_input={
        "mode": "search",
        "keyword": "Data Engineer",
        "location": "Indonesia",
        "maxItems": 25,
        "enableAnalytics": True
    }
)

## Fetch results — flat JSON, ready for pandas
jobs = list(
    client.dataset(run["defaultDatasetId"]).iterate_items()
)

## Load into DataFrame for analysis
import pandas as pd
df = pd.DataFrame(jobs)
print(f"Extracted {len(df)} jobs | Salary range: {df['salary_min'].min():.0f} – {df['salary_max'].max():.0f} {df['salary_currency'].mode()[0]}")
```

#### cURL (REST API)

```bash
curl -X POST "https://api.apify.com/v2/acts/galih_rakasiwi~linkedin-job-market-api/runs?token=YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "mode": "search",
    "keyword": "Machine Learning Engineer",
    "location": "Singapore",
    "maxItems": 25,
    "datePosted": "week",
    "enableAnalytics": true
  }'

## Fetch results after run completes
curl "https://api.apify.com/v2/datasets/<DATASET_ID>/items?token=YOUR_API_TOKEN&format=json&clean=1"
```

#### Node.js (Apify SDK)

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

const client = new ApifyClient({ token: 'YOUR_APIFY_API_TOKEN' });

const run = await client.actor('galih_rakasiwi/linkedin-job-market-api').call({
    mode: 'batch_search',
    keywords: ['Data Engineer', 'MLOps Engineer', 'Analytics Engineer'],
    location: 'Indonesia',
    maxItems: 15,
    enableAnalytics: true,
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(`Extracted ${items.length} enriched job listings`);

// Filter for high-salary remote roles
const highValue = items
    .filter(j => j.workplace_type === 'Remote' && (j.salary_min || 0) >= 20000000);
console.log(`${highValue.length} remote roles above 20M IDR`);
```

#### Apify CLI

```bash
apify call galih_rakasiwi/linkedin-job-market-api \
  --input '{"mode": "search", "keyword": "Data Engineer", "maxItems": 25}' \
  --output jobs.json
```

***

### Pricing & Support

| Item | Price |
|---|---|
| Each job listing pushed to dataset | **$0.02** / result |
| Analytics summary record | **Free** — no charge |
| Failed run / zero results | **Free** — you pay only for data you receive |

You are never billed for compute time, retries, or empty runs. This is pure **Pay-Per-Result** — transparent, predictable, and aligned with your data needs.

#### Cost Estimator

| Scenario | Estimated Results | Estimated Cost |
|---|---|---|
| 1 keyword × 10 jobs | 10 | $0.20 |
| Batch 5 keywords × 10 jobs each | 50 | $1.00 |
| Major search × 25 jobs | 25 | $0.50 |
| Analytics mode (skill + salary insights) | 1 summary record | Free |

***

### How We Handle Stability & Anti-Bot

LinkedIn's public endpoints are rate-limited and subject to HTML structure changes. This Actor includes multiple layers of defense to maximize uptime and data consistency:

| Layer | Mechanism |
|---|---|
| **Token-Bucket Rate Limiter** | Throttles requests to ~8–10 req/s, preventing burst patterns that trigger IP blocks |
| **Exponential Backoff Retry** | 3 retries with 1s → 2s → 4s backoff on `TimeoutException`, `ConnectError`, `RemoteProtocolError` |
| **Auth Wall Detection** | Monitors redirects to `/login`, `/checkpoint`, `/signup` — surfaces clean errors instead of silent data loss |
| **HTTP 429 Handler** | Respects `Retry-After` headers when LinkedIn rate-limits, backing off gracefully |
| **Session Warmup** | Establishes guest cookies via a dedicated warmup request before any data fetch |
| **Proxy Integration** | First-class Apify Residential Proxy support — rotates IPs to avoid geographic and volumetric blocking |
| **Partial Result Resilience** | If one job detail fetch fails, the rest of the batch continues — no all-or-nothing failures |
| **CSS Selector Constants** | All HTML selectors are module-level constants. When LinkedIn changes markup, only selectors update — parsing logic stays intact |
| **Circuit Breaker Ready** | Detects consecutive failures and can halt requests during cool-down periods (configurable) |

This isn't a naive `requests.get()` loop. It's a production-grade HTTP client with session orchestration, originally built as a FastAPI microservice with structured logging, type safety (`mypy` strict mode), and >80% test coverage on parser logic.

***

### Perfect For

| Audience | Use Case |
|---|---|
| **Quantitative Researchers** | Labor market econometrics, salary trend modeling, skill-demand forecasting |
| **Data Scientists & ML Engineers** | Build job recommendation engines, train skill-gap classifiers, feed RAG pipelines |
| **AI Developers** | Power AI Career Agents with real-time structured job data + skill analytics |
| **HR Tech & Recruiting Platforms** | Backend job feed, competitive hiring intelligence, salary benchmarking |
| **Universities & EdTech** | Career center job matching, curriculum-to-market alignment analysis |
| **Job Boards & Aggregators** | Structured job feed with 25+ fields — no parsing needed |
| **Government & Policy Research** | Labor market analysis, workforce planning, employment policy data |

***

### Tech Stack

**FastAPI** · **httpx** (HTTP/2) · **BeautifulSoup4 + lxml** · **Pydantic v2** · **Apify SDK** (Python) · **structlog** (structured JSON logging) · **MongoDB** (optional, for `major_search` mode)

***

### Development & Self-Hosting

This Actor is built on a standalone FastAPI microservice that can run independently outside Apify:

```bash
## Clone and set up
git clone <repo-url> && cd linkedin_api
uv sync

## Run as Apify Actor (local simulation)
uv run python src/main.py

## Run as REST API server
uv run uvicorn app.main:app --reload
```

Full technical documentation — architecture, data flow pipeline, parser strategy, configuration reference, and testing guide — is available in [`docs/DOCUMENTATION.md`](docs/DOCUMENTATION.md).

***

### Disclaimer

This Actor accesses publicly available data from LinkedIn's guest (non-authenticated) endpoints. It does not bypass authentication, scrape logged-in content, or violate LinkedIn's robots.txt directives.

- **Data Rights:** All job listing data remains the property of the respective employers and LinkedIn Corporation. Users are responsible for complying with LinkedIn's Terms of Service and applicable data protection laws in their jurisdiction.
- **No Affiliation:** This Actor is not affiliated with, endorsed by, or connected to LinkedIn Corporation or Microsoft.
- **Accuracy:** Salary data is extracted from job descriptions using heuristic parsing. Not all listings include salary information — null values indicate the employer did not disclose compensation.
- **Rate Limits:** LinkedIn's guest API imposes a soft limit of ~50–75 results per query. The Actor respects these limits and surfaces them transparently.

***

### License

MIT — see [LICENSE](LICENSE).

# Actor input Schema

## `mode` (type: `string`):

Choose how you want to extract LinkedIn job data.

## `keyword` (type: `string`):

Job title, skill, or boolean search. Supports AND, OR, NOT, and quoted exact phrases. Examples: 'Software Engineer', 'Python AND SQL AND Spark', '"data engineer" remote'.

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

List of search queries. Each query will run independently and results are merged. Max 10 queries per run.

## `majorName` (type: `string`):

Indonesian academic major (prodi). The actor auto-generates relevant LinkedIn search keywords from curated skill data. Requires MongoDB with seeded data.

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

Geographic filter — country, city, or region. Leave empty for worldwide results.

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

Maximum number of job postings to extract per query (max 25). LinkedIn guest API limits total results to ~50-75 across all pages.

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

Show only fully remote positions.

## `experienceLevel` (type: `string`):

Filter by career level.

## `employmentType` (type: `string`):

Filter by employment arrangement.

## `datePosted` (type: `string`):

Only show jobs posted within this time period.

## `fastMode` (type: `boolean`):

ON = 5-10x faster, but only id/title/company/location/link per job (no salary, skills, benefits, description). OFF (default) = full detail per job, much slower for large maxItems. Applies to Single Search, Batch Search, and Search by Major modes only.

## `enableAnalytics` (type: `boolean`):

Push an additional analytics summary record to the dataset containing top skills, salary ranges, and stats. Useful for dashboards.

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

Route requests through Apify proxy to avoid IP blocking by LinkedIn. HIGHLY RECOMMENDED — residential proxies give best results.

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

HTTP request timeout in seconds. Increase for slow proxy connections.

## `debugMode` (type: `boolean`):

Enable verbose logging. Useful for troubleshooting.

## Actor input object example

```json
{
  "mode": "search",
  "keyword": "Software Engineer",
  "keywords": [
    "Python Developer",
    "Data Engineer",
    "Product Manager",
    "DevOps Engineer",
    "Machine Learning Engineer"
  ],
  "majorName": "Teknik Informatika",
  "location": "Indonesia",
  "maxItems": 10,
  "remoteOnly": false,
  "experienceLevel": "",
  "employmentType": "",
  "datePosted": "month",
  "fastMode": false,
  "enableAnalytics": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "requestTimeoutSecs": 30,
  "debugMode": false
}
```

# Actor output Schema

## `jobListings` (type: `string`):

All scraped job postings in the default dataset — one record per job with id, title, company, location, salary, skills, benefits, and more. Export as JSON, CSV, Excel, or access programmatically via API.

## `analyticsSummary` (type: `string`):

Filtered view of summary/analytics records in the dataset. Contains skill demand rankings, salary ranges, and workplace distribution per query. Only present when enableAnalytics is turned on or when running analytics mode.

## `rawDatasetApi` (type: `string`):

Direct API endpoint to the full dataset. Use for programmatic access or custom filtering beyond the views above.

# 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 = {
    "mode": "search",
    "keyword": "Software Engineer",
    "keywords": [
        "Python Developer",
        "Data Engineer",
        "Product Manager",
        "DevOps Engineer",
        "Machine Learning Engineer"
    ],
    "majorName": "Teknik Informatika",
    "location": "Indonesia",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("galih_rakasiwi/linkedin-job-market-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 = {
    "mode": "search",
    "keyword": "Software Engineer",
    "keywords": [
        "Python Developer",
        "Data Engineer",
        "Product Manager",
        "DevOps Engineer",
        "Machine Learning Engineer",
    ],
    "majorName": "Teknik Informatika",
    "location": "Indonesia",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("galih_rakasiwi/linkedin-job-market-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 '{
  "mode": "search",
  "keyword": "Software Engineer",
  "keywords": [
    "Python Developer",
    "Data Engineer",
    "Product Manager",
    "DevOps Engineer",
    "Machine Learning Engineer"
  ],
  "majorName": "Teknik Informatika",
  "location": "Indonesia",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call galih_rakasiwi/linkedin-job-market-api --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,galih_rakasiwi/linkedin-job-market-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/3vXFpE9Iw8AN1G3Gg/builds/hJu3thVw2M9yjPtTP/openapi.json