# XING Jobs Scraper (`datahamster/xing-jobs-scraper`) Actor

XING jobs scraper: search xing.com job ads by keyword and city with radius, employment type, remote and career level filters. Get title, company, location, salary (employer range or XING estimate), posted date and a snippet; optional full description. Monitor mode returns only new jobs.

- **URL**: https://apify.com/datahamster/xing-jobs-scraper.md
- **Developed by:** [Viktor Dubnytskiy](https://apify.com/datahamster) (community)
- **Categories:** Jobs
- **Features:** Limited permissions
- **Stats:** 3 total users, 2 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.80 / 1,000 result items

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## XING Jobs Scraper

Search XING (xing.com) jobs by keyword and city and get one flat row per job ad: title, company, city, employment type, salary (the employer's range or XING's own estimate, flagged), posted date, a short summary of the tasks and the job URL. Turn on `includeDetails` for the full ad text, remote option, career level and industry. No account and no cookies. Monitor mode turns the same search into an alert on new jobs.

**Try it:** the prefilled example returns 20 rows in about 5 seconds and costs about $0.02. Results cost $1.00 per 1,000.

Coverage: XING returns at most 1,000 jobs per search, mostly in Germany, Austria and Switzerland. XING's search is semantic and mixes related jobs into the list. Measured on 2026-11-05 (100 jobs per search, keyword in the title, company or summary): `Pflegefachkraft` in Hamburg 94 of 100, `java` 91, `Buchhalter` in Frankfurt am Main 68, `data analyst` 63, `Projektmanager` in München 35, and `python developer` in Berlin 7 with both words (16 mention "python"). A made-up keyword in Berlin returned 20 unrelated jobs on page 1. By default (`keywordMatch: "relevant"`) a keyword is skipped, free of charge, when none of the first 20 ads mention it; `strict` keeps only ads that mention it.

- **No start fee:** in scrape mode you pay $1.00 per 1,000 jobs and nothing per run. The most-used XING jobs actor in the Store charges the same $0.001 per job plus at least $0.0005 per actor start (checked 2026-11-05), so a 20-job scrape costs about 2% less here and a 5-job scrape about 9% less. Monitor mode adds a $0.005 monitor-check per run (see Pricing), so there a 5-new-job run costs $0.010 here.
- **Salary on 19 of 20 rows** in the example run: 15 are XING's salary estimate (`salaryIsEstimate: true`, with a median) and 4 are a range the employer published, so you can tell the two apart.
- **XING's own filters:** radius around the city, employment type, remote option and career level, applied on XING's side so you pay only for matching jobs.
- **Monitor mode:** a scheduled task returns only jobs it has not seen before. The first run of a search is a baseline and returns nothing.

### What you get

Real rows from the example dataset, which is the prefilled input (`keywords: ["python developer"]`, `location: "Berlin"`, 20 jobs):

| title / company | city | employment | salary (EUR / year) | estimate | posted |
|---|---|---|---|---|---|
| Python Developer Financial Services (all genders) / Exxeta | Berlin | Full-time | 59,000-86,000 | yes | 2026-09-17 |
| Python / Django Entwickler (m/w/d) – Fullstack, REST, CI/CD / Rockstardevelopers GmbH | Berlin | Full-time | 52,500-67,500 | yes | 2026-11-04 |
| Backend Engineer (m/f/d) / Care Companion GmbH | Berlin | Full-time | 60,000-70,000 | no | 2026-10-19 |
| Engineer Applied AI Engineering & Full-Stack (m/w/d) / CTG Consulting GmbH | Berlin | Full-time | 60,000-85,000 | no | 2026-07-15 |
| Full Stack Software Engineer (m/w/d) / Odoo DE GmbH | Berlin | Full-time | 48,000-60,000 | no | 2026-10-30 |

One full row:

```json
{
  "id": "158655343",
  "url": "https://www.xing.com/jobs/berlin-backend-engineer-158655343",
  "scrapedAt": "2026-11-05T13:15:15.042370Z",
  "jobId": "158655343",
  "title": "Backend Engineer (m/f/d)",
  "company": "Care Companion GmbH",
  "companyId": null,
  "companyLogo": null,
  "location": "Berlin",
  "locations": ["Berlin"],
  "employmentType": "Full-time",
  "salaryMin": 60000,
  "salaryMax": 70000,
  "salaryMedian": null,
  "salaryCurrency": "EUR",
  "salaryIsEstimate": false,
  "postedAt": "2026-10-19T10:52:06Z",
  "activeUntil": "2027-10-19T10:52:08Z",
  "applyUrl": null,
  "applyOnXing": true,
  "remote": null,
  "isRemote": null,
  "snippet": "Develop features from data model to API. Work on budget, billing, and payroll. Maintain production code for users.",
  "description": null,
  "detailsFetched": false,
  "query": "python developer",
  "rank": 12
}
```

Full row: `id` / `jobId`, `url`, `title`, `company`, `companyId`, `companyLogo`, `location`, `locations`, `employmentType`, `salaryMin`, `salaryMax`, `salaryMedian`, `salaryCurrency`, `salaryIsEstimate`, `postedAt`, `activeUntil`, `applyUrl`, `applyOnXing`, `remote`, `remoteOptions`, `isRemote`, `snippet`, `query`, `rank`, `scrapedAt`. With `includeDetails: true` also `description`, `activatedAt`, `careerLevel`, `discipline`, `industry`, `language`, `region`, `countryCode`, and `remote` / `isRemote` from the ad itself.

`id` is XING's job id, so a job found by two keywords is one row and monitor mode tracks it across runs. `keywordMatch` decides which rows you get (see above); with several keywords each keyword gets an equal share of `maxItems`, and a share one keyword does not use passes on to the next. `postedAt` is the date XING shows on the ad (it moves when the employer refreshes the ad); `activatedAt` (details) is the first publication. `snippet` is XING's three-line summary of the tasks and exists on about a third of the ads. `applyUrl` is the employer's own application page when the ad links one; `applyOnXing: true` means the application runs on XING.

### Use cases

- **Daily job alert.** One saved task per search (`"keywords": ["Projektmanager"]`, `"location": "München"`, `"radius": "20"`) in monitor mode, scheduled every morning. Each run returns only the jobs that were not there before.
- **Salary research for the DACH market.** Pull a few hundred ads for a role and city and compare employer ranges with XING's estimates.
- **Hiring signal.** See which companies in a city are hiring for your niche, with employment type and career level on each row.

### Try it

Hit **Start**: the prefilled input searches `python developer` in Berlin, 20 jobs. Change the city to `München`, `Hamburg`, `Wien` or `Zürich`, add `radius: "50"`, pick `employmentType: "part-time"` or `remote: "hybrid"`, and set `includeDetails: true` for the full ad text (30 jobs with full text took about 40 seconds in a test run).

**Monitor mode.** Save the input as a task and set:

```json
{
  "mode": "monitor",
  "monitorStateId": "pm-muenchen-daily",
  "keywords": ["Projektmanager"],
  "location": "München",
  "maxResultsPerQuery": 300,
  "maxItems": 50,
  "webhookUrl": "https://your-endpoint.example.com/hook"
}
```

Put the task on a schedule (Apify, Schedules, cron `0 7 * * *` for daily).

- **How "new" is decided:** a job is new when its id is not in the task's history and its XING date (`postedAt`) is no older than the start of the last run that read its search, minus 2 hours. An older job the actor simply had not reached before (it sat deeper than `maxResultsPerQuery`) is recorded and never returned or charged.
- **The first run of a search is the baseline.** It reads up to `maxResultsPerQuery` jobs per keyword, records them and returns nothing: you pay one monitor-check and no rows, and the run summary says `emptyReason: "baseline"`. From the second run on you get the jobs that appeared since. A keyword added to the task later, or a change of city, filters or `maxResultsPerQuery`, starts a new baseline for that search.
- **`maxItems` counts new jobs only.** Jobs already seen are read and skipped without counting, so a page of old jobs never ends the run early. A new job left over by `maxItems` is not recorded and comes back in the next run.
- XING has no "newest first" sort, so new jobs can sit anywhere in the list: set `maxResultsPerQuery` to cover the whole search. A job XING refreshes gets a new date, and if the actor has never seen it before it counts as new. When a search stops before its end the log says so and `XING_STATS.incompleteQueries` lists it. On a search cut by `maxResultsPerQuery`, a new job that sat deeper than the limit and only rises into view after the next run counts as old and is not reported, so keep the limit above the search's total.
- A refreshed ad does not come back as new. Point `webhookUrl` or the Telegram fields at your own channel to get the new jobs pushed to you.

### Input

| Field | Meaning | Default |
|---|---|---|
| `keywords` | Keywords, one per line; each is a separate search | required |
| `location` | City as XING spells it, e.g. `Berlin`, `München`, `Wien`; empty = all of XING | empty |
| `radius` | `10`, `20`, `50`, `70`, `100` or `200` km around the city | XING default |
| `employmentType` | `full-time`, `part-time`, `self-employed`, `student`, `seasonal`, `temporary`, `volunteer` | any |
| `remote` | `remote` (full remote, ignores the city), `hybrid`, `on-site` | any |
| `careerLevel` | `student-intern`, `entry-level`, `professional`, `manager`, `executive`, `senior-executive` | any |
| `includeDetails` | Open each job page for the full ad and its facts | `false` |
| `keywordMatch` | `relevant` (skip a keyword when no ad on page 1 mentions it), `strict` (only ads that mention every word of it), `off` (everything XING returns) | `relevant` |
| `maxResultsPerQuery` | Stop each keyword after this many jobs (at most 1,000) | `100` |
| `maxItems` | Stop the whole run after this many rows (monitor mode: new jobs), shared equally between keywords | `100` |
| `mode` | `scrape`, or `monitor` for new jobs only | `scrape` |
| `monitorStateId`, `webhookUrl`, `telegramBotToken`, `telegramChatId` | Monitor-mode state key and alert targets | empty |

### Pricing

| Event | Price |
|---|---|
| result | $0.001 per job ($1.00 per 1,000) |
| monitor-check | $0.005 per monitor run |
| change | $0.001 per new job in monitor mode |

Apify Store discounts: SILVER -10%, GOLD and higher -20% on every event.

You pay only for rows that are pushed. A keyword with no ad mentioning it on XING's first page is skipped and charges nothing, and a monitor run that is blocked before it reads anything charges no monitor-check. A monitor run that reads XING always costs the $0.005 monitor-check, also when every keyword is skipped or nothing is new. Apify platform usage is billed by Apify on top; the example run used about $0.0004 of it.

**Found it useful?** A short review on the Store page helps other people find this actor. If a search misbehaves, open an issue on the actor page.

### Related actors

- [LinkedIn Jobs Scraper](https://apify.com/datahamster/linkedin-jobs-scraper) for the same roles on LinkedIn, in Germany or anywhere else.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/datahamster/welcome-to-the-jungle-jobs-scraper) for jobs in France and the rest of Europe.
- [Glassdoor Jobs Scraper: Salary Estimates, Ratings, Monitor](https://apify.com/datahamster/glassdoor-jobs) for employer ratings next to the postings.
- [Career Site Jobs Monitor: Greenhouse, Lever, Ashby, Workday](https://apify.com/datahamster/ats-jobs) to watch a specific employer's own career site.

### Limits

- XING returns at most 1,000 jobs per keyword and filter set. A broader search ends there with a warning in the log (`XING_STATS.cappedQueries`); split it by city or filter.
- The search is semantic. `relevant` (the default) only skips a keyword when none of the first 20 ads mention it; once page 1 has a match, XING's related jobs further down are kept (for `python developer` in Berlin 16 of 100 ads mention "python"). Use `strict` when every row must mention the keyword. Matching is by word: `java` does not match "JavaScript", `go` does not match "Google", `C++`, `C#` and `R` match only themselves, words of 5 or more letters also match inside German compounds ("python" in "Pythonentwickler"), and hyphens and spaces inside a compound do not matter ("Full-Stack", "Full Stack" and "Fullstack" all match each other).
- A city XING does not know is silently dropped by XING, which then searches everywhere. The actor detects this, skips the keyword with a warning and lists it in `XING_STATS.unresolvedLocation`; it costs one extra search page per keyword with a city.
- `remote: "remote"` searches all of XING; XING does not combine full remote with a city. Each filter takes one value.
- Salary figures are copied as XING shows them. XING gives no pay period, so a student job can show 500-1,500 EUR (a month) next to yearly salaries.
- Without `includeDetails`, `remote` is filled only when you set the remote filter.

### FAQ

**Do I need a XING account or cookies?** No. The actor reads the same public job search and job pages that xing.com shows to a visitor who is not signed in.

**Why did my keyword return nothing?** Either XING has no jobs for it with your filters, none of the first 20 ads mention it (XING only had related jobs, see `keywordMatch`), or the city was not recognised. The `RUN_SUMMARY` record in the run's key-value store has `emptyReason`, and `XING_STATS` lists `emptyQueries`, `noKeywordMatch` (with `page1KeywordHits`) and `unresolvedLocation`. In monitor mode the first run of a search is a baseline and returns nothing by design.

**Can I get the recruiter's name or contact details, or XING member profiles?** No. Rows hold job and company data only, and member profiles are never visited. The contact section of a job ad is not read; e-mail addresses and phone numbers are removed from the rest of the text.

### Changelog

- 0.1: initial release with keyword and city search, radius, employment type, remote and career level filters, optional full ad text, keyword matching (relevant, strict, off), fair `maxItems` share per keyword, and monitor mode for new jobs with a baseline first run and a date rule for jobs not reached before.

# Actor input Schema

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

Job keywords, one per line, e.g. "python developer", "Projektmanager", "Pflegefachkraft". Each keyword is a separate XING search with the filters below.

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

City as XING spells it, e.g. "Berlin", "München", "Hamburg", "Wien", "Zürich". Leave empty to search all of XING. A city XING does not know is reported in the log and the keyword returns nothing.

## `radius` (type: `string`):

Distance around the city. Needs a city. Example: 20.

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

Keep only this employment type (XING's own filter). Example: full-time.

## `remote` (type: `string`):

Keep only this remote option (XING's own filter). Full remote searches all of XING and ignores the city. Rows of a filtered search carry the option in `remote`.

## `careerLevel` (type: `string`):

Keep only this career level (XING's own filter). Example: entry-level.

## `includeDetails` (type: `boolean`):

true = open each job page and add the full description as plain text (contacts removed), remote option, career level, discipline, industry, first publication date and the employer's apply link. One extra request per job. Example: false.

## `keywordMatch` (type: `string`):

XING's search is semantic and also returns related jobs. relevant (default) skips a keyword, free of charge, when none of the first 20 ads mention it, and otherwise keeps XING's list including related jobs. strict keeps only ads whose title, company or summary contain every word of the keyword. off keeps everything. Example: relevant.

## `maxResultsPerQuery` (type: `integer`):

Stop each keyword after this many jobs. XING returns at most 1,000 jobs per search. Example: 100.

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

Stop the whole run after this many jobs (you are charged only for pushed jobs). Example: 20.

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

scrape = full results; monitor = only new/changed items since the previous run of this task

## `monitorStateId` (type: `string`):

Optional state id when not running as a saved task (monitor mode)

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

POST a change summary here in monitor mode

## `telegramBotToken` (type: `string`):

Optional: bot token for monitor-mode change summaries

## `telegramChatId` (type: `string`):

Optional: chat id that receives monitor-mode summaries

## Actor input object example

```json
{
  "keywords": [
    "python developer"
  ],
  "location": "Berlin",
  "radius": "",
  "employmentType": "",
  "remote": "",
  "careerLevel": "",
  "includeDetails": false,
  "keywordMatch": "relevant",
  "maxResultsPerQuery": 20,
  "maxItems": 20,
  "mode": "scrape"
}
```

# Actor output Schema

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

All pushed rows (dataset, JSON)

## `resultsTable` (type: `string`):

Dataset in the Console viewer

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

RUN_SUMMARY record

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "python developer"
    ],
    "location": "Berlin",
    "maxResultsPerQuery": 20,
    "maxItems": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datahamster/xing-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "keywords": ["python developer"],
    "location": "Berlin",
    "maxResultsPerQuery": 20,
    "maxItems": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("datahamster/xing-jobs-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "keywords": [
    "python developer"
  ],
  "location": "Berlin",
  "maxResultsPerQuery": 20,
  "maxItems": 20
}' |
apify call datahamster/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

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/gEHhKpPwwLgSn4WRq/builds/foxae8LwmDY2NQxcz/openapi.json
