# AI Job Match + LinkedIn Jobs Scraper: scored to your CV (`rich_minds/linkedin-job-match-ai`) Actor

First 25 jobs free. AI job match for LinkedIn jobs: scrapes your search, drops reposts, agencies and duplicates free, scores each job 0-100 against your CV with a recruiter note. Pay per matched job, no start fee. Free demo on any plan; live search runs on your own Apify account.

- **URL**: https://apify.com/rich\_minds/linkedin-job-match-ai.md
- **Developed by:** [Rich Minds](https://apify.com/rich_minds) (community)
- **Categories:** Jobs, AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 matched job (rules only)s

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

## AI Job Match + LinkedIn Jobs Scraper: scored to your CV

**Get only the new LinkedIn jobs that fit your CV, each scored 0–100 with why it fits, the skills you're missing, visa-sponsorship flags and a link to the person who posted it.**

⚡ First **25 jobs free** · 💵 **$0.002** per matched job · 🤖 AI match **≈ $0.015 all-in** ($0.01 + tokens) · 🔑 **No API key needed** — the AI uses the model access of your Apify plan, or your own key · ⏱️ demo in seconds, live search ≈ 3–6 min (estimate) · 🍪 no LinkedIn cookies

![One row per matched job — rank, match score, verdict, the skills you match and miss, salary and the next step](https://api.apify.com/v2/key-value-stores/Ls1cTnQ9NhS2OiWp8/records/shortlist.svg)

> **Try it in 30 seconds.** Click **Try it** — the form is pre-filled with 7 sample jobs and a sample CV: free, on any
> plan. The live LinkedIn search runs on your own Apify account (a plan that runs Store Actors); your first **25
> matched jobs** are free, and jobs that fail your filters are never charged.
> → [What a run costs](#-pricing--what-a-run-really-costs) · [What the AI adds](#-what-the-ai-tier-adds) · [Daily job alerts](#-run-it-daily--linkedin-job-alerts)

### ⚡ At a glance

| | |
|---|---|
| **What you get** | a ranked shortlist of LinkedIn jobs that fit your CV: score, skills you match / miss, salary, sponsorship flags, who posted it and how to reach them |
| **You provide** | 1–5 job search terms, a location and your CV — pasted, or a link to a PDF / DOCX |
| **Output** | JSON / CSV / Excel dataset, best match first, plus `RUN_SUMMARY` (funnel + market report) and a `DIGEST` for Slack / e-mail |
| **Typical run** | 3 searches × 40 jobs = 120 scraped → ≈ 30 matched (estimate); the demo: 7 sample jobs → 3 matched |
| **Cost of that run** | $0.24 LinkedIn scraper + 30 × $0.01 AI match + ≈ $0.19 tokens = **≈ $0.73** ($0.30 with AI off) |
| **AI tier, all in** | ≈ $0.0148 per matched job: $0.01 here + ≈ $0.0048 AI tokens on your account (basic: $0.002) |
| **Free tier** | first 25 matched jobs per account; filtered, duplicate and below-score jobs are always free |
| **Works with** | Schedules, webhooks, Sheets, Slack, Notion / Airtable, n8n / Make / Zapier, MCP agents |

### 🎯 What this Actor does

It scrapes your LinkedIn searches, then does the reading for you — you pay only for jobs that pass your filters and
your minimum score:

- **A job match score against your resume** — 0–100, the reasons, the skills you match and the ones to prepare.
- **Junk removed for free** — reposts, staffing agencies, excluded companies, too many applicants, too old or below
  your salary floor: never sent to the AI, never charged.
- **Sponsorship and clearance flags with the quoted sentence** — "We are unable to sponsor visas" is caught first.
- **Who to contact** — the poster's profile (else the company page) in `contactUrl`, plus a recruiter note and a
  cover-letter hook for strong and good matches.
- **Only new jobs on every run, in your inbox** — a daily schedule delivers and charges each job once, reposts
  included, and `notifyEmail` e-mails you the digest.
- **Ghost jobs flagged** — every job carries a `ghostJobRisk` with the reasons; `dropGhostJobs` removes the likely ones.

#### 🎯 Job match score against your resume

Paste your CV into `candidateProfile`, or link it in `candidateProfileUrl` (PDF, DOCX or text — your LinkedIn
profile's **More → Save to PDF** works). The free rules score must-have coverage, the description's skills your CV
states, title, seniority and freshness; with AI on, the model re-scores the close calls and explains each score.

#### 🛂 Visa sponsorship jobs and H-1B job alerts

`needsVisaSponsorship: true` drops every "unable to sponsor" / "U.S. citizens only" job and flags the ones that
sponsor, with the quoted sentence; `targetFlags: ["sponsorship_offered"]` keeps only those — the
[H-1B alert Task](#-try-it-for-your-niche) runs it every morning.

#### 🌍 Remote jobs — daily remote job alerts

`workplace: "remote"` is re-applied strictly on the returned fields (LinkedIn's AI search no longer does it
reliably); add `datePosted: "past24Hours"` and a salary floor for a daily alert.

#### 🎓 New-grad and entry-level jobs

`targetSeniority: ["Internship", "Entry level", "Associate"]` plus `excludeKeywords: ["senior", "5+ years"]` keeps the
jobs a graduate can land.

#### 👻 Ghost job detector

Reposted under a new id, open for 30+ days, 200+ applicants, no named poster: each signal is a point, and every row
gets `ghostJobRisk` (`low` / `medium` / `high`) with `ghostJobReasons`. `dropGhostJobs: true` drops the high ones
for free, before any AI call or charge.

#### ✉️ Recruiter note and cover letter generator

Strong and good matches get a ≤ 600-character note to the poster (reachable at `contactUrl`) and a cover-letter
opening, built only from `matchedSkills` and your CV — invented numbers, salary talk and placeholders are removed in code.

#### 👥 Several candidates in one run — for coaches and recruiters

Put a roster into `candidates` (`[{"name": …, "candidateProfile": …}, …]`): the search runs **once**, then each
candidate gets their own score, rows (`candidateName`), memory and `DIGEST` section — one event per job per candidate.

### 🆚 Why this instead of a LinkedIn Jobs Scraper?

| | [Linkedin Jobs Scraper (`curious_coder/linkedin-jobs-scraper`)](https://apify.com/curious_coder/linkedin-jobs-scraper) | **AI Job Match + LinkedIn Jobs Scraper** |
|---|---|---|
| **Price** | $0.002 per job row + $0.00005 per start · 17,864 users / 30 days | $0.002 per *matched* job (≈ $0.015 all-in with AI), first 25 free, no start fee |
| **What you pay for** | every row, reposts and agencies included | only jobs past your filters and minimum score |
| **Same 100 jobs, all in** | $0.20 for 100 raw rows you still read | $0.20 scraper + ≈ 25 × $0.01 + ≈ $0.16 tokens = **$0.61**, ranked with reasons and notes ($0.25 AI off) |
| **Filters after LinkedIn's AI search** | converted filters "can't guarantee that this 100% works" | seniority, type, remote, salary, applicants re-applied strictly |
| **Repeat runs** | dedupes only within one run | memory by job id **and** company + title + location, per candidate — reposts not charged twice |
| **Match to *your* CV** | none | 0–100 score, matched / missing skills, quoted requirements |
| **Sponsorship / clearance** | raw text | flags with the quoted sentence; "no sponsorship" dropped free |

**Other job sources buyers compare with:**

| Actor | What it delivers | Unit price | What this Actor adds |
|---|---|---|---|
| `valig/indeed-jobs-scraper` | raw Indeed rows, 3,890 users / 30 days | $0.0001 per row + $0.001 start | a per-CV score, flags, notes (Indeed source on the roadmap) |
| `fantastic-jobs/career-site-job-listing-api` | ATS postings with *global* AI filters | $0.012 per row + $0.01 start | a match against *your* CV at $0.01 per matched job |
| `curious_coder/linkedin-jobs-search-scraper` | classic filters, needs your LinkedIn cookies | $0.0015 per row + $0.005 start | no cookies — your account is never at risk |

### 💵 Pricing — what a run really costs

Pay per result: **one event per matched job, nothing else** — no start fee.

| Event | When it is charged | Price |
|---|---|---|
| `free-tier` | your first 25 matched jobs on this Actor, in any mode | **$0.00** |
| `qualified-job-basic` | AI off (or the AI failed) — normalised job, rule match score, skills, flags with evidence, contact link | **$0.002** |
| `qualified-job-ai` | AI on — everything above plus the AI score and reasons, quoted requirements, recruiter note, cover-letter hook | **$0.01** |

**AI tier, all in: ≈ $0.0148 per matched job** — the $0.01 event plus ≈ $0.0048 AI tokens billed to your Apify account
at OpenRouter rates (or to your own key): **2,164 tokens per job** (1,512 in / 652 out) measured in a local run, not
yet on Apify, priced at the default Claude Haiku 4.5.

**You are never charged for:** the scraping (billed by the source Actor), jobs below `minScore`, jobs that fail a
filter, duplicates and reposts, jobs you already received, or an AI fallback (charged as basic). Compute is included.

**How that compares** — `$0.002` per matched job is **1.7× cheaper** than the $0.0035 median unit price of the 10 job
Actors the Store lists next to this one for "ai job match" (checked 2026-09-25), and a matched job replaces the ≈ 4 raw
rows you would otherwise read — $0.0005 per raw row equivalent. Against the four LinkedIn / Indeed / ATS scrapers of
the research set ($0.00175 median per raw row) it is at parity.

**Worked example** (estimate until the first live run): 3 searches × 40 jobs = 120 scraped → ≈ 30 matched with AI on:
LinkedIn scraper $0.24 on your account + 30 × $0.01 = $0.30 here + ≈ 40 AI calls × $0.0048 = $0.19 tokens →
**≈ $0.73 total, $0.024 per matched job**. With AI off: $0.24 + 30 × $0.002 = **$0.30, $0.010 per matched job**. On your
first run 25 of those 30 are free. An API call that leaves the sizes out gets the same 40 jobs per search, capped at
$2 of scraping (`maxDiscoveryChargeUsd`; the form starts at $0.50).

### 🚀 How to use it

1. **Click `Try it`** — the form is pre-filled with 7 sample jobs and a sample CV; press **Start** (free, any plan).
2. **Switch the source** (`sourceMode`) to *Search LinkedIn*, type your own **Job search terms** (`searchKeywords`),
   **Location** and **Posted within** (`datePosted`).
3. **Paste your CV** into `candidateProfile` (or its link into `candidateProfileUrl`), set the filters that matter
   (`workplace`, `minSalary`, `needsVisaSponsorship`, `mustHaveSkills`) and your `minScore`.
4. **Open the dataset** — the Shortlist view lists the best matches first.

### 🤖 What the AI tier adds

The same job, AI **off** (`qualified-job-basic`, $0.002) — the demo run of `storage-example/INPUT.json`, 2026-09-25:

```json
{"title": "Senior Backend Engineer (Python)", "companyName": "Ledgerline", "matchScore": 91, "ruleScore": 91, "fitScore": null, "verdict": "strong", "label": "hot",
 "matchReasons": ["matches 2/2 must-have skills: Python, PostgreSQL", "you have 6 of the 7 skills the description names (missing: celery)", "2/3 nice-to-have skills mentioned", "title matches your search (100 %)"],
 "mustHaveRequirements": [], "recruiterNote": "", "coverLetterHook": "",
 "suggestedAction": "Apply — strong match (91/100); you match Python, PostgreSQL, Kubernetes, AWS; prepare for celery; posted 4 days ago with 58 applicants. Then message Maya R. (Head of Engineering), who posted it: https://www.linkedin.com/in/maya-r-sample-ledgerline."}
```

AI **on** (`qualified-job-ai`, ≈ $0.0148 all-in) — local run of `storage-example/INPUT.ai.json` (the form's sample
CV), 2026-09-25, with the open `gpt-oss-20b` model; on Apify the default Claude Haiku 4.5 fills the same fields.

```json
{"title": "Senior Backend Engineer (Python)", "companyName": "Ledgerline", "matchScore": 90, "ruleScore": 91, "fitScore": 90, "verdict": "strong", "label": "hot",
 "matchReasons": ["Candidate has 6 years of Python experience, exceeding the 5+ year requirement.", "Profile lists Django and PostgreSQL, matching the job’s required skills.", "Candidate’s AWS experience aligns with the job’s AWS requirement.", "Job offers H‑1B sponsorship, meeting the candidate’s visa need."],
 "mustHaveRequirements": ["5+ years of experience with Python and Django", "PostgreSQL", "AWS"],
 "recruiterNote": "Hello Maya, I’m excited about the Senior Backend Engineer role at Ledgerline. With 6 years of Python and Django experience, a strong background in PostgreSQL, and proven AWS deployments, I’m confident I can contribute to your accounting automation platform. Thank you for considering my application.",
 "coverLetterHook": "I am eager to bring my 6‑year background in Python/Django and AWS to Ledgerline’s accounting automation platform.",
 "suggestedAction": "Apply now and highlight your 6 years of Python/Django experience and AWS expertise."}
```

That is 10–15 minutes per job of reading and writing the first message — for ≈ $0.013 more per job, tokens
included. A job the AI scores below `minScore` is not delivered or charged.

![The Outreach view — who posted each job, the AI recruiter note and the cover-letter hook](https://api.apify.com/v2/key-value-stores/Ls1cTnQ9NhS2OiWp8/records/outreach.svg)

### ⚙️ Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `sourceMode` | `actor` | `dataset` | `list` | `actor` | Search LinkedIn, reuse a scraper dataset, or paste jobs (form: the free `list` demo). With nothing to search — `{}` over the API: no terms, URLs or CV — the free demo runs, nothing is charged and the scraper is never started |
| `searchKeywords` | string\[] | — | One LinkedIn search per term |
| `location` | string | `United States` | As typed on LinkedIn; empty = worldwide |
| `candidateProfile` / `candidateProfileUrl` | text / link | — | Your CV, pasted or as a PDF / DOCX / text link — every job is scored against it; with no term typed, its headline role is searched |
| `datePosted` | enum | `pastWeek` | `anyTime` · `past24Hours` (daily alerts) · `pastWeek` · `pastMonth` |
| `maxJobsPerSearch` | integer | `40` | Jobs scraped per term at $0.002, cut to fit the spend cap — the same for the form and the API |
| `maxDiscoveryChargeUsd` | number | `2` (form: `0.5`) | Hard cap on the scraper's charge to your account; an API call that omits it is capped at $2 |
| `minScore` | 0–100 | `60` | The only field that changes what you pay: below it = not delivered, not charged (first in the filter section) |
| `workplace` · `needsVisaSponsorship` · `minSalary` | enum · boolean · integer | `any` · `false` · `0` | Strict remote / hybrid / on-site filter · drop "no sponsorship" jobs · salary floor in `salaryCurrency` per `salaryPeriod` |
| `dropGhostJobs` | boolean | `false` | Drop jobs with a high ghost-job risk (free) |
| `enableAi` | boolean | `true` | AI match, requirements, note (needs a CV) |
| `candidates` | object\[] | — | A roster: one shared search, one score and memory per candidate |
| `dedupeAcrossRuns` | boolean | `true` | Only new jobs on every run, reposts included — kept per CV |
| `notifyEmail` | string | — | E-mail the run's digest (new jobs, top 10, links) after every run with new jobs |

<details>
<summary>Every other option and the flag names</summary>

More free filters: `mustHaveSkills`, `niceToHaveSkills`, `excludeKeywords`, `excludeCompanies`, `targetSeniority`,
`employmentTypes`, `maxApplicants`, `maxJobAgeDays`, `minCompanyEmployees` / `maxCompanyEmployees`,
`dropJobsWithoutSalary`, `excludeStaffingAgencies` (default `true`). AI: `generateRecruiterNote`, `noteTone`,
`llmProvider` + `llmApiKey`, `llmModel`. Output: `maxQualified` (default `100`), webhook. Advanced LinkedIn options
(`searchUrls`, `geoId`, `splitByLocation` past the 1,000-jobs cap) are in the **Input** tab.

**Flags** — put the value from the first column into `targetFlags` (the output key works too); an unknown name stops
the run at once with the list of valid ones.

| `targetFlags` value | Output key in `flags` | Meaning |
|---|---|---|
| `no_sponsorship` / `sponsorship_offered` | `noSponsorship` / `sponsorshipOffered` | the text says the employer will not / will sponsor a visa |
| `clearance_required` | `clearanceRequired` | a security clearance is required (−10 on the rule score) |
| `relocation_offered` | `relocationOffered` | relocation assistance is offered |
| `staffing_agency` | `staffingAgency` | a staffing / recruiting agency post (−10; dropped by default) |
| `language_required` | `languageRequired` | fluency in a specific language is required |

</details>

### 📤 Output

One dataset item per matched job — export as JSON, CSV or Excel, or stream it to a webhook. The top row of the demo
run (AI off):

```json
{
  "itemId": "42d5b06aab48", "jobId": "4301197264", "dedupeKey": "id:4301197264", "rank": 1,
  "url": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301197264",
  "title": "Senior Backend Engineer (Python)", "companyName": "Ledgerline", "workplace": "remote",
  "salaryMin": 150000, "salaryMax": 185000, "salaryCurrency": "USD", "jobAgeDays": 4, "applicants": 58,
  "ghostJobRisk": "low", "recruiterName": "Maya R.", "contactUrl": "https://www.linkedin.com/in/maya-r-sample-ledgerline",
  "matchScore": 91, "ruleScore": 91, "fitScore": null, "verdict": "strong", "label": "hot",
  "matchedSkills": ["Python", "PostgreSQL", "Kubernetes", "AWS", "django", "redis"], "missingSkills": ["celery"],
  "flagEvidence": ["We will sponsor H-1B transfers for the right candidate."],
  "aiUsed": false, "chargedEvent": "qualified-job-basic", "billedAs": "qualified-job-basic"
}
```

Dataset **views**: **Shortlist** (best first) · **Outreach** (poster, contact, note, hook) · **Requirements &
flags** (years, quoted must-haves, sponsorship evidence, ghost-job risk) · **Overview** (every column).

<details>
<summary>Every output field</summary>

| Field | Description |
|---|---|
| `itemId`, `jobId`, `dedupeKey` | Stable identity — safe as a primary key (`itemId` is per job and candidate in a roster run) |
| `candidateName` | The roster candidate the row is scored for; null for a single CV |
| `jobUrl`, `url`, `applyUrl` | The job page (tracking stripped) and the apply link |
| `title`, `companyName`, `companyLinkedinUrl`, `companyWebsite`, `companyLogo`, `companyEmployees` | Job and company |
| `location`, `workplace`, `seniority`, `employmentType`, `jobFunction`, `industries`, `benefits` | What kind of job |
| `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryPeriod`, `salaryText` | Parsed salary (hourly when under 1,000) |
| `postedAt`, `jobAgeDays`, `expiresAt`, `applicants` | Freshness and competition |
| `ghostJobRisk`, `ghostJobReasons` | Ghost-job risk (low / medium / high) and the signals behind it |
| `recruiterName`, `recruiterTitle`, `recruiterProfileUrl`, `contactUrl` | Who posted it and where to reach them (poster, else company page) |
| `descriptionSnippet` | First 400 characters of the description |
| `matchScore`, `ruleScore`, `fitScore`, `verdict`, `label`, `rank` | Final, rule and AI score; strong…weak; hot / warm / cold; position |
| `matchReasons`, `matchedSkills`, `missingSkills` | Why — every skill occurs in the description |
| `yearsRequired`, `mustHaveRequirements` | Requirements from the description (the quotes need the AI) |
| `flags`, `flagEvidence` | The six flags and their verbatim sentences |
| `recruiterNote`, `coverLetterHook` | AI texts, strong / good matches only; empty with AI off |
| `suggestedAction` | The next step with the contact link: the AI's, else the rule-based one on hot / warm jobs |
| `aiUsed`, `aiModel`, `chargedEvent`, `billedAs`, `source`, `searchQuery`, `scrapedAt` | Provenance and billing (`billedAs` = the tier, also on free rows) |

</details>

Every run that delivered writes a **`DIGEST`** (new jobs, top 10 with links, market report — e-mailed with
`notifyEmail`). `RUN_SUMMARY` (= `OUTPUT`) holds the funnel, charged events, `yieldByQuery`, `aiTokens`, `timing` and
the **`marketReport`** over every loaded job: median salary per term, most-asked skills and your most frequent gaps.

⭐ **Found it useful? A review on the Store helps others find it** — it takes a minute on the Actor's page.

### 🔁 Run it daily — LinkedIn job alerts

1. **Type your e-mail into `notifyEmail`** — after every run with new matches the digest (new jobs, top 10 with links
   and why they fit, the market report) lands in your inbox; no Slack or Zapier needed.
2. **Actions → Schedule** in the Console — daily at 7:00 with `datePosted: "past24Hours"`.
3. Keep `dedupeAcrossRuns: true` — jobs are remembered 60 days by id **and** company + title + location, so each run
   charges **only what is new**. The memory is kept **per CV**, so several candidates on one account never hide jobs
   from each other (`dedupeStoreName` keeps one memory across CV edits).
4. Send new matches to your **application tracker** (below) or Slack; the market report in `DIGEST` tells you what
   your market pays and asks for — worth a weekly run even once you have a job.

Daily cost for a real job hunt — 5 search terms × 25 jobs posted in the last 24 hours = 125 scraped ($0.25) → ≈ 15 new
matches × $0.01 + ≈ $0.10 tokens ≈ **$0.50 a day, ≈ $3.50 a week** (estimate), and 25 of the first matches are free.

#### 📋 A job application tracker that fills itself

Import `docs/tracker/job-application-tracker.csv` (Status, Applied on, Next follow-up, Notes + the Shortlist columns)
into Google Sheets, Notion or Airtable; **Integrations → Google Sheets** (or a Make / Zapier webhook) appends each new
job, keyed by `itemId`.

#### 🎯 Try it for your niche

A saved Task per use case (`storage-example/tasks/*.json`) — add your `notifyEmail`, run it once, then schedule it.

| Niche | What it looks for | Task |
|---|---|---|
| Remote Python job alerts (H-1B) | past 24 h, remote, ≥ $140k, sponsorship | `tasks/daily-remote-python-alerts.json` |
| H-1B / visa sponsorship job alerts | ML / data, only jobs that sponsor | `tasks/h1b-visa-sponsorship-job-alerts.json` |
| Remote job alerts in Europe | frontend, remote, ≥ €55k | `tasks/remote-europe-job-alerts.json` |
| New-grad software jobs | entry level, ≤ 200 applicants | `tasks/new-grad-software-jobs.json` |
| Career coach: junior data analysts | London, entry / associate, ≥ £28k | `tasks/career-coach-weekly-data-analyst.json` |
| Career coach: a roster | one search, a score per candidate | `tasks/career-coach-roster-weekly.json` |
| Recruiter: fintech PM roles | New York, no agencies, poster names | `tasks/recruiter-candidate-fit.json` |

### 🔌 Integrations, job search automation and API

- **E-mail** — `notifyEmail`; **Google Sheets / Slack** — the **Integrations** tab (Shortlist view / `DIGEST`).
- **Webhook** — `webhookUrl` POSTs `{"event": "job.qualified", "job": {…}, "runId": "…"}` per job to Zapier, Make, n8n
  or Notion, or with `webhookBatchSize` > 1 `{"event": "jobs.qualified", "jobs": [{…}, …], "runId": "…"}` per batch.
  A 429 / 5xx is retried once after 2 s; a failed POST is counted in `OUTPUT.webhook.failed`, never fails the run.
- **AI agents / MCP** — **first call = the free trial:** `{"sourceMode": "list", "itemsList": [...]}` matches the jobs
  you send with no scraper run, as the snippets below do. An empty `{}` runs the free demo.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("rich_minds/linkedin-job-match-ai").call(run_input={
    "sourceMode": "list",
    "itemsList": [{"id": "1", "title": "Backend Engineer", "descriptionText": "Python, PostgreSQL, AWS. 5+ years."}],
    "candidateProfile": "Backend engineer, 6 years of Python and PostgreSQL on AWS.",
    "minScore": 50,
    "maxDiscoveryChargeUsd": 0.5,  # spend cap on your account once you switch to "sourceMode": "actor"
}, timeout_secs=300)  # 1 job; for a live search size it as in the FAQ "How long does a run take?"
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["rank"], item["title"], item["matchScore"], item["verdict"])
```

<details>
<summary>The same call in JavaScript</summary>

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

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('rich_minds/linkedin-job-match-ai').call({
    sourceMode: 'list', itemsList: [{ id: '1', title: 'Backend Engineer', descriptionText: 'Python, AWS. 5+ years.' }],
    candidateProfile: 'Backend engineer, 6 years of Python on AWS.', minScore: 50, maxDiscoveryChargeUsd: 0.5,
}, { timeout: 300 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.map((i) => [i.rank, i.title, i.matchScore, i.verdict]));
```

</details>

**Use it from Claude, ChatGPT or any MCP client** — add Apify's MCP server with this Actor as a tool:

```json
{"mcpServers": {"apify": {"url": "https://mcp.apify.com/?actors=rich_minds/linkedin-job-match-ai"}}}
```

Then ask: *"Run linkedin-job-match-ai in `list` mode on these jobs with my CV (free), then search with
`sourceMode: actor` and `maxDiscoveryChargeUsd: 0.5`."*

#### Run outcomes — what your integration sees

<details>
<summary>All seven outcomes: run status, dataset, OUTPUT, charge</summary>

| Outcome | Run status | Dataset | `OUTPUT` | Charged? | What to do |
|---|---|---|---|---|---|
| Free demo (the pre-filled sample) | SUCCEEDED | 3 of 7 sample jobs | `demo: true` | no | switch the source, type your terms and CV |
| Success | SUCCEEDED | matched jobs, best first | funnel, `chargedEvents`, `marketReport` | per matched job | — |
| Nothing matched | SUCCEEDED | empty | `qualified: 0` | no | loosen `minScore` / filters |
| Demo text still in place | SUCCEEDED | empty | `inputNeeded` | no | replace the terms / CV the status names |
| Invalid input (unknown flag, unreadable CV link) | FAILED | empty | — / `inputNeeded` | no | fix the field the status names |
| Source failed | FAILED | empty | `sourceError` | no | follow the reason (plan, timeout) |
| AI unavailable (plan, key, rate limit) | SUCCEEDED | rule-scored jobs | `aiError`, `freeAiReserve` | your free jobs except 5 kept for the AI, then basic | `llmProvider: byok` |

</details>

### 👥 Who is it for?

| You are… | You run it to… | Start with |
|---|---|---|
| A job seeker (engineer, analyst, designer, PM) | get only new jobs that fit your CV every morning | the *Remote Python* Task: `past24Hours`, AI on |
| Someone who needs visa sponsorship | never apply to a "we cannot sponsor" job again | the *H-1B* Task: `needsVisaSponsorship: true` |
| A career coach, bootcamp or outplacement firm | rank each candidate's jobs weekly into their Notion / Airtable board | the *roster* Task: `candidates`, one memory per candidate |
| A recruiter or staffing team | find the roles a candidate fits, and who posted them | the *Recruiter* Task, Outreach view with `contactUrl` |
| An AI agent / job-search copilot | call "find jobs that fit this CV" as one MCP tool | `list` mode (free), then `actor` |

### 🧠 How the AI works

- **One typed call per job** returns the match score, the extracted requirements and the note + hook together. It
  sees your CV (≤ 2,000 characters), your skills, the job's fields and description (≤ 4,000 characters) and the rule
  findings.
- **Grounded, checked in code.** Skills only when the description names them; requirements, years and sponsorship
  only when quoted from the text; verdict from the score bands (≥ 80 strong, ≥ 65 good, ≥ 50 stretch); notes only for
  strong / good matches, minus any invented number, salary talk or placeholder.
- **Tokens only where they matter** — only jobs within 20 points of `minScore` reach the model.
- **No keys required.** Default `anthropic/claude-haiku-4.5` through Apify's model access; `llmProvider: "byok"` +
  `llmApiKey` for your own OpenAI / Anthropic / Gemini / Groq key, or any OpenRouter slug in `llmModel`.
- **Graceful fallback, one rule.** If the model fails — plan, key or rate limit alike — the job keeps its rule score,
  reasons, regex years and flags (`aiUsed: false`) and notes stay empty. It uses your free jobs except the last 5,
  which wait for a run where the AI works, and is then billed as basic.

### 🔒 Data, compliance and limits

- The source reads LinkedIn's **public, logged-out** job pages — no login, no cookies, your account is never touched.
- Your CV (pasted or linked) is used only for scoring, **never written to the dataset**; the poster's photo is dropped.
  A LinkedIn profile *page* needs a login and is not read — use its "Save to PDF" export.
- Limits: ≈ 1,000 jobs per LinkedIn search (`splitByLocation` gets past it); salary, applicants and poster are missing
  on many jobs; skill and flag rules are English (the AI reads any language); up to 50 candidates per roster run.
- Use the output within LinkedIn's terms and privacy law (GDPR, CCPA); contact posters only about their job.

### ❓ FAQ

**How much will one run cost me?** A 3-term search of 40 jobs each: $0.24 for the scraping on your account + $0.30
for ≈ 30 AI-matched jobs + ≈ $0.19 tokens ≈ $0.73 (≈ $0.30 with AI off). Filtered and below-score jobs cost nothing.

**What is an AI job match?** A 0–100 score of how well one job fits your CV, with the reasons, the skills you match
and the ones you miss — this Actor computes it for every LinkedIn job your search returns and keeps only the matches.

**Is this a LinkedIn jobs scraper?** Yes and more: it runs `curious_coder/linkedin-jobs-scraper` on your account, then
filters, dedupes and scores what it returns — you pay us only per matched job.

**Can it replace my LinkedIn job search?** It runs the same search and reads every result; scheduled, it is a job alert.

**How does resume job matching work here?** The rules match your CV's skills against each description with word
boundaries (Java never matches JavaScript); the AI scores the fit and cites the requirement or CV fact behind it.

**How is this different from Jobscan, Teal or Huntr?** Those are monthly seats (roughly $25–$50) where you paste each
job yourself. Here search, filters and scoring run on a schedule: 100 matched jobs with AI ≈ $1.50 all-in.

**What will my first real search cost?** 3 terms × 40 jobs ≈ $0.24 on your account, capped by
`maxDiscoveryChargeUsd` ($0.50 in the form); of ≈ 30 matched jobs the first 25 are free.

**How long does a run take?** Demo: 3 s (measured on Apify). AI, per job, measured: 14.6–28 s per call with a
provider key (local runs); Apify's model access has not been timed on the platform yet. With your own key calls run
2 at a time, then one at a time after a rate limit: a rate-limited platform run took 61 s per job. The rate-limit
backoff is capped at **120 s per run**, then the rest keep their rule score. Scraping ≈ 1–3 min per 40 jobs
(estimate). Size `timeoutSecs` for `.call()` as **terms × 180 + AI jobs × 15 + 120** (AI jobs ≈ a third of the jobs
scraped): the form's 3 × 40 search ≈ 540 + 600 + 120 = **1,260 s**; AI off, terms × 180 + 60. Every run
reports `sourceSecs`, `aiSecs`, `aiSecsPerUnit` and `aiBackoffSecs` in `OUTPUT.timing`.

**Which Apify plan do I need?** Any plan runs the demo and `list` / `dataset` modes. The live search and the built-in
AI need a plan that can run Store Actors; if yours cannot, the run stops at once with the reason and nothing is
charged. Your own key (`llmProvider: "byok"`) works on every plan.

**Can it spot ghost jobs?** Yes — the ghost job detector rates every posting: reposted, open 30+ days, 200+
applicants, no named poster. `ghostJobRisk` shows the level and reasons; `dropGhostJobs` drops the high ones for free.

**What happens if nothing matches my filters?** The run succeeds with 0 rows, free; `OUTPUT.stats` names the filter.

**What does "matched" mean?** A job that passed every free filter and whose final `matchScore` is at least your
`minScore` (default 60). Only matched jobs are charged.

**Will I be charged for the same job twice?** Not with `dedupeAcrossRuns` on (default): jobs are remembered 60 days
by id and by company + title + location. In a roster, one job for two candidates is two matched jobs.

**Is the data public / is this legal?** Yes — public, logged-out job listings; use them within LinkedIn's terms.

### 🧩 More Actors from the same developer

The same pay-per-qualified-result model:

- **[Linkedin Intent Leads](https://apify.com/rich_minds/linkedin-intent-leads)** — linkedin buying intent, linkedin intent signals, social selling
- **[Google Reviews Insights](https://apify.com/rich_minds/google-reviews-insights)** — google reviews analysis, reputation management, google maps reviews
- **[Local Business Lead](https://apify.com/rich_minds/local-business-lead)** — local business leads, google maps scraper, google maps email extractor
- **[Youtube Video Research Ai](https://apify.com/rich_minds/youtube-video-research-ai)** — youtube outlier videos, youtube video research, youtube competitor analysis

### 🆘 Support

Something missing or wrong? Open an issue on the Actor's page — buyer requests are shipped first.

### 📝 Changelog

One line per published build, newest first — `/actor-publish` adds it with the commit subject.

- **0.3** (2026-09-25) — `notifyEmail` e-mails the daily digest; ghost job detector (`ghostJobRisk`,
  `dropGhostJobs`); one free-reserve rule for every AI failure; a rate-limited AI stops after 120 s of backoff
  (`timing.aiBackoffSecs`); `minScore` leads the filter section.
- **0.2.2** (2026-09-25) — your own AI key (`llmProvider: byok`) runs 2 calls at a time and one at a time after a rate
  limit, so a free-tier key still scores the sample; the rate-limit message names `llmApiKey` / `llmModel`.
- **0.2** (2026-09-25) — roster of candidates, CV from a link, `contactUrl`, market report, dedupe memory per CV.
- **0.1.1** / **0.1** (2026-09-25) — real Actor handle in the snippets · initial release.

**Next:** Indeed as a second source · an "AI included" tier (tokens paid by us) · the hiring manager's e-mail for
strong matches · a cohort report for coaches · tailored CV bullets for strong matches.

# Actor input Schema

## `sourceMode` (type: `string`):

<b>Search LinkedIn</b> — runs <code>curious\_coder/linkedin-jobs-scraper</code> on your account for the search terms below (about $0.002 per job scraped, billed by that Actor; needs an Apify plan that runs Store Actors — if yours cannot, the run stops at once and nothing is charged). <b>Existing dataset</b> — match the jobs of an earlier run (no new scraping cost). <b>Paste jobs</b> — the free demo: the sample jobs below, or your own list. An API call that names nothing to search (<code>{}</code>: no search terms, URLs or CV) runs the free demo on the sample jobs instead — nothing is charged and the source Actor is never started.

## `searchKeywords` (type: `array`):

One LinkedIn job search per term (job title, skill or both, e.g. <i>python developer</i>). Each search returns up to <b>Jobs per search</b> jobs.

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

City, region or country as you would type it on LinkedIn (e.g. <i>United States</i>, <i>London, United Kingdom</i>, <i>Remote</i>). Empty = worldwide.

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

Only jobs posted in this window. <b>Past 24 hours</b> is the daily-alert setting.

## `maxJobsPerSearch` (type: `integer`):

How many jobs each search term scrapes (the source's <code>limitPerSource</code>, $0.002 each on your account). Cut automatically so all searches stay inside <b>Max source spend</b>.

## `maxDiscoveryChargeUsd` (type: `number`):

Hard cap on what the LinkedIn scraper may charge your account in <b>Search LinkedIn</b> mode — the form starts at $0.50, so your first real search can never cost more. An API or agent call that leaves it out is capped at $2 per run; raise it for bigger searches.

## `candidateProfile` (type: `string`):

Paste your CV summary or LinkedIn About: skills, years of experience, target roles, visa needs. The rules pull your skills from it and the AI scores every job against it. It is only sent to the model — never written to the dataset.

## `candidateProfileUrl` (type: `string`):

Instead of pasting: a public link to your CV as PDF, DOCX or text — e.g. your LinkedIn profile saved as PDF (profile → <b>More → Save to PDF</b>) uploaded to an Apify key-value store on your account or any file host. Its text is read at the start of the run and added to <b>Your CV / profile</b>. A LinkedIn profile page itself needs a login and cannot be read.

## `minScore` (type: `integer`):

The only field that changes what you pay: jobs whose final match score is below this are dropped and <b>not charged</b>. Raise it to pay only for the strongest matches, lower it to see more. 80+ = strong, 65+ = good, 50+ = stretch.

## `needsVisaSponsorship` (type: `boolean`):

Drop jobs whose description says the employer will not sponsor a visa ("unable to sponsor", "no sponsorship", "U.S. citizens only"); the sentence is kept as evidence. The AI also weighs it.

## `workplace` (type: `string`):

Keep only remote, hybrid or on-site jobs (from LinkedIn's workplace type; unknown ones are kept).

## `mustHaveSkills` (type: `array`):

Skills the job should ask for (word-boundary match: <i>Java</i> never matches <i>JavaScript</i>). They weigh most in the match score and fill <code>matchedSkills</code>.

## `niceToHaveSkills` (type: `array`):

Skills that raise the score when the job mentions them.

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

Drop every job whose title or description mentions one of these (e.g. <i>unpaid</i>, <i>commission only</i>, <i>clearance</i>).

## `targetSeniority` (type: `array`):

Keep only these LinkedIn seniority levels: <i>Internship</i>, <i>Entry level</i>, <i>Associate</i>, <i>Mid-Senior level</i>, <i>Director</i>, <i>Executive</i> (jobs without a level are kept). LinkedIn's new AI search no longer filters this reliably — this is the strict post-filter.

## `employmentTypes` (type: `array`):

Keep only these employment types: <i>Full-time</i>, <i>Part-time</i>, <i>Contract</i>, <i>Temporary</i>, <i>Internship</i> (jobs without one are kept).

## `minSalary` (type: `integer`):

Drop jobs whose stated top salary is below this (in <b>Salary currency</b> per <b>Salary period</b>; hourly and yearly are converted at 2,080 hours). Jobs without a salary are kept unless you tick the box below. 0 = off.

## `salaryCurrency` (type: `string`):

ISO code of your salary floor, e.g. USD, EUR, GBP. Jobs paid in another currency are not compared.

## `salaryPeriod` (type: `string`):

The period of your salary floor.

## `dropJobsWithoutSalary` (type: `boolean`):

Only with a salary floor: also drop jobs that state no salary.

## `maxApplicants` (type: `integer`):

Drop jobs that already have more applicants than this. 0 = off.

## `maxJobAgeDays` (type: `integer`):

Drop jobs posted more than this many days ago. 0 = off.

## `dropGhostJobs` (type: `boolean`):

Drop postings with a <b>high</b> ghost-job risk — at least three points from: reposted under a new job id, open for 30+ days (60+ counts double), 200+ applicants, no named poster. Every delivered job carries <code>ghostJobRisk</code> (low / medium / high) and its reasons either way.

## `excludeCompanies` (type: `array`):

Company names to never show (your current employer, companies you already applied to).

## `excludeStaffingAgencies` (type: `boolean`):

Drop jobs posted by staffing / recruiting agencies (company name, industry or "our client" wording).

## `minCompanyEmployees` (type: `integer`):

Drop companies smaller than this (when LinkedIn states the size). 0 = off.

## `maxCompanyEmployees` (type: `integer`):

Drop companies larger than this (when LinkedIn states the size). 0 = off.

## `enableAi` (type: `boolean`):

Score each job against your CV with grounded reasons, extract its real requirements (years, must-haves, sponsorship with the quoted sentence) and draft a note to the poster plus a cover-letter hook for strong and good matches. Needs <b>Your CV / profile</b>. Off = rule-based score only (cheaper).

## `generateRecruiterNote` (type: `boolean`):

For strong and good matches only; greets the poster by name when LinkedIn shows one. Off = score and requirements only.

## `noteTone` (type: `string`):

How the recruiter note sounds.

## `llmProvider` (type: `string`):

<b>Apify (no keys)</b> — the AI runs through Apify's built-in OpenRouter proxy on plans that can run Store Actors; tokens are billed to your Apify account at OpenRouter's rates. <b>My own key</b> — use your OpenAI / Anthropic / Gemini / Groq key instead (works on every plan).

## `llmApiKey` (type: `string`):

Required when <b>AI model access</b> is <i>My own API key</i>. Stored encrypted by Apify, never logged.

## `maxQualified` (type: `integer`):

Hard cap on results (and therefore on what you pay for). The best matches are output first.

## `candidates` (type: `array`):

Score one search for a whole roster: a JSON array, one object per candidate with <code>name</code> and <code>candidateProfile</code> (or <code>candidateProfileUrl</code>), optionally their own <code>searchKeywords</code>, <code>mustHaveSkills</code>, <code>niceToHaveSkills</code>, <code>targetSeniority</code>, <code>workplace</code>, <code>minSalary</code>, <code>needsVisaSponsorship</code>, <code>minScore</code>, <code>maxQualified</code> … Every term is searched once for all; each candidate gets their own score, rows (<code>candidateName</code>), memory of jobs already received and DIGEST section. One matched-job event per job per candidate. Leave empty for your own search.

## `dedupeAcrossRuns` (type: `boolean`):

Remembers every job you received — by LinkedIn id and by company + title + location, so reposts are caught — in a named key-value store on your account for 60 days, and skips them next time. Keep it on for a daily schedule.

## `notifyEmail` (type: `string`):

After every run with at least one new matched job, the run's digest (how many are new, the top 10 with links and why they match, the market report) is e-mailed here through Apify's send-mail Actor. Schedule the run daily and the jobs come to your inbox — no Slack or Zapier needed. Never sent for the free demo.

## `webhookUrl` (type: `string`):

Matched jobs are POSTed here as JSON (Zapier, Make, n8n, Slack, Notion, Airtable). For Google Sheets you can also use Apify's Integrations tab.

## `webhookBatchSize` (type: `integer`):

1 = one POST per job the moment it is ready. Higher = one POST per N jobs.

## `searchUrls` (type: `array`):

Public LinkedIn job-search URLs (open linkedin.com/jobs/search in a private window, set the filters, copy the URL). Searched in one extra run next to the search terms.

## `geoId` (type: `string`):

Precise location id from a LinkedIn search URL (<code>geoId=</code>). Overrides the free-text location when LinkedIn resolves it.

## `distance` (type: `integer`):

Search radius around the location. 0 = LinkedIn's default.

## `companyIds` (type: `array`):

LinkedIn numeric company ids (from a company URL or <code>f\_C=</code> in a search URL), e.g. 1441 for Google.

## `under10Applicants` (type: `boolean`):

Ask LinkedIn for early-bird jobs only.

## `splitByLocation` (type: `boolean`):

Gets past LinkedIn's 1,000-jobs-per-search cap by searching each city of <b>Split country</b> separately (more jobs, more source cost).

## `splitCountry` (type: `string`):

Two-letter country code whose cities are searched, e.g. US, GB, DE. Only with <b>Split the search by city</b>.

## `discoveryActorId` (type: `string`):

Actor used in <b>Search LinkedIn</b> mode. Any Actor whose output has the fields listed in the README works.

## `discoveryInput` (type: `object`):

Merged over the input built from the fields above and passed to the source Actor as-is — for options this form does not show. See the source Actor's input schema.

## `itemsList` (type: `array`):

Only for <b>Paste jobs</b> mode. JSON array of jobs in the shape of <code>curious\_coder/linkedin-jobs-scraper</code> (at least <code>title</code>; <code>id</code>, <code>link</code>, <code>companyName</code>, <code>descriptionText</code> … as in its output).

## `datasetId` (type: `string`):

Only for <b>Existing dataset</b> mode. Pick a dataset of an earlier <code>curious\_coder/linkedin-jobs-scraper</code> run so the Actor is granted read access to it.

## `llmModel` (type: `string`):

Leave empty for the default (<code>anthropic/claude-haiku-4.5</code>). Apify mode takes an OpenRouter slug such as <code>openai/gpt-4.1-mini</code>; own-key mode takes <code>provider:model</code>, e.g. <code>anthropic:claude-haiku-4-5-20251001</code>.

## `aiCandidateMultiplier` (type: `integer`):

How many of the best rule-scored jobs get the AI pass, as a multiple of <b>Max matched jobs</b> (only jobs within 20 points of the minimum score). Higher = more thorough, slower, more tokens.

## `targetFlags` (type: `array`):

Only deliver jobs with at least one of these flags: <code>sponsorship\_offered</code>, <code>no\_sponsorship</code>, <code>clearance\_required</code>, <code>relocation\_offered</code>, <code>staffing\_agency</code>, <code>language\_required</code> (the camelCase output keys such as <code>sponsorshipOffered</code> work too). An unknown name stops the run at once with the list of valid ones.

## `suppressionList` (type: `array`):

LinkedIn job ids, job URLs or exact titles to never output. Skipped before any processing and never charged.

## `maxToProcess` (type: `integer`):

Upper bound on how many jobs pass the free filters and get scored in one run (controls run time). Default = 3 × max matched.

## `dedupeStoreName` (type: `string`):

Key-value store used for cross-run memory. Left at the default, the memory is kept per CV: another <code>candidateProfile</code> (another candidate) starts its own list, so one candidate never hides jobs from another. Type your own name to keep one memory across CV edits, or one per campaign.

## `webhookHeaders` (type: `object`):

Extra HTTP headers for the webhook, e.g. <code>{"Authorization": "Bearer …"}</code>.

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

Not needed: the source Actor handles LinkedIn's anti-blocking on its side.

## Actor input object example

```json
{
  "sourceMode": "list",
  "searchKeywords": [
    "python developer",
    "backend engineer python",
    "platform engineer"
  ],
  "location": "United States",
  "datePosted": "pastWeek",
  "maxJobsPerSearch": 40,
  "maxDiscoveryChargeUsd": 0.5,
  "candidateProfile": "Backend engineer, 6 years of experience. Python (Django, FastAPI), PostgreSQL, Redis, Docker, Kubernetes and AWS. Built REST and GraphQL APIs for a fintech payments platform serving 2M users; led a team of 4. Looking for a senior backend or platform role, remote or hybrid in the US. Needs H-1B visa sponsorship.",
  "minScore": 60,
  "needsVisaSponsorship": false,
  "workplace": "any",
  "minSalary": 0,
  "salaryCurrency": "USD",
  "salaryPeriod": "year",
  "dropJobsWithoutSalary": false,
  "maxApplicants": 0,
  "maxJobAgeDays": 0,
  "dropGhostJobs": false,
  "excludeStaffingAgencies": true,
  "minCompanyEmployees": 0,
  "maxCompanyEmployees": 0,
  "enableAi": true,
  "generateRecruiterNote": true,
  "noteTone": "professional",
  "llmProvider": "apify",
  "maxQualified": 100,
  "dedupeAcrossRuns": true,
  "webhookBatchSize": 1,
  "distance": 0,
  "under10Applicants": false,
  "splitByLocation": false,
  "discoveryActorId": "curious_coder/linkedin-jobs-scraper",
  "discoveryInput": {},
  "itemsList": [
    {
      "id": "4301187710",
      "link": "https://www.linkedin.com/jobs/view/staff-software-engineer-apis-at-orbital-freight-4301187710?refId=abc123&trackingId=xyz789&position=1&pageNum=0",
      "title": "Staff Software Engineer, APIs",
      "companyName": "Orbital Freight",
      "companyLinkedinUrl": "https://www.linkedin.com/company/orbital-freight?trk=public_jobs_topcard-org-name",
      "companyWebsite": "https://orbitalfreight.example",
      "companyEmployeesCount": 420,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "workRemoteAllowed": true,
      "salaryInfo": [
        "$170,000.00/yr",
        "$210,000.00/yr"
      ],
      "postedAt": "2026-09-22",
      "applicantsCount": "34",
      "applyUrl": "https://careers.orbitalfreight.example/jobs/staff-software-engineer-apis",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "jobFunction": "Engineering and Information Technology",
      "industries": "Transportation, Logistics, Supply Chain and Storage",
      "benefits": [
        "Medical insurance",
        "401(k)"
      ],
      "jobPosterName": "Daniel K.",
      "jobPosterTitle": "Engineering Manager, Platform APIs",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/daniel-k-sample-orbital",
      "descriptionText": "Orbital Freight moves 40,000 shipments a day through our APIs. We are hiring a Staff Software Engineer to own the public shipment and pricing APIs.\nWhat you will do:\n- Design and ship REST and GraphQL APIs in Python (FastAPI) backed by PostgreSQL and Redis\n- Run services on Docker and Kubernetes in AWS\n- Mentor a team of 5 engineers\nRequirements:\n- 6+ years of professional experience building backend services in Python\n- Deep knowledge of PostgreSQL and API design\nNice to have: Kafka, Terraform.\nVisa sponsorship is available for this role. We are a remote-first company across US time zones."
    },
    {
      "id": "4301190022",
      "link": "https://www.linkedin.com/jobs/view/senior-python-engineer-data-platform-at-tidewater-analytics-4301190022?refId=def456&position=2&pageNum=0",
      "title": "Senior Python Engineer - Data Platform",
      "companyName": "Tidewater Analytics",
      "companyLinkedinUrl": "https://www.linkedin.com/company/tidewater-analytics",
      "companyEmployeesCount": 180,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "salaryInfo": [
        "$140,000.00/yr",
        "$170,000.00/yr"
      ],
      "postedAt": "2026-09-20",
      "applicantsCount": "Over 200 applicants",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Software Development",
      "jobPosterName": "Priya S.",
      "jobPosterTitle": "Technical Recruiter",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/priya-s-sample-tidewater",
      "descriptionText": "Join the data platform team behind our retail forecasting product.\nYou will build batch and streaming pipelines in Python with Airflow, Spark and dbt on Snowflake, and expose results through internal APIs built with FastAPI.\nRequirements: 5+ years of experience with Python and SQL; experience with Airflow or a similar orchestrator; AWS.\nNice to have: Kubernetes, Terraform.\nWe offer relocation assistance to our Denver hub for those who want it, but the role is fully remote."
    },
    {
      "id": "4301191508",
      "link": "https://www.linkedin.com/jobs/view/platform-engineer-at-northpeak-health-4301191508?refId=ghi789&position=3&pageNum=0",
      "title": "Platform Engineer",
      "companyName": "Northpeak Health",
      "companyLinkedinUrl": "https://www.linkedin.com/company/northpeak-health-sample",
      "companyEmployeesCount": 2300,
      "location": "Boston, MA",
      "workplaceTypes": [
        "Hybrid"
      ],
      "salaryInfo": [
        "$155,000.00/yr",
        "$185,000.00/yr"
      ],
      "postedAt": "2026-09-23",
      "applicantsCount": "Be among the first 25 applicants",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Hospitals and Health Care",
      "descriptionText": "Build the internal developer platform for 300 engineers: Kubernetes, Terraform, AWS, Python and Go tooling, CI/CD with GitHub Actions.\nRequirements: 5+ years of experience in platform or infrastructure engineering.\nApplicants must be authorized to work in the U.S. We are unable to sponsor visas for this position."
    },
    {
      "id": "4301193377",
      "link": "https://www.linkedin.com/jobs/view/python-developer-at-brightwave-staffing-4301193377?position=4&pageNum=0",
      "title": "Python Developer",
      "companyName": "Brightwave Staffing Group",
      "location": "Austin, TX",
      "workplaceTypes": [
        "On-site"
      ],
      "salaryInfo": [
        "$55.00/hr",
        "$65.00/hr"
      ],
      "postedAt": "2026-09-24",
      "applicantsCount": "12",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Contract",
      "industries": "Staffing and Recruiting",
      "descriptionText": "Our client, a Fortune 500 insurer, is looking for a Python Developer for a 6-month W2 contract. Python, Django, PostgreSQL required. C2C not available."
    },
    {
      "id": "4301195840",
      "link": "https://www.linkedin.com/jobs/view/backend-engineer-payments-at-corvid-pay-4301195840?position=5&pageNum=0",
      "title": "Backend Engineer, Payments",
      "companyName": "Corvid Pay",
      "companyLinkedinUrl": "https://www.linkedin.com/company/corvid-pay-sample",
      "companyEmployeesCount": 95,
      "location": "New York, NY",
      "workplaceTypes": [
        "On-site"
      ],
      "postedAt": "2026-09-18",
      "applicantsCount": "87",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Financial Services",
      "descriptionText": "Corvid Pay is building card issuing for small banks. You will write Java services with Spring Boot and Kafka and own our ledger.\nRequirements: 4+ years of experience with Java or Kotlin; experience with payments or ledgers.\nOffice-based in Manhattan five days a week."
    },
    {
      "id": "4301197264",
      "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301197264?refId=jkl012&position=6&pageNum=0",
      "title": "Senior Backend Engineer (Python)",
      "companyName": "Ledgerline",
      "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
      "companyWebsite": "https://ledgerline.example",
      "companyEmployeesCount": 260,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "salaryInfo": [
        "$150,000.00/yr",
        "$185,000.00/yr"
      ],
      "postedAt": "2026-09-21",
      "applicantsCount": "58",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Financial Services",
      "jobPosterName": "Maya R.",
      "jobPosterTitle": "Head of Engineering",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/maya-r-sample-ledgerline",
      "descriptionText": "Ledgerline builds accounting automation for 9,000 small businesses.\nYou will design Django services and REST APIs on PostgreSQL, run them on AWS, and improve our payments reconciliation.\nRequirements: 5+ years of experience with Python and Django; PostgreSQL; AWS.\nNice to have: Celery, Redis, Kubernetes.\nWe will sponsor H-1B transfers for the right candidate."
    },
    {
      "id": "4301199931",
      "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301199931?position=7&pageNum=0",
      "title": "Senior Backend Engineer (Python)",
      "companyName": "Ledgerline, Inc.",
      "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "postedAt": "2026-09-24",
      "applicantsCount": "3",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "descriptionText": "Reposted. Ledgerline builds accounting automation for small businesses. Python, Django, PostgreSQL, AWS."
    }
  ],
  "aiCandidateMultiplier": 2,
  "dedupeStoreName": "linkedin-job-match-ai-seen",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `qualified` (type: `string`):

All matched jobs as JSON, best match first.

## `sheet` (type: `string`):

The same jobs as a spreadsheet.

## `runSummary` (type: `string`):

JSON record with the funnel (loaded -> dropped by each free filter -> AI-matched -> matched), charged events by type, free-tier jobs used and remaining, per-search-term yield, whether a budget limit was reached, webhook delivery counts and the dedupe store size.

## `digest` (type: `string`):

The new matches of this run as a short Markdown list with links — point a Slack or e-mail integration at it.

# 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 = {
    "sourceMode": "list",
    "searchKeywords": [
        "python developer",
        "backend engineer python",
        "platform engineer"
    ],
    "maxJobsPerSearch": 40,
    "maxDiscoveryChargeUsd": 0.5,
    "candidateProfile": "Backend engineer, 6 years of experience. Python (Django, FastAPI), PostgreSQL, Redis, Docker, Kubernetes and AWS. Built REST and GraphQL APIs for a fintech payments platform serving 2M users; led a team of 4. Looking for a senior backend or platform role, remote or hybrid in the US. Needs H-1B visa sponsorship.",
    "discoveryInput": {},
    "itemsList": [
        {
            "id": "4301187710",
            "link": "https://www.linkedin.com/jobs/view/staff-software-engineer-apis-at-orbital-freight-4301187710?refId=abc123&trackingId=xyz789&position=1&pageNum=0",
            "title": "Staff Software Engineer, APIs",
            "companyName": "Orbital Freight",
            "companyLinkedinUrl": "https://www.linkedin.com/company/orbital-freight?trk=public_jobs_topcard-org-name",
            "companyWebsite": "https://orbitalfreight.example",
            "companyEmployeesCount": 420,
            "location": "United States (Remote)",
            "workplaceTypes": [
                "Remote"
            ],
            "workRemoteAllowed": true,
            "salaryInfo": [
                "$170,000.00/yr",
                "$210,000.00/yr"
            ],
            "postedAt": "2026-09-22",
            "applicantsCount": "34",
            "applyUrl": "https://careers.orbitalfreight.example/jobs/staff-software-engineer-apis",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "jobFunction": "Engineering and Information Technology",
            "industries": "Transportation, Logistics, Supply Chain and Storage",
            "benefits": [
                "Medical insurance",
                "401(k)"
            ],
            "jobPosterName": "Daniel K.",
            "jobPosterTitle": "Engineering Manager, Platform APIs",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/daniel-k-sample-orbital",
            "descriptionText": "Orbital Freight moves 40,000 shipments a day through our APIs. We are hiring a Staff Software Engineer to own the public shipment and pricing APIs.\nWhat you will do:\n- Design and ship REST and GraphQL APIs in Python (FastAPI) backed by PostgreSQL and Redis\n- Run services on Docker and Kubernetes in AWS\n- Mentor a team of 5 engineers\nRequirements:\n- 6+ years of professional experience building backend services in Python\n- Deep knowledge of PostgreSQL and API design\nNice to have: Kafka, Terraform.\nVisa sponsorship is available for this role. We are a remote-first company across US time zones."
        },
        {
            "id": "4301190022",
            "link": "https://www.linkedin.com/jobs/view/senior-python-engineer-data-platform-at-tidewater-analytics-4301190022?refId=def456&position=2&pageNum=0",
            "title": "Senior Python Engineer - Data Platform",
            "companyName": "Tidewater Analytics",
            "companyLinkedinUrl": "https://www.linkedin.com/company/tidewater-analytics",
            "companyEmployeesCount": 180,
            "location": "United States (Remote)",
            "workplaceTypes": [
                "Remote"
            ],
            "salaryInfo": [
                "$140,000.00/yr",
                "$170,000.00/yr"
            ],
            "postedAt": "2026-09-20",
            "applicantsCount": "Over 200 applicants",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Software Development",
            "jobPosterName": "Priya S.",
            "jobPosterTitle": "Technical Recruiter",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/priya-s-sample-tidewater",
            "descriptionText": "Join the data platform team behind our retail forecasting product.\nYou will build batch and streaming pipelines in Python with Airflow, Spark and dbt on Snowflake, and expose results through internal APIs built with FastAPI.\nRequirements: 5+ years of experience with Python and SQL; experience with Airflow or a similar orchestrator; AWS.\nNice to have: Kubernetes, Terraform.\nWe offer relocation assistance to our Denver hub for those who want it, but the role is fully remote."
        },
        {
            "id": "4301191508",
            "link": "https://www.linkedin.com/jobs/view/platform-engineer-at-northpeak-health-4301191508?refId=ghi789&position=3&pageNum=0",
            "title": "Platform Engineer",
            "companyName": "Northpeak Health",
            "companyLinkedinUrl": "https://www.linkedin.com/company/northpeak-health-sample",
            "companyEmployeesCount": 2300,
            "location": "Boston, MA",
            "workplaceTypes": [
                "Hybrid"
            ],
            "salaryInfo": [
                "$155,000.00/yr",
                "$185,000.00/yr"
            ],
            "postedAt": "2026-09-23",
            "applicantsCount": "Be among the first 25 applicants",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Hospitals and Health Care",
            "descriptionText": "Build the internal developer platform for 300 engineers: Kubernetes, Terraform, AWS, Python and Go tooling, CI/CD with GitHub Actions.\nRequirements: 5+ years of experience in platform or infrastructure engineering.\nApplicants must be authorized to work in the U.S. We are unable to sponsor visas for this position."
        },
        {
            "id": "4301193377",
            "link": "https://www.linkedin.com/jobs/view/python-developer-at-brightwave-staffing-4301193377?position=4&pageNum=0",
            "title": "Python Developer",
            "companyName": "Brightwave Staffing Group",
            "location": "Austin, TX",
            "workplaceTypes": [
                "On-site"
            ],
            "salaryInfo": [
                "$55.00/hr",
                "$65.00/hr"
            ],
            "postedAt": "2026-09-24",
            "applicantsCount": "12",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Contract",
            "industries": "Staffing and Recruiting",
            "descriptionText": "Our client, a Fortune 500 insurer, is looking for a Python Developer for a 6-month W2 contract. Python, Django, PostgreSQL required. C2C not available."
        },
        {
            "id": "4301195840",
            "link": "https://www.linkedin.com/jobs/view/backend-engineer-payments-at-corvid-pay-4301195840?position=5&pageNum=0",
            "title": "Backend Engineer, Payments",
            "companyName": "Corvid Pay",
            "companyLinkedinUrl": "https://www.linkedin.com/company/corvid-pay-sample",
            "companyEmployeesCount": 95,
            "location": "New York, NY",
            "workplaceTypes": [
                "On-site"
            ],
            "postedAt": "2026-09-18",
            "applicantsCount": "87",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Financial Services",
            "descriptionText": "Corvid Pay is building card issuing for small banks. You will write Java services with Spring Boot and Kafka and own our ledger.\nRequirements: 4+ years of experience with Java or Kotlin; experience with payments or ledgers.\nOffice-based in Manhattan five days a week."
        },
        {
            "id": "4301197264",
            "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301197264?refId=jkl012&position=6&pageNum=0",
            "title": "Senior Backend Engineer (Python)",
            "companyName": "Ledgerline",
            "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
            "companyWebsite": "https://ledgerline.example",
            "companyEmployeesCount": 260,
            "location": "United States (Remote)",
            "workplaceTypes": [
                "Remote"
            ],
            "salaryInfo": [
                "$150,000.00/yr",
                "$185,000.00/yr"
            ],
            "postedAt": "2026-09-21",
            "applicantsCount": "58",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Financial Services",
            "jobPosterName": "Maya R.",
            "jobPosterTitle": "Head of Engineering",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/maya-r-sample-ledgerline",
            "descriptionText": "Ledgerline builds accounting automation for 9,000 small businesses.\nYou will design Django services and REST APIs on PostgreSQL, run them on AWS, and improve our payments reconciliation.\nRequirements: 5+ years of experience with Python and Django; PostgreSQL; AWS.\nNice to have: Celery, Redis, Kubernetes.\nWe will sponsor H-1B transfers for the right candidate."
        },
        {
            "id": "4301199931",
            "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301199931?position=7&pageNum=0",
            "title": "Senior Backend Engineer (Python)",
            "companyName": "Ledgerline, Inc.",
            "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
            "location": "United States (Remote)",
            "workplaceTypes": [
                "Remote"
            ],
            "postedAt": "2026-09-24",
            "applicantsCount": "3",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "descriptionText": "Reposted. Ledgerline builds accounting automation for small businesses. Python, Django, PostgreSQL, AWS."
        }
    ],
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("rich_minds/linkedin-job-match-ai").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 = {
    "sourceMode": "list",
    "searchKeywords": [
        "python developer",
        "backend engineer python",
        "platform engineer",
    ],
    "maxJobsPerSearch": 40,
    "maxDiscoveryChargeUsd": 0.5,
    "candidateProfile": "Backend engineer, 6 years of experience. Python (Django, FastAPI), PostgreSQL, Redis, Docker, Kubernetes and AWS. Built REST and GraphQL APIs for a fintech payments platform serving 2M users; led a team of 4. Looking for a senior backend or platform role, remote or hybrid in the US. Needs H-1B visa sponsorship.",
    "discoveryInput": {},
    "itemsList": [
        {
            "id": "4301187710",
            "link": "https://www.linkedin.com/jobs/view/staff-software-engineer-apis-at-orbital-freight-4301187710?refId=abc123&trackingId=xyz789&position=1&pageNum=0",
            "title": "Staff Software Engineer, APIs",
            "companyName": "Orbital Freight",
            "companyLinkedinUrl": "https://www.linkedin.com/company/orbital-freight?trk=public_jobs_topcard-org-name",
            "companyWebsite": "https://orbitalfreight.example",
            "companyEmployeesCount": 420,
            "location": "United States (Remote)",
            "workplaceTypes": ["Remote"],
            "workRemoteAllowed": True,
            "salaryInfo": [
                "$170,000.00/yr",
                "$210,000.00/yr",
            ],
            "postedAt": "2026-09-22",
            "applicantsCount": "34",
            "applyUrl": "https://careers.orbitalfreight.example/jobs/staff-software-engineer-apis",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "jobFunction": "Engineering and Information Technology",
            "industries": "Transportation, Logistics, Supply Chain and Storage",
            "benefits": [
                "Medical insurance",
                "401(k)",
            ],
            "jobPosterName": "Daniel K.",
            "jobPosterTitle": "Engineering Manager, Platform APIs",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/daniel-k-sample-orbital",
            "descriptionText": """Orbital Freight moves 40,000 shipments a day through our APIs. We are hiring a Staff Software Engineer to own the public shipment and pricing APIs.
What you will do:
- Design and ship REST and GraphQL APIs in Python (FastAPI) backed by PostgreSQL and Redis
- Run services on Docker and Kubernetes in AWS
- Mentor a team of 5 engineers
Requirements:
- 6+ years of professional experience building backend services in Python
- Deep knowledge of PostgreSQL and API design
Nice to have: Kafka, Terraform.
Visa sponsorship is available for this role. We are a remote-first company across US time zones.""",
        },
        {
            "id": "4301190022",
            "link": "https://www.linkedin.com/jobs/view/senior-python-engineer-data-platform-at-tidewater-analytics-4301190022?refId=def456&position=2&pageNum=0",
            "title": "Senior Python Engineer - Data Platform",
            "companyName": "Tidewater Analytics",
            "companyLinkedinUrl": "https://www.linkedin.com/company/tidewater-analytics",
            "companyEmployeesCount": 180,
            "location": "United States (Remote)",
            "workplaceTypes": ["Remote"],
            "salaryInfo": [
                "$140,000.00/yr",
                "$170,000.00/yr",
            ],
            "postedAt": "2026-09-20",
            "applicantsCount": "Over 200 applicants",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Software Development",
            "jobPosterName": "Priya S.",
            "jobPosterTitle": "Technical Recruiter",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/priya-s-sample-tidewater",
            "descriptionText": """Join the data platform team behind our retail forecasting product.
You will build batch and streaming pipelines in Python with Airflow, Spark and dbt on Snowflake, and expose results through internal APIs built with FastAPI.
Requirements: 5+ years of experience with Python and SQL; experience with Airflow or a similar orchestrator; AWS.
Nice to have: Kubernetes, Terraform.
We offer relocation assistance to our Denver hub for those who want it, but the role is fully remote.""",
        },
        {
            "id": "4301191508",
            "link": "https://www.linkedin.com/jobs/view/platform-engineer-at-northpeak-health-4301191508?refId=ghi789&position=3&pageNum=0",
            "title": "Platform Engineer",
            "companyName": "Northpeak Health",
            "companyLinkedinUrl": "https://www.linkedin.com/company/northpeak-health-sample",
            "companyEmployeesCount": 2300,
            "location": "Boston, MA",
            "workplaceTypes": ["Hybrid"],
            "salaryInfo": [
                "$155,000.00/yr",
                "$185,000.00/yr",
            ],
            "postedAt": "2026-09-23",
            "applicantsCount": "Be among the first 25 applicants",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Hospitals and Health Care",
            "descriptionText": """Build the internal developer platform for 300 engineers: Kubernetes, Terraform, AWS, Python and Go tooling, CI/CD with GitHub Actions.
Requirements: 5+ years of experience in platform or infrastructure engineering.
Applicants must be authorized to work in the U.S. We are unable to sponsor visas for this position.""",
        },
        {
            "id": "4301193377",
            "link": "https://www.linkedin.com/jobs/view/python-developer-at-brightwave-staffing-4301193377?position=4&pageNum=0",
            "title": "Python Developer",
            "companyName": "Brightwave Staffing Group",
            "location": "Austin, TX",
            "workplaceTypes": ["On-site"],
            "salaryInfo": [
                "$55.00/hr",
                "$65.00/hr",
            ],
            "postedAt": "2026-09-24",
            "applicantsCount": "12",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Contract",
            "industries": "Staffing and Recruiting",
            "descriptionText": "Our client, a Fortune 500 insurer, is looking for a Python Developer for a 6-month W2 contract. Python, Django, PostgreSQL required. C2C not available.",
        },
        {
            "id": "4301195840",
            "link": "https://www.linkedin.com/jobs/view/backend-engineer-payments-at-corvid-pay-4301195840?position=5&pageNum=0",
            "title": "Backend Engineer, Payments",
            "companyName": "Corvid Pay",
            "companyLinkedinUrl": "https://www.linkedin.com/company/corvid-pay-sample",
            "companyEmployeesCount": 95,
            "location": "New York, NY",
            "workplaceTypes": ["On-site"],
            "postedAt": "2026-09-18",
            "applicantsCount": "87",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Financial Services",
            "descriptionText": """Corvid Pay is building card issuing for small banks. You will write Java services with Spring Boot and Kafka and own our ledger.
Requirements: 4+ years of experience with Java or Kotlin; experience with payments or ledgers.
Office-based in Manhattan five days a week.""",
        },
        {
            "id": "4301197264",
            "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301197264?refId=jkl012&position=6&pageNum=0",
            "title": "Senior Backend Engineer (Python)",
            "companyName": "Ledgerline",
            "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
            "companyWebsite": "https://ledgerline.example",
            "companyEmployeesCount": 260,
            "location": "United States (Remote)",
            "workplaceTypes": ["Remote"],
            "salaryInfo": [
                "$150,000.00/yr",
                "$185,000.00/yr",
            ],
            "postedAt": "2026-09-21",
            "applicantsCount": "58",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "industries": "Financial Services",
            "jobPosterName": "Maya R.",
            "jobPosterTitle": "Head of Engineering",
            "jobPosterProfileUrl": "https://www.linkedin.com/in/maya-r-sample-ledgerline",
            "descriptionText": """Ledgerline builds accounting automation for 9,000 small businesses.
You will design Django services and REST APIs on PostgreSQL, run them on AWS, and improve our payments reconciliation.
Requirements: 5+ years of experience with Python and Django; PostgreSQL; AWS.
Nice to have: Celery, Redis, Kubernetes.
We will sponsor H-1B transfers for the right candidate.""",
        },
        {
            "id": "4301199931",
            "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301199931?position=7&pageNum=0",
            "title": "Senior Backend Engineer (Python)",
            "companyName": "Ledgerline, Inc.",
            "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
            "location": "United States (Remote)",
            "workplaceTypes": ["Remote"],
            "postedAt": "2026-09-24",
            "applicantsCount": "3",
            "seniorityLevel": "Mid-Senior level",
            "employmentType": "Full-time",
            "descriptionText": "Reposted. Ledgerline builds accounting automation for small businesses. Python, Django, PostgreSQL, AWS.",
        },
    ],
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("rich_minds/linkedin-job-match-ai").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 '{
  "sourceMode": "list",
  "searchKeywords": [
    "python developer",
    "backend engineer python",
    "platform engineer"
  ],
  "maxJobsPerSearch": 40,
  "maxDiscoveryChargeUsd": 0.5,
  "candidateProfile": "Backend engineer, 6 years of experience. Python (Django, FastAPI), PostgreSQL, Redis, Docker, Kubernetes and AWS. Built REST and GraphQL APIs for a fintech payments platform serving 2M users; led a team of 4. Looking for a senior backend or platform role, remote or hybrid in the US. Needs H-1B visa sponsorship.",
  "discoveryInput": {},
  "itemsList": [
    {
      "id": "4301187710",
      "link": "https://www.linkedin.com/jobs/view/staff-software-engineer-apis-at-orbital-freight-4301187710?refId=abc123&trackingId=xyz789&position=1&pageNum=0",
      "title": "Staff Software Engineer, APIs",
      "companyName": "Orbital Freight",
      "companyLinkedinUrl": "https://www.linkedin.com/company/orbital-freight?trk=public_jobs_topcard-org-name",
      "companyWebsite": "https://orbitalfreight.example",
      "companyEmployeesCount": 420,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "workRemoteAllowed": true,
      "salaryInfo": [
        "$170,000.00/yr",
        "$210,000.00/yr"
      ],
      "postedAt": "2026-09-22",
      "applicantsCount": "34",
      "applyUrl": "https://careers.orbitalfreight.example/jobs/staff-software-engineer-apis",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "jobFunction": "Engineering and Information Technology",
      "industries": "Transportation, Logistics, Supply Chain and Storage",
      "benefits": [
        "Medical insurance",
        "401(k)"
      ],
      "jobPosterName": "Daniel K.",
      "jobPosterTitle": "Engineering Manager, Platform APIs",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/daniel-k-sample-orbital",
      "descriptionText": "Orbital Freight moves 40,000 shipments a day through our APIs. We are hiring a Staff Software Engineer to own the public shipment and pricing APIs.\\nWhat you will do:\\n- Design and ship REST and GraphQL APIs in Python (FastAPI) backed by PostgreSQL and Redis\\n- Run services on Docker and Kubernetes in AWS\\n- Mentor a team of 5 engineers\\nRequirements:\\n- 6+ years of professional experience building backend services in Python\\n- Deep knowledge of PostgreSQL and API design\\nNice to have: Kafka, Terraform.\\nVisa sponsorship is available for this role. We are a remote-first company across US time zones."
    },
    {
      "id": "4301190022",
      "link": "https://www.linkedin.com/jobs/view/senior-python-engineer-data-platform-at-tidewater-analytics-4301190022?refId=def456&position=2&pageNum=0",
      "title": "Senior Python Engineer - Data Platform",
      "companyName": "Tidewater Analytics",
      "companyLinkedinUrl": "https://www.linkedin.com/company/tidewater-analytics",
      "companyEmployeesCount": 180,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "salaryInfo": [
        "$140,000.00/yr",
        "$170,000.00/yr"
      ],
      "postedAt": "2026-09-20",
      "applicantsCount": "Over 200 applicants",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Software Development",
      "jobPosterName": "Priya S.",
      "jobPosterTitle": "Technical Recruiter",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/priya-s-sample-tidewater",
      "descriptionText": "Join the data platform team behind our retail forecasting product.\\nYou will build batch and streaming pipelines in Python with Airflow, Spark and dbt on Snowflake, and expose results through internal APIs built with FastAPI.\\nRequirements: 5+ years of experience with Python and SQL; experience with Airflow or a similar orchestrator; AWS.\\nNice to have: Kubernetes, Terraform.\\nWe offer relocation assistance to our Denver hub for those who want it, but the role is fully remote."
    },
    {
      "id": "4301191508",
      "link": "https://www.linkedin.com/jobs/view/platform-engineer-at-northpeak-health-4301191508?refId=ghi789&position=3&pageNum=0",
      "title": "Platform Engineer",
      "companyName": "Northpeak Health",
      "companyLinkedinUrl": "https://www.linkedin.com/company/northpeak-health-sample",
      "companyEmployeesCount": 2300,
      "location": "Boston, MA",
      "workplaceTypes": [
        "Hybrid"
      ],
      "salaryInfo": [
        "$155,000.00/yr",
        "$185,000.00/yr"
      ],
      "postedAt": "2026-09-23",
      "applicantsCount": "Be among the first 25 applicants",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Hospitals and Health Care",
      "descriptionText": "Build the internal developer platform for 300 engineers: Kubernetes, Terraform, AWS, Python and Go tooling, CI/CD with GitHub Actions.\\nRequirements: 5+ years of experience in platform or infrastructure engineering.\\nApplicants must be authorized to work in the U.S. We are unable to sponsor visas for this position."
    },
    {
      "id": "4301193377",
      "link": "https://www.linkedin.com/jobs/view/python-developer-at-brightwave-staffing-4301193377?position=4&pageNum=0",
      "title": "Python Developer",
      "companyName": "Brightwave Staffing Group",
      "location": "Austin, TX",
      "workplaceTypes": [
        "On-site"
      ],
      "salaryInfo": [
        "$55.00/hr",
        "$65.00/hr"
      ],
      "postedAt": "2026-09-24",
      "applicantsCount": "12",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Contract",
      "industries": "Staffing and Recruiting",
      "descriptionText": "Our client, a Fortune 500 insurer, is looking for a Python Developer for a 6-month W2 contract. Python, Django, PostgreSQL required. C2C not available."
    },
    {
      "id": "4301195840",
      "link": "https://www.linkedin.com/jobs/view/backend-engineer-payments-at-corvid-pay-4301195840?position=5&pageNum=0",
      "title": "Backend Engineer, Payments",
      "companyName": "Corvid Pay",
      "companyLinkedinUrl": "https://www.linkedin.com/company/corvid-pay-sample",
      "companyEmployeesCount": 95,
      "location": "New York, NY",
      "workplaceTypes": [
        "On-site"
      ],
      "postedAt": "2026-09-18",
      "applicantsCount": "87",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Financial Services",
      "descriptionText": "Corvid Pay is building card issuing for small banks. You will write Java services with Spring Boot and Kafka and own our ledger.\\nRequirements: 4+ years of experience with Java or Kotlin; experience with payments or ledgers.\\nOffice-based in Manhattan five days a week."
    },
    {
      "id": "4301197264",
      "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301197264?refId=jkl012&position=6&pageNum=0",
      "title": "Senior Backend Engineer (Python)",
      "companyName": "Ledgerline",
      "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
      "companyWebsite": "https://ledgerline.example",
      "companyEmployeesCount": 260,
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "salaryInfo": [
        "$150,000.00/yr",
        "$185,000.00/yr"
      ],
      "postedAt": "2026-09-21",
      "applicantsCount": "58",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "industries": "Financial Services",
      "jobPosterName": "Maya R.",
      "jobPosterTitle": "Head of Engineering",
      "jobPosterProfileUrl": "https://www.linkedin.com/in/maya-r-sample-ledgerline",
      "descriptionText": "Ledgerline builds accounting automation for 9,000 small businesses.\\nYou will design Django services and REST APIs on PostgreSQL, run them on AWS, and improve our payments reconciliation.\\nRequirements: 5+ years of experience with Python and Django; PostgreSQL; AWS.\\nNice to have: Celery, Redis, Kubernetes.\\nWe will sponsor H-1B transfers for the right candidate."
    },
    {
      "id": "4301199931",
      "link": "https://www.linkedin.com/jobs/view/senior-backend-engineer-python-at-ledgerline-4301199931?position=7&pageNum=0",
      "title": "Senior Backend Engineer (Python)",
      "companyName": "Ledgerline, Inc.",
      "companyLinkedinUrl": "https://www.linkedin.com/company/ledgerline-sample",
      "location": "United States (Remote)",
      "workplaceTypes": [
        "Remote"
      ],
      "postedAt": "2026-09-24",
      "applicantsCount": "3",
      "seniorityLevel": "Mid-Senior level",
      "employmentType": "Full-time",
      "descriptionText": "Reposted. Ledgerline builds accounting automation for small businesses. Python, Django, PostgreSQL, AWS."
    }
  ],
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call rich_minds/linkedin-job-match-ai --silent --output-dataset

```

## MCP server setup

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

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/NNGkqUoqcisyBEc7Q/builds/m90ygRvuECUuAT1YG/openapi.json
