# XING Jobs Scraper ($0.87/1K): Jobs & Salaries in DACH (`tsutseisoftware/xing-jobs-scraper`) Actor

Scrape XING jobs in Germany, Austria and Switzerland: title, company, places, remote option, employment type, career level, yearly salary, full description and apply link. All filters, past the 1,000-job limit, monitoring of new and removed jobs, notifications, market summary. Unofficial.

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

## Pricing

from $0.77 / 1,000 jobs

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
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: Jobs & Salaries in Germany, Austria and Switzerland

Get job ads from **XING** (xing.com, the German-speaking professional network) as clean, ready-to-use data. Search by **keyword**, **location** with a **radius**, **employment type**, **career level**, **remote option**, **minimum salary** and **date posted**, or paste any XING job search or job URL. Every job comes with its **full description**, the **yearly salary** (the employer's own, or XING's estimate, always marked which), all places, the company, discipline, industry and the **apply link**.

**$0.87 per 1 000 jobs, full descriptions included.** No proxy setup and no extra platform costs.

Built for **recruiters, job boards, HR and salary analysts and job seekers** in the DACH region: schedule it daily in monitoring mode and you get only the jobs that are new or changed, plus, if you want, the jobs that **were taken down**. Every run also saves a free **market summary**: yearly salary quartiles by country, employment type, career level, remote option and discipline, top companies and cities.

### Why use this XING scraper?

