# XING Jobs Scraper — Germany, Austria & Swiss Jobs | $0.60/1k (`glasswing/xing-jobs-scraper`) Actor

Scrape XING jobs in Germany, Austria and Switzerland by keyword, city or search URL. Company, location, remote, employment type, career level, salary (employer or XING estimate), date, full description. CSV, JSON, Excel.

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

## Pricing

from $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

### What does XING Jobs Scraper do?

XING Jobs Scraper extracts **job postings from XING**, the professional network of Germany, Austria and Switzerland (DACH), and delivers them as clean JSON, CSV or Excel. Paste XING job search URLs, or type keywords such as `Softwareentwickler` or `Pflegefachkraft` and cities such as `Berlin`, `Wien` or `Zürich`, and get one row per job: title, company, XING company page, location, remote/hybrid/on-site, employment type, career level, industry, salary (the employer's range or XING's estimate, labelled), posting date, full description and the employer's apply link.

It works as a **XING jobs API alternative**: no XING account, no login, no browser and no residential proxy. It reads the same public, logged-out job search that xing.com shows to every visitor.

### Use cases for this XING job scraper

- **Recruiting and staffing agencies:** find companies hiring for the roles you place, by city, career level and employment type, and build lead lists from the company names and XING company pages.
- **Salary benchmarking in the DACH region:** collect employer salary ranges and XING's salary estimates for a role across Berlin, Munich, Vienna or Zurich.
- **Labour-market research and job boards:** track how many postings appear per city, industry or remote option, or feed fresh German-language jobs into your own product.
- **AI agents and automations:** a scheduled daily run with `postedWithinDays: 1` gives a clean "new today" feed.

### What data you get from every XING job posting

| Field | Type | Description |
|---|---|---|
| `jobId` | string | XING's numeric posting id (the number at the end of the job URL) |
| `url` | string | Public XING job page |
| `title` | string | Job title as published by the employer |
| `companyName` | string | Hiring company as shown on the posting |
| `companyUrl` | string | XING company page, when the posting links one |
| `companyLogo` | string | Company logo image URL |
| `location` | string | Main location as "City, Country" |
| `city`, `region`, `postalCode` | string | Parts of the main location (postal code when the employer gives one) |
| `country`, `countryCode` | string | Country name and ISO code (`DE`, `AT`, `CH`, ...) |
| `locations` | array | Every location of a multi-location posting, as "City, CC" |
| `workplace` | array | `Remote`, `Hybrid`, `On-site` |
| `isRemote` | boolean | True when the posting offers fully remote work |
| `employmentType` | string | Label such as "Full-time" or "Part-time" |
| `employmentTypeCode` | string | Stable code: `FULL_TIME`, `PART_TIME`, `CONTRACTOR`, `INTERN`, `SEASONAL`, `TEMPORARY`, `VOLUNTARY` |
| `careerLevel` | string | Label such as "Professional/Experienced" or "Manager/Supervisor" |
| `industry` | string | Industry of the employer |
| `discipline` | string | Job discipline, e.g. "IT and software development" |
| `salaryMin`, `salaryMax` | number | Salary range (annual gross) |
| `salaryMedian` | number | Middle of XING's estimate (estimates only) |
| `salaryCurrency` | string | `EUR` or `CHF` |
| `salaryPeriod` | string | Always `yearly`: XING shows annual gross salaries |
| `salarySource` | string | `employer` = the employer states it; `xing_estimate` = XING's own estimate |
| `postedAt` | string | ISO 8601 time the posting went live |
| `refreshedAt` | string | ISO 8601 time the posting was last refreshed |
| `expiresAt` | string | ISO 8601 time the posting stops being active |
| `descriptionText` | string | Full job description as plain text (e-mail addresses and phone numbers removed) |
| `language` | string | Language of the posting text (`de`, `en`, ...) |
| `tags` | array | Keyword tags XING attached to the posting |
| `applyUrl` | string | Employer's own application page, when the posting links one |
| `applicationType` | string | `external` (employer site), `xing` (apply on XING), `email` or `message` |
| `isPromoted` | boolean | True for paid or top-job postings |
| `searchKeyword`, `searchLocation` | string | The search that found the job |
| `status` | string | `ok`, `not_found` or `error` (see below) |
| `error` | string | Reason when `status` is not `ok` |
| `scrapedAt` | string | ISO 8601 time of extraction |

