# XING Jobs Scraper - DACH Job Ads, Salaries & Hiring API (`rel8ble/xing-jobs-scraper`) Actor

Use this to get job ads from XING (Germany, Austria, Switzerland). Input: keywords, cities, filters or XING URLs. One result = one job: title, company, location, salary, employment type, career level, remote, date, URL; optional full description. Past the 1,000 cap. $0.60 per 1,000.

- **URL**: https://apify.com/rel8ble/xing-jobs-scraper.md
- **Developed by:** [Giovanni Rich](https://apify.com/rel8ble) (community)
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$0.60 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

Learn more: https://docs.apify.com/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 & API - job ads from Germany, Austria and Switzerland (salaries, career level, remote)

**XING Jobs Scraper** is a XING scraper and unofficial XING jobs API for the DACH job market. Give it keywords, cities and filters (or paste XING search, landing-page or job URLs) and get every matching job ad on www.xing.com/jobs as clean JSON, CSV or Excel: title, company (with size, industry and XING page), location down to the postal code, salary (stated in the ad or XING's own estimate), full-time / part-time / freelance, career level, job field, industry, remote / hybrid / on-site, posting and expiry dates, the apply link and, if you want it, the full job description.

It reads the same JSON the XING website loads, over plain HTTP: no browser, no login and no XING account. XING returns at most 1,000 jobs for any one search; this scraper **splits big searches automatically** by job field, career level, employment type and remote option and merges the results without duplicates. In testing, every job in Hamburg (22,107 listed) returned 21,888 unique jobs (99%) in 40 seconds.

Use it for **recruiting and staffing lead generation in Germany, Austria and Switzerland** (which companies are hiring SAP consultants or nurses in Munich this week), job boards and aggregators, salary benchmarking in EUR and CHF, sales prospecting on hiring signals, and DACH labour-market research.

### How to use

1. Type one or more **Search keywords** (`software engineer`, `Pflegefachkraft`, `Vertrieb`, `SAP`) and, optionally, **Cities** (`Berlin`, `München`, `Hamburg`, `Wien`, `Zürich`). Every keyword is searched in every city. No keyword = all jobs matching your cities and filters.
2. Optionally filter: **Remote / hybrid / on-site**, **Employment types**, **Career levels**, **Job fields**, **Industries**, **Posted within (days)**, **Minimum yearly salary**, **Countries**, **Radius**. Tick **Exact keyword matches only** if you want only ads that contain your keyword (XING matches by meaning).
3. Set **Max jobs per search** (0 = everything). Tick **Include full description** if you need the ad text.
4. Click **Start**. Download the results as JSON, CSV, Excel or HTML from the **Output** tab, or pull them through the Apify API, Make, Zapier, n8n or an MCP client.

Already have links? Paste XING **search URLs**, **landing pages** (`https://www.xing.com/jobs/t-python`, `https://www.xing.com/jobs/l-berlin`) or **job URLs** into *XING URLs* instead; the filters in a search URL are read from the URL.

### What you get

One dataset item per job ad:

- **Identity**: `id` (XING job id, stable across runs), `xingId`, `title`, `url`.
- **Company**: `companyName`, `companyId`, `companyUrl` (XING company page), `companyLogoUrl`, `companySize` ("51-200 employees"), `companyIndustry`, `companyCity`, `companyCountry`.
- **Where**: `location`, `city`, `postalCode`, `region`, `street` (workplace address when given), `countryCode`, `country`, `additionalLocations`, `isRemote`, `workplaceTypes` (Remote, Hybrid, On-site).
- **Work**: `employmentType` (Full-time, Part-time, Self-employed, Student, Temp, ...), `careerLevel` (Entry Level ... Senior Executive), `discipline` (XING's 22 job fields), `industry`.
- **Pay**: `salaryMin`, `salaryMax`, `salaryMedian`, `salaryCurrency` (EUR, CHF), `salaryPeriod` (year) and `salarySource`: `employer` when the ad states the pay, `xing-estimate` when it is XING's estimate.
- **Dates**: `postedAt`, `refreshedAt`, `expiresAt`.
- **Applying**: `applyType` (external, xing), `applyUrl` (the employer's application page), `redirectsToExternalSite`.
- **Extras**: `isPaidAd`, `isTopJob`, `adLanguage` (de / en / ...), `jobCode` (the employer's reference), `keywords`, `highlights` (XING's short summary of the main tasks).
- **Where it came from**: `sourceQuery`, `sourceLocation`, `position`, `scrapedAt`.

With **Include full description** on, each job also gets `description` (plain text), optional `descriptionHtml`, `introduction` and `qualifications` (XING's summary), `descriptionUrl` (for ads hosted elsewhere), `companyDescription`, `companyWebsite` and `companyKununuUrl` (employer reviews). It comes in the same request, so it is just as fast and costs the same.

### Use cases

- **Staffing and recruiting lead generation (DACH)**: a company posting three SAP roles in Munich needs people now. Run daily with *Posted within 1 day* and send new ads to your CRM with the company size, XING page and apply link attached.
- **Sales prospecting on hiring signals**: companies hiring their first "Head of Data" or ten warehouse workers are buying tools and services. Filter by job field, career level and industry.
- **Salary benchmarking**: `salaryMin` / `salaryMax` by job field, career level, city and country, in EUR and CHF, with `salarySource` telling stated pay from XING estimates.
- **Job boards and aggregators**: pull a job field or a whole city into your own feed, deduplicated by `id`.
- **Labour-market research**: demand by job field, remote share, freelance share, German vs English ads, over time.
- **AI agents**: "find hybrid Python jobs in Berlin posted this week paying over 70,000 EUR" maps straight onto the input fields.

### Input example

| Field | Default | Description |
|---|---|---|
| `searchQueries` | - | Keywords, one search each. Empty = all jobs matching the filters |
| `strictKeywordMatch` | false | Keep only ads whose title or XING keywords contain the keyword |
| `locations` | all of XING | Cities and towns: `Berlin`, `München`, `Wien`, `Zürich` |
| `radius` | 20 | Kilometres around each city; 0 = the city only |
| `countries` | all | Any of `DE`, `AT`, `CH`, `LU` (applied after the search) |
| `postedWithinDays` | 0 (any) | Published or refreshed in the last N days |
| `workplaceTypes` | all | Any of `remote`, `hybrid`, `onsite` |
| `employmentTypes` | all | Any of `fulltime`, `parttime`, `freelance`, `student`, `seasonal`, `temporary`, `volunteer` |
| `careerLevels` | all | Any of `student`, `entry`, `professional`, `manager`, `director`, `executive` |
| `disciplines` | all | XING's 22 job fields, e.g. `it-software`, `sales`, `health-social`, `finance-accounting` |
| `industries` | all | XING's 23 industry groups, e.g. `internet-it`, `banking-finance`, `automotive` |
| `salaryMin` / `salaryMax` | 0 | Yearly salary range (stated or estimated) |
| `language` | `en` | Labels in English or German (`de`) |
| `maxItems` | 100 | Max jobs per search; 0 = all |
| `deepSearch` | true | Split searches above 500 jobs so nothing is cut off at 1,000 |
| `includeDetails` | false | Full description, summary, company description and website (no extra requests) |
| `includeDescriptionHtml` | false | Also keep the description HTML |
| `startUrls` | - | XING search URLs, landing pages or job URLs |
| `proxyConfiguration` | Apify datacenter | No residential proxies needed |

Experienced Python and data jobs in Munich and Vienna, hybrid or remote, posted in the last two weeks, at least 60,000 a year:

```json
{
    "searchQueries": ["python", "data engineer"],
    "locations": ["München", "Wien"],
    "workplaceTypes": ["remote", "hybrid"],
    "careerLevels": ["professional", "manager"],
    "postedWithinDays": 14,
    "salaryMin": 60000,
    "maxItems": 200,
    "includeDetails": true
}
```

Every job in Hamburg, no cap:

```json
{
    "locations": ["Hamburg"],
    "maxItems": 0
}
```

Every sales job in Vienna, Zurich and Graz posted this week, labels in German:

```json
{
    "disciplines": ["sales"],
    "locations": ["Wien", "Zürich", "Graz"],
    "postedWithinDays": 7,
    "language": "de",
    "maxItems": 0
}
```

From links you copied off the site:

```json
{
    "startUrls": [
        "https://www.xing.com/jobs/search?keywords=python&location=Berlin&employmentType=FULL_TIME.ef2fe9",
        "https://www.xing.com/jobs/t-controller",
        "https://www.xing.com/jobs/berlin-senior-software-engineer-157369813"
    ]
}
```

### Output example

From a real run (search for `data scientist` in `Zürich`, details on; long texts shortened):

```json
{
    "id": "158550594",
    "xingId": "158550594.a0c65f",
    "title": "Cloud Data Solutions Specialist (m/w/d)",
    "url": "https://www.xing.com/jobs/zuerich-cloud-data-solutions-specialist-158550594",
    "companyName": "ROCKEN",
    "companyId": "2025879.f36256",
    "companyUrl": "https://www.xing.com/pages/rocken-ag",
    "companyLogoUrl": "https://www.xing.com/imagecache/public/scaled_original_image/eyJ1dWlkIjoiZjJhMWY4NGUt...",
    "companySize": "51-200 employees",
    "companyIndustry": "HR services and consulting",
    "companyCity": "Zürich",
    "companyCountry": "Switzerland",
    "location": "Zürich, Kanton Zürich, Switzerland",
    "city": "Zürich",
    "postalCode": "8001",
    "region": "Kanton Zürich",
    "street": "Zürich",
    "countryCode": "CH",
    "country": "Switzerland",
    "additionalLocations": [],
    "isRemote": false,
    "workplaceTypes": ["Hybrid"],
    "employmentType": "Full-time",
    "careerLevel": "Professional/Experienced",
    "discipline": "IT and software development",
    "industry": "Internet and IT",
    "salaryMin": 102000,
    "salaryMax": 131500,
    "salaryMedian": 115000,
    "salaryCurrency": "CHF",
    "salaryPeriod": "year",
    "salarySource": "xing-estimate",
    "postedAt": "2026-10-14T11:13:15.000Z",
    "refreshedAt": "2026-10-14T11:13:15.000Z",
    "expiresAt": "2026-11-13T11:15:52.000Z",
    "applyType": "external",
    "applyUrl": "https://rocken.jobs/application/APq4VyNdD7Q_cloud-data-solutions-specialist?utm_source=xing&utm_medium=cpc&utm_campaign=sponsored",
    "redirectsToExternalSite": false,
    "isPaidAd": true,
    "isTopJob": false,
    "adLanguage": "de",
    "jobCode": "550312",
    "keywords": ["engineer", "ci", "cd", "etl", "sql", "mysql", "python", "bim", "rocken", "zürich"],
    "highlights": [
        "Entwicklung der unternehmensweiten Datenumgebung.",
        "Entwurf von Datenmodellen und -architekturen.",
        "Automatisierung der Datenverarbeitung durch Pipelines."
    ],
    "sourceQuery": "data scientist",
    "sourceLocation": "Zürich",
    "position": 13,
    "scrapedAt": "2026-10-15T17:36:44.132Z",
    "introduction": "Ein Rocken Partner sucht einen Data Engineer in Zürich. Das Unternehmen entwickelt innovative Immobilienlösungen mit Fokus auf Nachhaltigkeit und Effizienz.",
    "qualifications": ["Studium in Informatik oder Data Science.", "Erfahrung mit ETL-/ELT-Verfahren erforderlich.", "Kenntnisse in SQL und Python notwendig."],
    "description": "Wie entstehen Immobilienprojekte, die Regionen nachhaltig prägen? Unser Rocken Partner entwickelt und realisiert wegweisende Immobilienlösungen – von der ersten Idee bis zur finale ...",
    "descriptionUrl": null,
    "companyDescription": null,
    "companyWebsite": "https://rocken.jobs/",
    "companyKununuUrl": "https://www.kununu.com/ch/rocken2"
}
```

Fill rates on a 21,888-job test run (every job in Hamburg): id, title, URL, company name, location, city, country, employment type, career level, job field, industry, workplace type, dates, apply type, ad language and keywords 100%; region 99%; company page details (id, logo, industry) 82%, company size 69%; salary 81% (20% stated by the employer, 61% XING estimates); external apply link 59%; employer reference code 64%; postal code 43%; XING highlights 37%; street 28%. On a 160-job run with details: description 100%; XING introduction and qualifications 22%; company website 19%; kununu link 6%. A field XING does not publish for a job is `null`, never guessed.

### Pricing

Pay per result: **$0.60 per 1,000 jobs** (one result = one job ad saved to the dataset). The full description is included in that price.

- 100 jobs for a quick search = $0.06
- Every job in Hamburg, about 21,900 jobs = $13.13
- A daily run of 10 keywords, new jobs only (about 500 jobs) = $0.30 a day

No start fee and no charge per search. Failed requests, duplicate ads, expired job URLs, empty searches and jobs skipped by the country or exact-keyword filters are never charged. If you set a maximum cost per run, the scraper stops cleanly when it reaches it. Apify's free plan includes $5 of monthly platform credit, enough for about 8,000 jobs.

### Integrations

- **Apify API**: run the actor and fetch results over REST, or with the official [Python](https://docs.apify.com/api/client/python) and [JavaScript / Node.js](https://docs.apify.com/api/client/js) clients.
- **MCP for AI agents**: through the Apify MCP server (https://mcp.apify.com), Claude, ChatGPT, Cursor and other agents can call this XING jobs API directly and read the results. The input fields are described for agents.
- **Make, Zapier and n8n**: start runs and push new jobs to your CRM, Slack, Google Sheets or Airtable.
- **Webhooks**: get notified when a run finishes and process the data right away.
- **Schedules**: run daily with `postedWithinDays: 1` and deduplicate by `id` to collect only new ads.
- **Google Sheets**: export the dataset straight into a spreadsheet, or refresh it on a schedule.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("rel8ble/xing-jobs-scraper").call(run_input={
    "searchQueries": ["SAP Berater"],
    "locations": ["München", "Frankfurt am Main"],
    "postedWithinDays": 7,
    "maxItems": 100,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], "|", job["companyName"], "|", job["city"], "|", job["salaryMin"], job["salaryCurrency"], "|", job["url"])
```

### Limits (read before large runs)

- **1,000 jobs per single search** is XING's own limit, and its paging repeats some ads on big searches. Deep search splits any search above 500 jobs into narrower ones; a slice that is still above 1,000 after every split is paged to the limit and counted in the run summary (`searchesCappedAt1000`). On the largest test (every job in Hamburg) 99% of the listed jobs came back.
- **XING searches by meaning.** `Controller` also returns related finance and consulting roles (about 4 in 10 results in testing). Turn on `strictKeywordMatch` to keep only ads whose title or XING keywords contain your keyword; the skipped ads are not charged. For keyword searches XING only reports "1,000+" as the total, so the run summary shows `siteTotalIsLowerBound`.
- **Cities, not countries.** XING's public search has no country filter. `countries` is applied to each job after the search, so "all of Switzerland" pages through jobs from everywhere (fine for small numbers; for big pulls, list a few Swiss cities instead). A city XING does not recognise returns 0 jobs and the run summary says so (XING itself would silently search everything).
- **Remote filter and cities.** With `workplaceTypes: ["remote"]`, XING also returns fully remote jobs from other cities for a city search, because they can be done from there.
- **Salaries are mostly estimates.** About a fifth of ads state a salary; XING estimates the rest. `salarySource` tells them apart. Figures are yearly gross amounts.
- **No sort order.** XING's API ignores the sort parameter (tested with a dozen values, including date and relevance), so results come in XING's relevance order. Use `postedWithinDays` to get the newest jobs.
- **No personal data.** Contact-person blocks are not requested, e-mail apply addresses and recruiter profiles are never returned, and e-mail addresses and phone numbers written inside the ad text are replaced with `[email removed]` / `[phone removed]`. Names written inside the free text of an ad can still appear there.

### FAQ

**Is there an official XING API for job search?**
XING offers no public API for reading its job ads. This actor is an unofficial alternative that reads the public job search, without a login.

**Do I need a XING account or cookies?**
No. Everything comes from the public, logged-out job search.

**How do I get only new jobs every day?**
Schedule the actor daily with `postedWithinDays: 1` and deduplicate on `id` in your own system. XING counts refreshed ads as new, so some older ads come back when they are republished; `postedAt` shows the first publication date.

**Can I get English labels for German ads?**
Yes: `language: "en"` (default) returns the employment type, career level, job field, industry and country in English. The ad text stays in the language the employer wrote it in; `adLanguage` tells you which.

**Why did I get fewer jobs than XING's count?**
XING's count includes ads that appear twice across pages and moves while a big run is going; duplicates are dropped and not charged. Check `RUN_SUMMARY` in the key-value store: it lists each search with the site total, pages fetched and why it stopped.

**Is scraping XING legal?**
The actor collects publicly visible job ads, not personal data. You are responsible for how you use the data and for following XING's terms and the laws that apply to you (including the GDPR).

**Something is wrong or a field is missing.**
Open an issue on the Issues tab of the actor page with the run ID. It reaches the developer directly.

# Actor input Schema

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

Optional. Job keywords as typed into the XING search box, one per line, in German or English: "software engineer", "Pflegefachkraft", "Vertrieb", "SAP". A skill, job title or company name all work; XING matches by meaning, so close variants are included. Each keyword is one search and returns up to maxItems jobs. Leave empty to list all jobs matching the locations and filters below. Give at least one of searchQueries, locations, a filter or startUrls.

## `strictKeywordMatch` (type: `boolean`):

Optional boolean, default false. XING's search matches by meaning, so "Controller" also returns related finance and consulting roles (about 4 in 10 results in testing). true = keep only jobs whose title or XING keywords contain every word of the search keyword; the others are skipped and not charged (they still take requests). Has no effect on searches without keywords.

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

Optional. Cities or towns to search around, one per line: "Berlin", "München", "Hamburg", "Wien", "Zürich". Each one is matched with XING's own city lookup (the first match is used and named in the log). Every keyword is searched in every city (2 keywords x 3 cities = 6 searches). Empty = all of XING. A place XING does not recognise returns 0 jobs and is named in the run summary (it is not silently widened). For a whole country use countries instead.

## `radius` (type: `integer`):

Optional. Distance in kilometres around each city in locations, integer 0-200. Default 20 (what XING's own city pages use). 0 = only jobs in the city itself. Ignored when locations is empty.

## `countries` (type: `array`):

Optional. Keep only jobs located in these countries: any of "DE", "AT", "CH", "LU". XING's search has no public country filter, so this is applied to each job's country after the search (skipped jobs are not charged, but they still take requests). For one country's jobs, combining it with a few cities is faster. Empty = all.

## `postedWithinDays` (type: `integer`):

Optional. Only jobs published or refreshed in the last N days, integer >= 0, applied by XING itself (any number works). 0 (default) = any date. Use 1 on a daily schedule to collect only new jobs.

## `workplaceTypes` (type: `array`):

Optional. Keep only these workplace settings: any of "remote" (fully remote), "hybrid" (partly remote), "onsite". Empty = all.

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

Optional. Keep only these employment types: any of "fulltime", "parttime", "freelance" (self-employed / contractor), "student" (working student, internship), "seasonal", "temporary", "volunteer". Empty = all.

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

Optional. Keep only these career levels: any of "student" (student / intern), "entry" (entry level), "professional" (experienced), "manager", "director" (VP, head of), "executive" (CEO, managing director). Empty = all.

## `disciplines` (type: `array`):

Optional. Keep only jobs in these job fields (XING's 22 disciplines): "analysis-statistics", "administration", "consulting", "customer-service", "purchasing-logistics", "finance-accounting", "research-teaching", "health-social", "design-architecture", "engineering", "it-software", "management", "marketing", "hr", "pr-journalism", "production-trades", "product-management", "project-management", "quality-process", "legal", "sales", "other". Use \["sales"] with no keyword to list every sales job. Empty = all.

## `industries` (type: `array`):

Optional. Keep only jobs at employers in these industries (XING's 23 industry groups, each with its sub-industries): "architecture-construction", "consumer-goods-retail", "automotive", "industry-engineering", "pharma-medtech", "energy-environment", "transport-logistics", "tourism-hospitality", "internet-it", "telecommunications", "media-publishing", "banking-finance", "insurance", "real-estate", "audit-tax-law", "consulting", "marketing-pr-design", "hr-services", "public-sector", "education-science", "health-social", "art-culture-sport", "other". Empty = all.

## `salaryMin` (type: `integer`):

Optional. Only jobs whose yearly salary reaches at least this amount (in the job's currency, usually EUR), integer >= 0. XING applies it to the salary in the ad or, when the ad gives none, to XING's own estimate. 0 (default) = no salary filter.

## `salaryMax` (type: `integer`):

Optional. Upper end of the yearly salary filter, integer >= 0. 0 (default) = no upper limit. Only used together with salaryMin or on its own as a cap.

## `language` (type: `string`):

Optional. Language of the labels XING returns (employment type, career level, job field, industry, country): "en" (default) or "de". The ad text itself stays in whatever language the employer wrote it (see adLanguage).

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

Optional. Maximum jobs saved per search (one keyword in one city), integer >= 0. Default 100; 0 = every job the search has. You pay per job saved ($0.0006 each), so 100 jobs = $0.06. Use 10-20 for a quick answer.

## `deepSearch` (type: `boolean`):

Optional boolean, default true. XING returns at most 1,000 jobs for any one search, and its paging gets unreliable on big searches. With deep search on, a search with more than 500 jobs is split automatically by job field, career level, employment type and remote option, and the results are merged without duplicates. Only kicks in when maxItems is above 500 (or 0). It costs extra requests, not extra money per job.

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

Optional boolean. false (default) = listing data: title, company, location, salary, employment type, career level, job field, industry, remote option, dates, apply link, keywords and highlights. true = also the full job description (plain text), the AI summary (introduction and qualifications), the company description, website and kununu link. Comes in the same request (no extra requests), same price per result; pages are about 3x bigger.

## `includeDescriptionHtml` (type: `boolean`):

Optional boolean. Only used with includeDetails or job URLs. true = add descriptionHtml (the original formatting) next to the plain-text description. Default false.

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

Optional. URLs copied from www.xing.com, one per line. A search URL ("https://www.xing.com/jobs/search?keywords=python\&location=Berlin\&employmentType=FULL_TIME.ef2fe9") is scraped with the filters in the URL (the filter fields above are not applied to it). A jobs landing page ("https://www.xing.com/jobs/t-python", "https://www.xing.com/jobs/l-berlin") runs the search that page shows. A job URL ("https://www.xing.com/jobs/berlin-senior-software-engineer-157369813") or a bare job id is looked up directly and always includes the full description. Expired jobs are listed in the run summary and are not charged.

## `maxConcurrency` (type: `integer`):

Optional, advanced. Number of parallel requests, integer 1-30. Default 10. Leave unset.

## `maxRequestRetries` (type: `integer`):

Optional, advanced. Retries per failed or blocked request, integer 0-20; each retry uses a new session and IP. Default 8. Leave unset.

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

Optional, advanced. Apify Proxy settings object. Default {"useApifyProxy": true} (datacenter proxies are enough). Leave unset.

## Actor input object example

```json
{
  "searchQueries": [
    "software engineer"
  ],
  "strictKeywordMatch": false,
  "locations": [
    "Berlin"
  ],
  "radius": 20,
  "postedWithinDays": 0,
  "salaryMin": 0,
  "salaryMax": 0,
  "language": "en",
  "maxItems": 20,
  "deepSearch": true,
  "includeDetails": false,
  "includeDescriptionHtml": false,
  "maxConcurrency": 10,
  "maxRequestRetries": 8,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All jobs found: title, company (name, size, industry, XING page), location, salary (stated or XING estimate), employment type, career level, job field, industry, remote option, dates and job URL (plus the full description and company description when includeDetails is on).

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

Per-search counts, the totals XING reported, how many narrower searches deep search ran, stop reasons and the list of anything that failed.

# 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": [
        "software engineer"
    ],
    "locations": [
        "Berlin"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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