- 📝 **Full description in every row at no extra cost**, in plain text, Markdown or HTML, plus XING's short summary, key responsibilities and qualifications.
- 💰 **Salaries you can compare.** Yearly salary from and to as numbers, with `salarySource` telling the **employer's salary** from **XING's estimate** (and the estimate's median). In our test 86 % of developer jobs in Berlin had one of the two.
- ♾️ **Every job of a large search.** XING shows at most 1 000 jobs for one search; with **Max jobs** 0 the actor reads past that automatically and says in the status if anything was left out.
- 🔎 **The website's filters** (filtered-out jobs cost nothing): employment type, career level, remote option, radius, minimum yearly salary, last 24 hours / 7 days / 30 days.
- 📬 **Monitoring mode:** a daily feed of new and changed jobs (`changeType`, `changedFields`), optionally with **removed jobs** (`expired` or `noLongerMatches`, with `daysOnline`).
- 🔔 **Job alerts without any integration:** send the saved jobs to **Slack, Discord, Telegram, WhatsApp** or your own **webhook** (Zapier, Make, n8n) after each run.
- 🔒 **Privacy first.** No recruiter names, e-mails or phone numbers in the data by default (they are removed from the descriptions); employers that are private persons are saved without their name. Contacts the ad shows are a paid opt-in.

#### How it compares with other XING scrapers

An honest comparison with the XING job scrapers most used in the Store (checked 2026-11-15), without naming them:

| Capability | This actor | Other scrapers |
|---|---|---|
| Keyword, location, radius, employment type, career level, remote and date filters, URLs | yes | yes (some fewer) |
| Full description | yes, included | included, or an extra charge |
| Employer's salary told apart from XING's estimate | yes | rarely |
| Every job of a large search (past the 1 000 the website shows) | yes | rarely |
| Monitoring of new and changed jobs, removed jobs reported | yes | some (new jobs only) |
| Notifications to Slack, Discord, Telegram, WhatsApp or a webhook | yes | some |
| Market summary of every run | yes | rarely |
| Contacts the ad shows (paid opt-in) | yes | some |
| Price per 1 000 jobs with descriptions (Free plan) | $0.87 | $0.90 to $2.19 |

### What data can you get?

| Group | Fields |
|---|---|
| Job | `title`, `url`, `employmentType`, `employmentTypeLabel`, `careerLevel`, `careerLevelLabel`, `discipline`, `industry`, `remote`, `remoteOptions`, `jobLanguage`, `keywords`, `isPromoted`, `isTopJob`, `postedAt`, `refreshedAt`, `validThrough` |
| Salary | `salaryMin`, `salaryMax`, `salaryMedian`, `salaryCurrency`, `salaryPeriod`, `salarySource` |
| Place | `location`, `city`, `zipCode`, `street`, `region`, `country`, `countryCode`, `locations` (every place) |
| Company | `company`, `companyId`, `companyUrl`, `companyLogo` |
| Text | `description`, `summary`, `keyResponsibilities`, `qualifications`, `applyUrl`, `applyOnXing` |
| Contacts (paid option) | `contactNames`, `contactEmails`, `contactPhones` |
| Monitoring | `changeType`, `changedFields`, `firstSeenAt`, `removedAt`, `removedReason`, `daysOnline` |

How full the fields are (measured 2026-11-15 on 1 738 jobs for "developer" in Berlin and "manager" anywhere): description 100 %, career level and remote option 100 %, salary 51 to 86 % (employer's own 16 to 22 %, the rest XING's estimate), short summary about 50 %, apply link to the employer's site about 50 to 67 % (the rest apply on XING), postal code about 50 %, street about 20 %. About 10 to 40 % of the ads show a contact person, e-mail or phone (paid option), depending on the field.

### How to scrape XING

1. Open the actor and enter one or more **Search keywords** (e.g. `developer`) and **Locations** (e.g. `Berlin`, `Wien`, `Zürich`), or paste **XING URLs** (a job search or a job page).
2. Narrow it with the **Filters**: employment type, career level, remote work, radius, minimum salary, date posted.
3. Set **Max jobs** (0 = every job of the search).
4. Click **Start** and download the dataset as **JSON, CSV, Excel, XML or HTML**, or read it through the Apify API.
5. To watch a search, turn on **Monitoring: only new or changed jobs** and schedule the actor daily.

### Use cases

#### Developer jobs in Berlin with salaries

```json
{
  "searchQueries": ["developer"],
  "locations": ["Berlin"],
  "maxItems": 100
}
```

#### Senior remote jobs in Germany, Austria and Switzerland posted this week

```json
{
  "searchQueries": ["product manager", "data engineer"],
  "careerLevels": ["PROFESSIONAL", "MANAGER"],
  "remoteOptions": ["FULL_REMOTE"],
  "postedWithin": "LAST_WEEK",
  "maxItems": 0
}
```

#### Nursing jobs around Vienna from EUR 45 000 a year

```json
{
  "searchQueries": ["Pflege"],
  "locations": ["Wien"],
  "radiusKm": 50,
  "minYearlySalary": 45000,
  "maxItems": 200
}
```

#### New SAP jobs every morning, with removed ones, to Slack

```json
{
  "searchQueries": ["SAP"],
  "locations": ["München"],
  "onlyNewOrChanged": true,
  "includeRemovedJobs": true,
  "monitoringKey": "sap-munich",
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxItems": 0
}
```

#### A search or a job from the website

Paste a job search from xing.com (its keyword, location, radius, employment type, career level, remote and date filters are used) or a job page into **XING URLs**.

```json
{
  "startUrls": [
    { "url": "https://www.xing.com/jobs/search?keywords=developer&location=Hamburg" },
    { "url": "https://www.xing.com/jobs/bonn-sap-business-technology-platform-btp-developer-159044594" }
  ],
  "maxItems": 100
}
```

#### Every job of a large search

XING shows at most 1 000 jobs for one search. With **Max jobs** 0 (or above 1 000) the actor reads larger searches in full automatically, each job once. The status message says if a search was still too large to read completely; narrow it with a location or a filter. XING's own job count is a little higher than the jobs it actually lists (about 96 % in our tests); the status shows both numbers.

#### Monitoring mode

The actor remembers the jobs of earlier runs with the same **Monitoring: key** and saves only jobs that are new or whose title, company, places, remote option, employment type, career level or salary changed. Unchanged jobs are not saved and not charged; every search answer read in this mode (up to 20 jobs) is a small "Monitoring page" charge. With **Monitoring: include removed jobs**, jobs of earlier runs that are no longer in the results come as rows with `changeType: "removed"` and `removedReason` `expired` (the job was taken down) or `noLongerMatches` (still published, no longer matching the search). They are checked only when every search of the run was read to its end.

#### Contacts (optional, personal data)

With **Contacts (paid option)** each job gets the contact person, e-mail addresses and phone numbers the ad itself shows (`contactNames`, `contactEmails`, `contactPhones`), never for an employer that is a private person. About 10 to 40 % of the ads have at least one, depending on the field. These are personal data: you are responsible for using them lawfully (GDPR). The descriptions never contain them.

#### Market summary (SUMMARY)

Every run saves a free summary to the key-value store (record `SUMMARY`): jobs matched, share with a salary, yearly salary quartiles per currency (overall, employer's salaries and estimates apart, by country, employment type, career level, remote option and discipline), top companies, cities, disciplines, industries, employment types, career levels and remote options.

### How much does it cost to scrape XING?

Pay per event; the prices are also on the **Pricing** tab. Platform costs are included.

| Event | Price | When |
|---|---|---|
| Job saved in the dataset | **$0.87 / 1 000** (Bronze $0.87, Silver $0.84, Gold and higher $0.77) | every saved row, with its full description |
| Actor start | $0.003 per run | once per run |
| Contact details | $0.40 / 1 000 | a saved job with at least one contact, only with **Contacts (paid option)** |
| Monitoring page | $0.25 / 1 000 answers | monitoring mode: every search answer read (up to 20 jobs), so unchanged jobs cost little |
| Extra page | $0.25 / 1 000 requests | requests beyond what the saved jobs explain: a search that finds nothing, URLs of removed jobs, second attempts, reading a large or overlapping search again. If the saved jobs don't cover a run's cost (e.g. a run that waits long because the website delays answers), the difference is charged as extra pages; the log says how many. A normal run pays nothing or very little here. |
| Notification | $0.001 per run | a run that sent its notification (all channels together) |

| Typical run | Price (Free plan) | Typical time |
|---|---|---|
| 20 jobs (the example input) | $0.02 | under 10 s |
| 1 000 jobs | $0.88 | about 2 to 3 minutes |
| Every developer job in Berlin (about 440) | $0.40 | about 1 minute |
| Daily monitoring of a search with 450 jobs, 20 new | $0.03 | under 1 minute |

You can set a maximum cost per run; the actor stops when it is reached.

### Input example

```json
{
  "searchQueries": ["developer"],
  "locations": ["Berlin", "Hamburg"],
  "employmentTypes": ["FULL_TIME"],
  "remoteOptions": ["PARTLY_REMOTE", "FULL_REMOTE"],
  "maxItems": 50,
  "descriptionFormat": "markdown"
}
```

### Output example

```json
{
  "id": "159044594",
  "source": "xing.com",
  "url": "https://www.xing.com/jobs/bonn-sap-business-technology-platform-btp-developer-159044594",
  "title": "SAP Business Technology Platform (BTP) Developer (m/w/d)",
  "company": "conet",
  "companyUrl": "https://www.xing.com/pages/conet",
  "location": "Bonn, DE",
  "city": "Bonn",
  "region": "Nordrhein-Westfalen",
  "countryCode": "DE",
  "locations": ["Bonn, DE", "Karlsruhe, DE", "Berlin, DE", "Düsseldorf, DE"],
  "remote": "hybrid",
  "employmentType": "FULL_TIME",
  "employmentTypeLabel": "Full-time",
  "careerLevel": "PROFESSIONAL",
  "careerLevelLabel": "Professional/Experienced",
  "discipline": "IT and software development",
  "industry": "IT services",
  "salaryMin": 69000,
  "salaryMax": 94500,
  "salaryMedian": 87000,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salarySource": "estimate",
  "postedAt": "2026-11-06T09:34:12Z",
  "validThrough": "2027-01-05T09:34:18Z",
  "keywords": ["sap", "java", "javascript", "node"],
  "summary": "Conet sucht einen SAP BTP Developer in Bonn…",
  "keyResponsibilities": ["Beratung und Umsetzung von SAP-Anforderungen.", "Entwicklung von Microservices auf SAP BTP."],
  "description": "Über uns\nWir erweitern unser Team „SAP Development“…",
  "applyUrl": "https://www.conet.de/de/karriere/jobs/2026-068-sap-business-technology-platform-btp-developer/",
  "applyOnXing": false,
  "isPromoted": true,
  "contactNames": [],
  "contactEmails": [],
  "contactPhones": [],
  "scrapedAt": "2026-11-15T10:00:00Z",
  "changeType": null
}
```

### Limitations

- XING's search ranks jobs by relevance, so it may also return related jobs (a "developer" search also finds business development roles). Use the filters or check the titles.
- XING's job count is a little higher than the jobs it actually lists (about 96 % can be read); the status shows both numbers.
- About half of the jobs show a salary; most of them are XING's estimate (`salarySource: "estimate"`), not the employer's figure.
- Free text may mention a person by name (e.g. "you will report to …"); e-mails, phone numbers and the names of contact persons are removed.
- Employer names that look like a private person (a practice, a sole trader) are hidden together with their address and logo; in doubt, privacy wins. In our samples 1 to 3 % of employers were hidden, many of them firms named after a person or partnership (e.g. law and tax firms).
- A request the website rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. The actor never solves challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/xing-jobs-scraper").call(run_input={
    "searchQueries": ["data engineer"], "locations": ["München"], "maxItems": 100,
})
for job in client.dataset(run.default_dataset_id).iterate_items():
    print(job["title"], job["company"], job["salaryMin"], job["salaryMax"], job["salarySource"], job["url"])