Optional fields are left out when XING does not publish them for a posting (for example about a quarter of postings show no salary at all). Labels come in English by default; set `language` to `de` for XING's German labels. Job texts always stay in the language the employer wrote them in.

#### Result status (tri-state output)

| `status` | Meaning | Billed? |
|---|---|---|
| `ok` | The job was found and extracted. | Yes |
| `not_found` | XING answered, but the search has no jobs, or the job id no longer exists. The row names the search or job. | No |
| `error` | XING could not be read after retries. `error` says why. | No |

A run that finds nothing still ends successfully with its free `not_found` rows, so a scheduled search that is empty today does not show up as a failed run.

### How to scrape XING jobs with this Actor

1. Open the Actor in Apify Console and click **Try for free**.
2. Paste XING job search URLs into **XING search or job URLs** (copy them from xing.com after setting your filters), or type **Keywords** and **Locations**.
3. Optionally narrow the search: workplace, remote only, employment types, career levels, posted within, salary range, only jobs with an employer salary.
4. Set **Maximum results** (start with the default 20) and click **Start**. The default run takes about 5 seconds.
5. Open the **Output** tab or **Export** the dataset as JSON, CSV, Excel, XML or HTML.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | one example search | xing.com job search URLs (every filter in the URL is kept), job page URLs or bare job ids |
| `keywords` | array | - | Search terms; each is searched in every location |
| `locations` | array | - | Cities or regions, e.g. `Berlin`, `München`, `Wien`, `Zürich` |
| `radius` | integer | - | Kilometres around each location |
| `workplace` | array | - | `remote`, `hybrid`, `onsite` |
| `remoteOnly` | boolean | `false` | Shortcut for fully remote jobs |
| `employmentTypes` | array | - | `FULL_TIME`, `PART_TIME`, `CONTRACTOR`, `INTERN`, `SEASONAL`, `TEMPORARY`, `VOLUNTARY` |
| `careerLevels` | array | - | `STUDENT_INTERN`, `ENTRY_LEVEL`, `PROFESSIONAL`, `MANAGER`, `DIRECTOR`, `EXECUTIVE` |
| `postedWithinDays` | integer | - | 1, 7 or 30 (XING's buckets; other values round up) |
| `salaryMin`, `salaryMax` | integer | - | XING's salary filter, annual gross in EUR |
| `employerSalaryOnly` | boolean | `false` | Keep only jobs whose salary comes from the employer |
| `fetchDetails` | boolean | `true` | Include `descriptionText` (no extra requests; off = smaller rows) |
| `language` | string | `en` | Label language: `en` or `de` |
| `maxItems` | integer | `20` | Stop after this many rows in total |
| `maxItemsPerSearch` | integer | - | Cap per search URL or keyword x location |
| `proxyConfiguration` | object | off | Not needed; datacenter proxy only if you ever see blocking |

Filters apply to keyword searches and fill in whatever a pasted search URL does not already set. When you use Keywords or Locations and leave the example URL in place, the example is skipped automatically.

Example input:

```json
{
    "keywords": ["Softwareentwickler", "Data Scientist"],
    "locations": ["Berlin", "Wien", "Zürich"],
    "workplace": ["remote", "hybrid"],
    "postedWithinDays": 7,
    "maxItems": 500,
    "maxItemsPerSearch": 100
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. A real row from a run on Apify (description and tags shortened):

```json
[
    {
        "url": "https://www.xing.com/jobs/hamburg-softwareentwickler-java-backend-bereich-digitale-identitaeten-157877077",
        "status": "ok",
        "scrapedAt": "2026-09-27T23:45:49.402Z",
        "jobId": "157877077",
        "title": "Softwareentwickler (m/w/d) Java/ Backend im Bereich Digitale Identitäten",
        "companyName": "APRIORI – BUSINESS SOLUTIONS AG",
        "companyUrl": "https://www.xing.com/pages/apriori-businesssolutionsag",
        "companyLogo": "https://www.xing.com/imagecache/public/scaled_original_image/eyJ1dWlkIjoiZDNjZDUyYWEtYjAwMy00NzkyLTgxN2YtNzMzNTM1NzU0NjkyIiwiYXBwX2NvbnRleHQiOiJlbnRpdHktcGFnZXMiLCJtYXhfd2lkdGgiOjk2LCJtYXhfaGVpZ2h0Ijo5Nn0?signature=0a9b9d0dd0ddd6e2bd190e6bd9081e1577ec7b4b9c3c8ce2716854286d731498",
        "location": "Hamburg, Germany",
        "city": "Hamburg",
        "region": "Freie und Hansestadt Hamburg",
        "country": "Germany",
        "countryCode": "DE",
        "locations": ["Hamburg, DE"],
        "workplace": ["On-site"],
        "isRemote": false,
        "employmentType": "Full-time",
        "employmentTypeCode": "FULL_TIME",
        "careerLevel": "Professional/Experienced",
        "industry": "Internet and IT",
        "discipline": "IT and software development",
        "salaryMin": 65000,
        "salaryMax": 80000,
        "salarySource": "employer",
        "salaryCurrency": "EUR",
        "salaryPeriod": "yearly",
        "postedAt": "2026-09-15T07:40:14Z",
        "refreshedAt": "2026-09-15T07:40:14Z",
        "expiresAt": "2026-10-15T07:40:37Z",
        "descriptionText": "Unser Klient ist ein führendes Technologieunternehmen im Bereich der digitalen Sicherheit und agiert als spezialisierter Entwicklungspartner für hochsensible Infrastrukturprojekte. ...",
        "language": "de",
        "tags": ["softwareentwickler", "java", "informatik", "perspektive"],
        "applyUrl": "https://www.apriori.de/job-finden/job/262607/?utm_source=xing.com",
        "applicationType": "external",
        "isPromoted": true,
        "searchKeyword": "Softwareentwickler",
        "searchLocation": "Hamburg"
    },
    {
        "url": "https://www.xing.com/jobs/search?keywords=Pflegefachkraft&location=Genf",
        "status": "not_found",
        "error": "XING has no jobs for this search (keywords \"Pflegefachkraft\", location \"Genf\") with the chosen filters.",
        "scrapedAt": "2026-09-27T23:45:45.687Z",
        "searchKeyword": "Pflegefachkraft",
        "searchLocation": "Genf"
    }
]
```

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

This Actor uses **pay-per-event** pricing. Platform usage (compute, storage, data transfer) is included in these prices:

| Event | Price | Charged when |
|---|---|---|
| Actor start | $0.005 per run | Once when the run starts (one event per GB of memory; the Actor runs on 1 GB). |
| Job posting | $0.0006 per job | One job with `status: ok` was saved to the dataset. |

**1,000 XING jobs cost about $0.61** ($0.005 to start plus 1,000 x $0.0006). Rows with `status` `not_found` or `error` are never billed, and a job found by several of your searches is saved and billed once. The free Apify plan's monthly credit covers several thousand jobs.

You can cap spending per run with **Maximum results** and with the run's **Max total charge** option; the Actor stops gracefully when either limit is reached and keeps everything it has already saved.

### How it compares

One request returns 20 complete postings including the full description, so 1,000 jobs take about 50 requests and well under a minute. Salary figures are labelled: `salarySource` tells you whether the employer published the range or XING estimated it, which matters for any salary analysis. Filters use XING's own search parameters, and pasted search URLs keep every filter you set on xing.com.

It is not for you if you need candidate or member profiles, recruiter contact data, applications or anything inside a XING account; those are out of scope by design.

### Integrations, exports and API access

Results export to **CSV, JSON, Excel**, XML and HTML from the **Output** tab or the dataset API. Apify integrations and webhooks push the same rows into **Google Sheets, Airtable or a CRM**, Slack, Amazon S3 or your own endpoint, directly or through Zapier, Make and n8n. Call the Actor from the **Apify API** (snippets on the **API** tab), from the **Apify MCP server**, or from any AI agent: inputs are plain strings and numbers, and every row carries `status` and `error`.

### Tips

- Keep `maxItems` small while testing, then raise it.
- Put all your keywords and cities in one run instead of many small runs; you pay the start fee once and duplicates across searches are removed.
- XING stops paging after about 470 jobs per search. To cover a large market, split it into narrower searches (per city, per keyword, per employment type) and use `maxItemsPerSearch` to balance them.
- German keywords with umlauts (`Bürokaufmann`, `München`) work as typed.

### Limitations

- **About 470 jobs per search.** XING's search pages no further; split big searches as described above.
- **XING's search is semantic.** Like on xing.com, a keyword also returns related postings, so not every title contains the exact word.
- **Date filter granularity.** XING offers "last 24 hours", "last week" and "last month" only; `postedWithinDays` rounds up to the next bucket.
- **Undocumented data source.** The Actor reads the public job search that xing.com's own pages use. XING can change it at any time; rows then come back as `error` with a reason and the Actor is updated (report it in the **Issues** tab).
- **Descriptions are the employer's own text.** E-mail addresses and phone numbers are removed and XING's separate contact section is never collected, but a description may still mention a person by name.
- **No login and no personal data.** Member profiles, recruiter contacts and anything behind a XING account are out of scope.

### FAQ

**Do I need a XING account or API key?** No. You only need an Apify account. The Actor uses XING's public, logged-out job search.

**Can I paste a search from xing.com?** Yes. Set your filters on xing.com, copy the address bar URL (for example `https://www.xing.com/jobs/search?keywords=Pflegefachkraft&location=Hamburg&radius=50`) and paste it. Every filter in the URL is kept.

**What is the difference between `employer` and `xing_estimate` salaries?** `employer` means the posting states the salary. `xing_estimate` is XING's own estimate for the role, shown when the employer gives none; it includes a `salaryMedian`.

**Which countries are covered?** Whatever XING lists: mostly Germany, Austria and Switzerland, plus some postings elsewhere in Europe.

**Why did I get fewer rows than `maxItems`?** The searches had fewer matches (or reached the ~470 limit), duplicates across searches were removed, or the run hit your **Max total charge** limit. Check the run log for "Stopping gracefully".

**Is it legal to scrape XING?** Scraping publicly available data is generally legal, but you are responsible for how you use the output. Read the legal notice below and XING's terms of service, and do not collect personal data without a legitimate reason.

**Can I use this Actor from an AI agent or MCP client?** Yes. Every row is self-describing (`status` plus `error`), inputs are plain strings, and results can be fetched via the dataset API or the Apify MCP server.

### Related Actors

- [LinkedIn Jobs Scraper](https://apify.com/glasswing/linkedin-jobs-scraper) - use it when the search needs to go beyond German-speaking Europe.
- [ATS Jobs: Workday, Greenhouse, Lever, BambooHR](https://apify.com/glasswing/ats-jobs-scraper) - use it to read postings directly from a company's own applicant-tracking system.
- [Dice Jobs Scraper](https://apify.com/glasswing/dice-jobs-scraper) - use it for US tech and IT roles instead of DACH listings.
- [Welcome to the Jungle Jobs Scraper](https://apify.com/glasswing/welcome-to-the-jungle-jobs) - use it for France and wider European listings.
- [Workable Jobs Scraper](https://apify.com/glasswing/workable-jobs-scraper) - use it for roles hosted on company Workable career pages.

### Legal and data-protection notice

This Actor extracts only job postings that XING publishes publicly to logged-out visitors; it does not extract private user data such as member profiles, recruiter names, e-mail addresses, phone numbers, gender or precise location (e-mail addresses and phone numbers found in free-text job descriptions are removed before the row is saved), and it does not log in or work around access controls. However, your results could still contain personal data. Personal data is protected by the GDPR in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you are unsure whether your reason is legitimate, consult your lawyers. You are responsible for complying with XING's terms of service and applicable law when using the extracted data.

This Actor is an independent tool and is not affiliated with, endorsed by or sponsored by XING or New Work SE. All trademarks belong to their respective owners.

# Changelog

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

# Actor input Schema

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

xing.com URLs, one per line. Accepts job search pages (https://www.xing.com/jobs/search?keywords=Pflegefachkraft\&location=Hamburg) with every filter they carry (radius, employment type, career level, workplace, salary, date posted), and single job pages (https://www.xing.com/jobs/berlin-python-developer-156675213) or a bare job id. Each search returns up to about 470 jobs, which is as far as XING pages.

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

Search terms, one per line, as you would type them into XING's job search, in German or English: "Softwareentwickler", "Pflegefachkraft", "Data Scientist", "Bürokaufmann". Each keyword is searched in every location below; jobs found by several searches are returned once.

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

Cities or regions, one per line, e.g. "Berlin", "München", "Wien", "Zürich", "Hamburg". Leave empty to search all of XING (mostly Germany, Austria and Switzerland).

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

Also include jobs this many kilometres around each location, e.g. 20 or 50. Leave empty for XING's default area.

## `workplace` (type: `array`):

Only jobs with these workplace options. Leave empty for all.

## `remoteOnly` (type: `boolean`):

Shortcut for Workplace = Remote: keep only postings XING lists as fully remote.

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

Only these employment types. Leave empty for all.

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

Only these career levels. Leave empty for all.

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

Only jobs published recently. XING offers three buckets: 1 (last 24 hours), 7 (last week) and 30 (last month); other values round up to the next bucket. Leave empty for any date.

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

XING's salary filter: only jobs whose salary (the employer's figure or XING's estimate) reaches this annual gross amount, e.g. 60000.

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

Upper end of XING's salary filter (annual gross), e.g. 90000. Leave empty for no upper limit.

## `employerSalaryOnly` (type: `boolean`):

Keep only postings whose salary comes from the employer (`salarySource` = employer). Postings with only XING's salary estimate or no salary are skipped.

## `fetchDetails` (type: `boolean`):

Adds the full job description (`descriptionText`). XING returns it inside the same search call, so this costs no extra requests; turn it off only for smaller rows.

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

Language of XING's labels such as employment type, career level, industry and country names. Job texts stay in the language the employer wrote them in.

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

Stop after this many rows in total. Each saved job (status ok) is one billable result. One request returns 20 jobs, so large runs stay fast.

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

Cap for each search URL or keyword x location combination, e.g. 100, so one broad search cannot use the whole budget. Leave empty for no per-search cap.

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

Optional. The Actor calls XING's public job search over plain HTTP and works from Apify's datacenter IPs without a proxy. Enable Apify Proxy (datacenter) only if you see repeated request failures; residential proxies are not needed.

## `query` (type: `string`):

Hidden single-keyword alias of `keywords` for API and agent callers, e.g. "Data Scientist".

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

Hidden single-location alias of `locations` for API and agent callers, e.g. "Berlin".

## Actor input object example

```json
{
  "startUrls": [
    "https://www.xing.com/jobs/search?keywords=Softwareentwickler&location=Berlin"
  ],
  "fetchDetails": true,
  "language": "en",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `results` (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 = {
    "startUrls": [
        "https://www.xing.com/jobs/search?keywords=Softwareentwickler&location=Berlin"
    ],
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("glasswing/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 = {
    "startUrls": ["https://www.xing.com/jobs/search?keywords=Softwareentwickler&location=Berlin"],
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("glasswing/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 '{
  "startUrls": [
    "https://www.xing.com/jobs/search?keywords=Softwareentwickler&location=Berlin"
  ],
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call glasswing/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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