# Job Posting AI Enricher – Skills, Seniority & Salary (`gazidev/job-posting-enricher`) Actor

Enrich job postings from any job scraper dataset, CSV or JSON with AI: skills, tech stack, seniority, years of experience, salary normalised to annual, remote/hybrid/onsite, visa sponsorship, education, contract type, languages and a summary. No API key. $2 per 1,000 jobs + LLM tokens.

- **URL**: https://apify.com/gazidev/job-posting-enricher.md
- **Developed by:** [Cemal Atakli](https://apify.com/gazidev) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job enricheds

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

## Job Posting AI Enricher – Extract Skills, Seniority & Salary from Job Descriptions

Turn raw job postings into **clean, structured job data** with AI. Feed the dataset of any job scraper (LinkedIn, Indeed, Glassdoor, Greenhouse, Lever, Workday, Ashby, career sites, ...), a CSV / Excel / JSON file, or paste jobs as JSON. Every job comes back with the same normalised fields:

- **Skills**: required skills, nice-to-have skills, soft skills and the **tech stack** (optionally named with **ESCO** or **O\*NET** labels)
- **Seniority** (intern, entry, junior, mid, senior, lead, principal, manager, director, executive) and **job function**
- **Years of experience** (min / max) and **education level**
- **Salary**: min / max / ISO currency / period, plus **annualised salary** (hourly x 2,080, monthly x 12, ...)
- **Remote / hybrid / onsite** and allowed remote regions or time zones
- **Visa sponsorship** (yes / no / unknown) with the **exact quote** as evidence
- **Employment type** (full-time, part-time, contract, internship, ...)
- **Posting language** and **language requirements** (e.g. "German (C1)")
- **Red flags** (commission-only, pay to apply, unpaid trial, ...) and a **1-2 sentence summary**

No prompt writing, no schema design and **no API key**: the LLM runs through [Apify's OpenRouter Actor](https://apify.com/apify/openrouter) with your run's Apify token.

**$2 per 1,000 enriched jobs + LLM tokens** (about $0.0002-0.0004 per job with the default model). Failed or empty jobs are free.

### What people use it for

- **Job boards and aggregators**: add skill, seniority, remote and salary filters to scraped listings.
- **Labour-market and salary research**: compare annualised pay by skill, seniority, country or remote type.
- **Recruiting agencies and sourcers**: find visa-sponsoring, remote-EU or senior roles in thousands of postings.
- **HR-tech and career apps**: match candidate skills to job requirements with consistent skill names.
- **Competitive intelligence**: see which tech stacks and seniority levels competitors are hiring for.

### Works with any job scraper

Title, description, company, location and salary fields are **detected automatically**, per row, so you can even mix sources:

| Source | Fields detected |
|---|---|
| Greenhouse, Lever, Workday, Ashby, SmartRecruiters, ATS Jobs API, Career Site Jobs (gazidev) | `title`, `description_text` / `description_html`, `company`, `locations`, `salary_min/max`, `workplace_type` |
| Workable | `title`, `descriptionText` + `requirementsText` + `benefitsText` |
| Bundesagentur für Arbeit / EURES-style | `title`, `description`, `employer`, `locations` |
| LinkedIn-style scrapers | `title` / `jobTitle`, `descriptionText` / `descriptionHtml`, `companyName`, `location` |
| Indeed-style scrapers | `positionName`, `description`, `company`, `location`, `salary`, `jobType` |
| Anything else | set `titleField`, `descriptionField` (comma-separated list allowed) etc. Dot paths like `job.title` work |

HTML is stripped automatically and descriptions are capped at 6,000 characters (configurable) to keep token cost predictable. Existing structured fields (salary columns, `workplace_type`, `employment_type`, `experience_level`) are passed to the model as hints.

### Input example

```json
{
  "datasetIds": ["YOUR_JOB_SCRAPER_DATASET_ID"],
  "maxItems": 500,
  "fields": ["seniority", "skills", "experience", "salary", "workplace", "visa", "summary"],
  "taxonomy": "free",
  "model": "google/gemini-2.5-flash-lite"
}
```

In an Apify integration (run this Actor after a job scraper finishes) use `{{resource.defaultDatasetId}}` as the dataset. Choosing fewer `fields` makes each job cheaper in tokens.

### Output example

```json
{
  "jobTitle": "Junior Data Analyst",
  "company": "Example Inc.",
  "location": "Toronto, ON",
  "jobUrl": "https://example.com/jobs/2",
  "sourceId": null,
  "seniority": "junior",
  "jobFunction": "Data Analytics",
  "skillsRequired": ["SQL", "Excel"],
  "skillsNiceToHave": ["Power BI"],
  "softSkills": [],
  "techStack": ["SQL", "Excel", "Power BI"],
  "yearsExperienceMin": null,
  "yearsExperienceMax": null,
  "educationLevel": "bachelor",
  "employmentType": "unknown",
  "remoteType": "hybrid",
  "remoteRegions": [],
  "visaSponsorship": "unknown",
  "visaEvidence": null,
  "salaryMin": 55000,
  "salaryMax": 62000,
  "salaryCurrency": "CAD",
  "salaryPeriod": "year",
  "salaryMinAnnual": 55000,
  "salaryMaxAnnual": 62000,
  "postingLanguage": "en",
  "languageRequirements": [],
  "redFlags": [],
  "summary": "Entry-level hybrid data analyst role in Toronto working with SQL and Excel.",
  "enrichError": null
}
```

Turn on **Include original job record** to get the full source row under `original`. `jobUrl` and `sourceId` are always included so you can join results back. The dataset has ready-made table views (Overview, Salary & requirements, Skills) and exports to CSV, Excel or JSON. The `OUTPUT` record summarises jobs enriched, errors, tokens and which fields were auto-detected.

### How you pay

1. **This Actor: $0.002 per job enriched** (`job-enriched`) plus a tiny start fee. Jobs that fail, return invalid JSON or have no title/description are **not charged**.
2. **LLM tokens** at OpenRouter prices, billed to **your Apify account** through `apify/openrouter`. A typical posting (~1,000-1,500 input tokens, ~400 output tokens) costs about **$0.0003** with Gemini 2.5 Flash Lite. Apify bills OpenRouter usage on the free plan at 10x.

Set a maximum cost per run in the run options and the Actor stops cleanly before exceeding it.

| | This Actor | AI add-ons inside job scrapers | Generic LLM row runners |
|---|---|---|---|
| Price per job | **$0.002** + tokens | ~$0.01-0.05 per job / report | ~$0.002 per row + tokens, you write the prompt |
| Works with any job source | yes (datasets, CSV, JSON) | only that scraper | yes |
| Ready-made job schema + salary annualisation | yes | varies | no |
| Failed jobs | free | varies | varies |

Need a custom prompt for non-job data? Use [Bulk AI Dataset Enricher](https://apify.com/gazidev/bulk-ai-dataset-enricher).

### Use with AI agents (Apify MCP)

Add the Actor to Claude, ChatGPT, Cursor or any MCP client through the [Apify MCP server](https://mcp.apify.com). An agent can pass a dataset ID or a few job objects and get typed fields back, e.g. *"Which of these 200 jobs are remote in the EU, sponsor visas and pay over EUR 70k a year?"*

### FAQ

**Do I need an OpenAI or OpenRouter key?** No. Your run's Apify token calls Apify's OpenRouter Actor; token costs appear on your Apify bill.

**Is the salary ever guessed?** No. Salary, years of experience and visa sponsorship are only filled when the posting (or a structured salary field) states them; otherwise they are `null` / `"unknown"`. Currencies are not converted; annual values use 2,080 hours, 260 days, 52 weeks or 12 months per year.

**Which model should I pick?** The default Gemini 2.5 Flash Lite is cheap and accurate for most postings. For very long or messy descriptions try Gemini 2.5 Flash or GPT-5.4 mini.

**Which languages work?** Postings in any language the model understands (English, German, French, Spanish, Dutch, Polish, ...). Set `summaryLanguage` to get summaries in your language.

**What happens on errors?** Rate limits and server errors are retried automatically; invalid JSON is retried once. A job that still fails is saved with `enrichError` and is not charged (tokens already used by OpenRouter are still billed by OpenRouter).

**Whose data can I enrich?** Your own datasets and files, e.g. the output of job scrapers you ran. The Actor does not scrape anything itself.

# Actor input Schema

## `datasetIds` (type: `array`):

Datasets with job postings, e.g. the output of a LinkedIn, Indeed, Greenhouse, Lever, Workday or career-site scraper run. In an integration use {{resource.defaultDatasetId}}. All sources are combined. Remove the example jobs below when you use your own data.

## `fileUrls` (type: `array`):

Public URLs of CSV, TSV, XLSX, JSON or JSON Lines files with one job per row. Google Sheets ('Anyone with the link'), Google Drive, Dropbox and GitHub links are converted to direct downloads.

## `jobs` (type: `array`):

A JSON array of job objects. Any field names work: title/description/company/location/salary are detected automatically.

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

Stop after this many jobs (0 = all). You pay per enriched job, so start small.

## `fields` (type: `array`):

Fewer fields = fewer output tokens = cheaper LLM cost. Empty = all fields.

## `taxonomy` (type: `string`):

How skills are named. ESCO / O\*NET labels make skills comparable across postings and countries.

## `summaryLanguage` (type: `string`):

Language of summary and jobFunction. Skill names stay in English.

## `titleField` (type: `string`):

Leave empty to auto-detect (title, jobTitle, positionName, ...). Dot paths work, e.g. job.title.

## `descriptionField` (type: `string`):

Leave empty to auto-detect (description_text, descriptionText, description, descriptionHtml, ...). Several fields: comma-separated, e.g. descriptionText,requirementsText. HTML is stripped.

## `companyField` (type: `string`):

Leave empty to auto-detect (company, companyName, organization, employer, ...).

## `locationField` (type: `string`):

Leave empty to auto-detect (location, locations, formattedLocation, city, ...).

## `salaryField` (type: `string`):

Leave empty to auto-detect (salary, salary_summary, salaryText, compensation, ...). Structured salary_min/salary_max columns are used as hints automatically.

## `model` (type: `string`):

LLM used through Apify's OpenRouter Actor; tokens are billed to your Apify account (no API key needed). A typical posting costs ~$0.0002-0.0004 in tokens with the default model.

## `customModel` (type: `string`):

Optional: any model ID from openrouter.ai/models. Overrides the select above.

## `maxDescriptionChars` (type: `integer`):

Longer descriptions are truncated to keep token cost predictable (6,000 chars = ~1,500 tokens).

## `concurrency` (type: `integer`):

Jobs sent to the model at the same time. Rate limits are retried automatically.

## `includeOriginal` (type: `boolean`):

Adds the full source row under 'original' (larger dataset). jobTitle, company, location, jobUrl and sourceId are always included for joining.

## `includeUsage` (type: `boolean`):

Adds aiModel, aiTokens and descriptionChars to every job.

## Actor input object example

```json
{
  "jobs": [
    {
      "title": "Senior Python Engineer (Remote, EU)",
      "description": "We are hiring a senior backend engineer with 5+ years of Python, FastAPI and PostgreSQL. Experience with AWS and Docker is a plus. You communicate clearly in English; German is nice to have. Remote within the EU (CET +/- 2 hours). Salary EUR 70,000-90,000 per year. Visa sponsorship is not available.",
      "company": "Example GmbH",
      "location": "Berlin, Germany",
      "job_url": "https://example.com/jobs/1"
    },
    {
      "title": "Junior Data Analyst",
      "description": "<p>Entry-level role. <b>SQL and Excel required</b>, Power BI a plus. Bachelor's degree in a quantitative field. Hybrid, 3 days in our Toronto office. $55k-$62k CAD.</p>",
      "company": "Example Inc.",
      "location": "Toronto, ON",
      "job_url": "https://example.com/jobs/2"
    },
    {
      "positionName": "Registered Nurse - ICU (Night Shift)",
      "company": "Example Health",
      "location": "Houston, TX",
      "salary": "$48 - $62 an hour",
      "jobType": [
        "Full-time"
      ],
      "description": "Join our 24-bed ICU. Requirements: active Texas RN license, BLS and ACLS certification, minimum 2 years of acute care experience. We sponsor H-1B and green card applications for qualified international nurses. Sign-on bonus available.",
      "url": "https://example.com/jobs/3"
    }
  ],
  "maxItems": 3,
  "fields": [
    "seniority",
    "jobFunction",
    "skills",
    "experience",
    "education",
    "employmentType",
    "workplace",
    "visa",
    "salary",
    "languages",
    "redFlags",
    "summary"
  ],
  "taxonomy": "free",
  "summaryLanguage": "English",
  "model": "google/gemini-2.5-flash-lite",
  "maxDescriptionChars": 6000,
  "concurrency": 10,
  "includeOriginal": false,
  "includeUsage": false
}
```

# Actor output Schema

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

No description

## `csv` (type: `string`):

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

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

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "jobs": [
        {
            "title": "Senior Python Engineer (Remote, EU)",
            "description": "We are hiring a senior backend engineer with 5+ years of Python, FastAPI and PostgreSQL. Experience with AWS and Docker is a plus. You communicate clearly in English; German is nice to have. Remote within the EU (CET +/- 2 hours). Salary EUR 70,000-90,000 per year. Visa sponsorship is not available.",
            "company": "Example GmbH",
            "location": "Berlin, Germany",
            "job_url": "https://example.com/jobs/1"
        },
        {
            "title": "Junior Data Analyst",
            "description": "<p>Entry-level role. <b>SQL and Excel required</b>, Power BI a plus. Bachelor's degree in a quantitative field. Hybrid, 3 days in our Toronto office. $55k-$62k CAD.</p>",
            "company": "Example Inc.",
            "location": "Toronto, ON",
            "job_url": "https://example.com/jobs/2"
        },
        {
            "positionName": "Registered Nurse - ICU (Night Shift)",
            "company": "Example Health",
            "location": "Houston, TX",
            "salary": "$48 - $62 an hour",
            "jobType": [
                "Full-time"
            ],
            "description": "Join our 24-bed ICU. Requirements: active Texas RN license, BLS and ACLS certification, minimum 2 years of acute care experience. We sponsor H-1B and green card applications for qualified international nurses. Sign-on bonus available.",
            "url": "https://example.com/jobs/3"
        }
    ],
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("gazidev/job-posting-enricher").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 = {
    "jobs": [
        {
            "title": "Senior Python Engineer (Remote, EU)",
            "description": "We are hiring a senior backend engineer with 5+ years of Python, FastAPI and PostgreSQL. Experience with AWS and Docker is a plus. You communicate clearly in English; German is nice to have. Remote within the EU (CET +/- 2 hours). Salary EUR 70,000-90,000 per year. Visa sponsorship is not available.",
            "company": "Example GmbH",
            "location": "Berlin, Germany",
            "job_url": "https://example.com/jobs/1",
        },
        {
            "title": "Junior Data Analyst",
            "description": "<p>Entry-level role. <b>SQL and Excel required</b>, Power BI a plus. Bachelor's degree in a quantitative field. Hybrid, 3 days in our Toronto office. $55k-$62k CAD.</p>",
            "company": "Example Inc.",
            "location": "Toronto, ON",
            "job_url": "https://example.com/jobs/2",
        },
        {
            "positionName": "Registered Nurse - ICU (Night Shift)",
            "company": "Example Health",
            "location": "Houston, TX",
            "salary": "$48 - $62 an hour",
            "jobType": ["Full-time"],
            "description": "Join our 24-bed ICU. Requirements: active Texas RN license, BLS and ACLS certification, minimum 2 years of acute care experience. We sponsor H-1B and green card applications for qualified international nurses. Sign-on bonus available.",
            "url": "https://example.com/jobs/3",
        },
    ],
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("gazidev/job-posting-enricher").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 '{
  "jobs": [
    {
      "title": "Senior Python Engineer (Remote, EU)",
      "description": "We are hiring a senior backend engineer with 5+ years of Python, FastAPI and PostgreSQL. Experience with AWS and Docker is a plus. You communicate clearly in English; German is nice to have. Remote within the EU (CET +/- 2 hours). Salary EUR 70,000-90,000 per year. Visa sponsorship is not available.",
      "company": "Example GmbH",
      "location": "Berlin, Germany",
      "job_url": "https://example.com/jobs/1"
    },
    {
      "title": "Junior Data Analyst",
      "description": "<p>Entry-level role. <b>SQL and Excel required</b>, Power BI a plus. Bachelor'\''s degree in a quantitative field. Hybrid, 3 days in our Toronto office. $55k-$62k CAD.</p>",
      "company": "Example Inc.",
      "location": "Toronto, ON",
      "job_url": "https://example.com/jobs/2"
    },
    {
      "positionName": "Registered Nurse - ICU (Night Shift)",
      "company": "Example Health",
      "location": "Houston, TX",
      "salary": "$48 - $62 an hour",
      "jobType": [
        "Full-time"
      ],
      "description": "Join our 24-bed ICU. Requirements: active Texas RN license, BLS and ACLS certification, minimum 2 years of acute care experience. We sponsor H-1B and green card applications for qualified international nurses. Sign-on bonus available.",
      "url": "https://example.com/jobs/3"
    }
  ],
  "maxItems": 3
}' |
apify call gazidev/job-posting-enricher --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,gazidev/job-posting-enricher"
        }
    }
}
```

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/Fn3pVwlr51qMBVhEt/builds/9sIuPsaf4bauOIIIH/openapi.json