summary = client.key_value_store(run.default_key_value_store_id).get_record("SUMMARY")["value"]
print(summary["salary"]["byCurrency"], summary["topCompanies"][:10])
```

**Compact output** keeps the core fields (title, company, place, country, remote, employment type, career level, salary, date, apply link, URL) plus the fields of the options you turned on: smaller rows for AI agents, MCP clients and spreadsheets.

### Troubleshooting

- **"Nothing to search"**: add a search keyword, a location, a filter or a XING URL.
- **"Your maximum cost per run … does not cover the start of the run"**: raise the maximum cost per run in the run options.
- **"job URLs of closed jobs skipped"**: the jobs are no longer published; use the URL of an open job.
- **"no jobs: …"**: the website found nothing for the search; try fewer filters or check the location spelling.
- **"… still had more than 1 000 jobs, so some jobs could not be read"**: narrow the search with a location or a filter.
- **"XING did not seem to know the location …"**: none of the first jobs is in that place, so XING searched everywhere; check the spelling (e.g. `München`, `Wien`, `Zürich`).
- **"job URLs not read because Max jobs was reached"**: raise **Max jobs**.
- **"XING is rejecting requests"**: try again later, and keep the proxy setting at its default.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More job scrapers

Jobs from another source, with salaries and monitoring:

- [StepStone Scraper](https://apify.com/tsutseisoftware/stepstone-scraper): jobs from StepStone in Germany, Austria, Belgium and the Netherlands: salary as numbers, hiring signals, monitoring
- [SEEK Scraper](https://apify.com/tsutseisoftware/seek-scraper): jobs from SEEK in Australia and New Zealand: salary as numbers, past the 550-job limit, hiring signals, removed jobs
- [Welcome to the Jungle Scraper](https://apify.com/tsutseisoftware/welcome-to-the-jungle-scraper): jobs from Welcome to the Jungle in France, Europe and the US: salary as numbers, company profile, closed jobs, alerts
- [Arbeitsagentur Jobbörse Scraper](https://apify.com/tsutseisoftware/arbeitsagentur-scraper): jobs from the Jobbörse of the Bundesagentur für Arbeit, Germany's largest job board: salary as numbers, employer profiles, removed jobs, alerts
- [LinkedIn Jobs Scraper](https://apify.com/tsutseisoftware/linkedin-jobs-scraper): public LinkedIn jobs in any country without login: salary as numbers, seniority, applicants, hiring signals, new and removed jobs, alerts
- [Career Site Job Search & Scraper](https://apify.com/tsutseisoftware/ats-jobs-scraper): jobs straight from company career sites on Greenhouse, Workday, Lever, Ashby and SmartRecruiters in any country, including the jobs that just closed

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

#### Is it legal to scrape XING?

It reads only publicly available job ads, without logging in, at most 90 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It returns contacts only if you turn on **Contacts (paid option)** (then you are responsible for using them lawfully) and always removes e-mails, phone numbers and the names of contact persons from the texts. The website's terms of use may restrict extracting its data; you are responsible for how you use the data (privacy laws, database rights and the website's terms). If in doubt, consult a lawyer. This actor is not affiliated with XING or New Work SE.

#### Why is the company empty for some jobs?

The employer name is a private person's name (a practice or a sole trader). For privacy the name, logo, company page and street are left out.

#### Is the salary the employer's?

Only when `salarySource` is `employer`. For many jobs XING shows its own estimate (`salarySource: "estimate"`, with `salaryMedian`); it is a useful market figure, not an offer.

#### Do I need a proxy?

No. The default setting works and costs you nothing extra.

#### Can I use it from an AI agent or through MCP?

Yes. Use **Compact output** for smaller rows, and call the actor through the Apify API or Apify's MCP server.

Also known as a XING API, XING job scraper, XING Stellenangebote export, XING Jobs Crawler or "XING Jobs Scraper Deutschland".

# Changelog

This Actor's version history is a separate document: https://apify.com/tsutseisoftware/xing-jobs-scraper/changelog.md

# Actor input Schema

## `searchQueries` (type: `array`):

What to search for, as on xing.com (job title, skill, company…), e.g. "developer", "Pflege", "SAP Berater". Each keyword is one search (combined with every location). Leave empty to search by location and filters only.

## `locations` (type: `array`):

City, region or country as you would type it on xing.com, e.g. "Berlin", "München", "Wien", "Zürich". Each location is combined with every keyword. Empty = everywhere.

## `startUrls` (type: `array`):

Paste URLs from xing.com: a job search (https://www.xing.com/jobs/search?keywords=developer\&location=Berlin, its keyword, location, radius, employment type, career level, remote and date filters are used) or a job page (https://www.xing.com/jobs/berlin-senior-developer-159044114). The filters below apply to the searches too.

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

Maximum number of jobs saved. You pay per saved job. 0 = no limit (every job of the searches, also past the 1 000 jobs the website shows for one search).

## `maxItemsPerSearch` (type: `integer`):

Maximum number of jobs saved from each search (keyword × location or URL). 0 = no limit per search.

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

Only jobs of these employment types (the website's filter). Empty = all.

## `careerLevels` (type: `array`):

Only jobs of these career levels (the website's filter). Empty = all.

## `remoteOptions` (type: `array`):

Only jobs with these remote options (the website's filter). Empty = all.

## `radiusKm` (type: `integer`):

Search around each location within this distance. Empty = the website's default.

## `minYearlySalary` (type: `integer`):

Only jobs whose yearly salary (the employer's or the website's estimate) reaches this amount (the website's filter).

## `postedWithin` (type: `string`):

Only jobs published or refreshed in this period. Empty = any time.

## `labelLanguage` (type: `string`):

Language of the employment type, career level, discipline, industry and country labels. Job titles and descriptions stay as the employer wrote them.

## `descriptionFormat` (type: `string`):

Format of the description: plain text, simple HTML or Markdown (good for AI agents and Notion).

## `descriptionMaxLength` (type: `integer`):

Cut the description after about this many characters (0 = full description). Smaller rows for spreadsheets and AI agents.

## `compactOutput` (type: `boolean`):

Only the core fields (title, company, place, country, remote, employment type, career level, salary, date, apply link, URL) plus the fields of the options you turned on. Smaller rows for AI agents, MCP clients and spreadsheets.

## `includeContacts` (type: `boolean`):

Add the contact person, e-mail addresses and phone numbers the ad itself shows (contactNames, contactEmails, contactPhones). Never for private persons as employers. These are personal data: you are responsible for using them lawfully (GDPR). A saved job with at least one contact is the "Contact details" event ($0.40 per 1 000 jobs with a contact, from 2026-11-15). Off by default; descriptions never contain contacts.

## `onlyNewOrChanged` (type: `boolean`):

Return only jobs that are new or whose title, company, places, remote option, employment type, career level or salary changed since the previous run with the same Monitoring key. Unchanged jobs are free; every search answer read in this mode (up to 20 jobs each) is the "Monitoring page" event ($0.25 per 1 000 answers, from 2026-11-15).

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched search (e.g. "developer-berlin"). Empty = "default". The value is stored encrypted.

## `includeRemovedJobs` (type: `boolean`):

With "Monitoring: only new or changed jobs": also return jobs of earlier runs that are no longer in the results, as rows with changeType "removed" and removedReason "expired" (the job was closed) or "noLongerMatches" (still published but no longer matching the search), with daysOnline. Checked only when every search was read to its end; a removed job is a saved row.

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

After each run, send the saved jobs (in monitoring mode only the new, changed and removed ones) to Telegram, Slack, Discord, WhatsApp or your webhook: title, company, place, salary and link. A run that sent its notification is the "Notification" event ($0.001 per run, from 2026-11-15). Token of your bot from @BotFather.

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

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...).

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

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

Any HTTPS URL (Zapier, Make, n8n…): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many jobs are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no job (e.g. a monitoring run without new jobs).

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

No proxy by default: the website answers the platform's servers directly, so you pay nothing for a proxy. Change it only if the website starts rejecting requests.

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "searchQueries": [
    "developer"
  ],
  "locations": [
    "Berlin"
  ],
  "maxItems": 20,
  "maxItemsPerSearch": 0,
  "labelLanguage": "en",
  "descriptionFormat": "text",
  "descriptionMaxLength": 0,
  "compactOutput": false,
  "includeContacts": false,
  "onlyNewOrChanged": false,
  "includeRemovedJobs": false,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

## `jobs` (type: `string`):

The saved jobs (one row per job), in the run's default dataset.

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

Free summary of the jobs the run found: yearly salary quartiles per currency (employer salaries and estimates apart, by country, employment type, career level, remote option and discipline), top companies, cities, disciplines, industries, employment types and career levels.

# 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 = {
    "searchQueries": [
        "developer"
    ],
    "locations": [
        "Berlin"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/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 = {
    "searchQueries": ["developer"],
    "locations": ["Berlin"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/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 '{
  "searchQueries": [
    "developer"
  ],
  "locations": [
    "Berlin"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,tsutseisoftware/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/qwENNWfHHue5KPJRF/builds/wFPtB9HCCRf85SAKo/openapi.json
