# XING Scraper — Jobs, Salaries & Company Contacts (`logiover/xing-scraper`) Actor

Scrape XING jobs (Germany, Austria, Switzerland) without login: full descriptions, salary ranges & XING estimates, apply links, plus the hiring company's website, email, phone and address. Search by keyword, city, company or filter — tens of thousands of jobs per run. Export CSV, Excel, JSON.

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

## Pricing

from $1.00 / 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.
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 Scraper

**XING Scraper** exports job postings from [XING](https://www.xing.com) — the professional network and job board for **Germany, Austria and Switzerland (DACH)** — to **CSV, Excel, JSON, XML or an API**, with **no login, no cookies and no browser**. If you were looking for a **XING jobs scraper**, a **XING API alternative** or a way to **scrape XING jobs without login**, this Actor gives you every job that matches your keywords, cities, companies and filters — with the **full job description**, **salary range or XING salary estimate**, **apply link**, employment type, career level, discipline, industry, remote/hybrid status and posting dates.

On top of the job data, it adds the **hiring company's contact details** from its XING company page — **website, email, phone, street address, coordinates, about text and employee count** — so the same export works as a **B2B lead list of companies that are hiring right now**. It reads the same data XING's own job search loads (20 complete jobs per request), so it is **fast** (1,000 jobs in about 5 seconds) and **deep**: XING shows at most 2,000 jobs per search, and this Actor cuts big searches into XING's own filter slices automatically, so one run can return **tens of thousands of jobs** — every job once, de-duplicated by its XING id.

> **Measured on 2026-10-15 on the Apify platform:** all **34,850 Berlin jobs in one run (94 s, 0 duplicates)** · **60,000 health-care jobs in one run** · 5,000 jobs for one keyword in 11 s · 1,000 jobs in 5 s · first rows after ~1 s · no login · no cookies · no proxy needed · pay per result.

***

### What you get

Every row is one XING job posting with up to **67 columns**:

| Group | Columns | Fill rate in a 34,850-job run (Berlin, 2026-10-15) |
|---|---|---|
| **Job** | `jobId`, `title`, `url`, `employmentType`, `careerLevel`, `discipline`, `industry`, `workplace` (Remote / Hybrid / On-site), `isRemote`, `language`, `skills`, `keywords`, `employerReference` | title, type, level, discipline, industry, workplace: **100 %** · skills 53 % |
| **Description** | `description` (clean text), `summary`, `qualifications`, `responsibilities`, `descriptionFormat`, optional `descriptionHtml` | description **100 %** · AI summary / bullet lists 22 % |
| **Salary** | `salaryMin`, `salaryMax`, `salaryMedian`, `salaryCurrency`, `salaryPeriod`, `salarySource` (`employer` or `xing_estimate`), `salaryText` | **82 %** of jobs have a salary range |
| **Location** | `location`, `city`, `postalCode`, `street`, `region`, `countryCode`, `country`, `allLocations` | city / region / country **100 %** |
| **Dates** | `postedAt`, `refreshedAt`, `expiresAt` | **100 %** |
| **Apply** | `applyType` (`external_website`, `xing_easy_apply`, `email`), `applyUrl`, `redirectsToExternalSite` | apply link **99.9 %** |
| **Company (from the job)** | `companyName`, `companyId`, `companyXingUrl`, `companySize`, `companyIndustry`, `companyLogoUrl` | company name **100 %** |
| **Company contacts (from the XING company page)** | `companyWebsite`, `companyEmail`, `companyPhone`, `companyAddress`, `companyPostalCode`, `companyCity`, `companyCountryCode`, `companyLatitude`, `companyLongitude`, `companyAbout`, `companySlogan`, `companyEmployeesOnXing`, `companySizeMin`, `companySizeMax`, `companyLocationsCount` | website **66 %** · email **58 %** · phone **56 %** · address **67 %** |
| **Listing flags** | `isPaidListing`, `isTopJob`, `isPromoted` | 100 % |
| **Run context** | `searchQuery` (which of your searches found the job), `xingJobId`, `scrapedAt` | 100 % |

The dataset has three ready-made table views: **Overview**, **Job details** and **Hiring companies (leads)**.

***

### Use cases

#### Recruiting and staffing agencies: find companies that are hiring

Every job comes with the employer's **website, email, phone and address**. Search the roles you place — "Pflegefachkraft", "SAP Berater", "Elektroniker", "Software Engineer" — in the cities you cover, export to Excel and you have a call list of employers with open positions today, the exact job they need to fill and how long it has been online (`postedAt`, `refreshedAt`). Repeat daily with **Posted within: Last 24 hours** to get only the new openings.

#### Job-market and salary analytics for Germany, Austria and Switzerland

XING lists about **643,000 jobs** (2026-10-15). Export whole disciplines, industries or cities with salary ranges (employer ranges and XING's own salary estimates with median), employment type, career level and remote status — then chart salaries by city, demand by discipline, the share of hybrid work, or how many jobs staffing agencies post compared to direct employers.

#### Competitor and employer monitoring

Paste competitors' XING company pages (or just their names) into **Companies** and schedule the run: you get every job they publish on XING, with titles, locations, salaries and descriptions — a clear signal of where a company is expanding, which skills it buys and how fast it hires.

#### Job boards, aggregators and HR tech

Feed a job board, a matching engine or an AI model with clean, structured DACH job data: plain-text descriptions, structured qualifications and responsibilities, normalized salaries, apply URLs, geo data and company metadata — refreshed as often as you like through the API.

#### Sales prospecting with hiring signals

A company hiring 10 sales people in Munich is a company with budget. Filter by discipline and industry, sort by `companyName` and count jobs per company: the companies with the most open positions are often the best prospects for recruiting, HR software, training, relocation and equipment vendors.

#### More ideas

**Career-portal and ATS research** (which ATS each employer uses — see the domain of `applyUrl`) · **relocation and expat services** (jobs open to EU work-permit holders) · **education and training providers** (demand for certifications by region) · **public-sector and labour-market research** · **CSV datasets for BI tools, Google Sheets and AI agents**.

***

### How it works

1. **Search.** Each line of *Search keywords* × each *City* × each *Company* is one search (all three are optional). Filters (employment type, career level, discipline, industry, workplace, salary, posting date) apply to every search. XING URLs you paste are added as further searches or single jobs.
2. **Count first.** The Actor asks XING how many jobs each search has. XING's own search window ends at **2,000 jobs** per search.
3. **Slice big searches automatically.** If you want more than 2,000 jobs from a search, it is cut into XING's own filter slices — **employment type → career level → discipline → industry** (these four partition XING's job board exactly; measured: their counts add up to XING's total) — then **workplace**, **salary band** and **region** for the very largest slices. Each slice is counted and only read when it fits the 2,000 window.
4. **Read complete jobs.** Each request returns 20 complete postings — description, salary, location, apply link and company — so there is no separate detail request per job.
5. **Add company contacts.** For every company with a XING page, the Actor reads the page once (website, email, phone, address, coordinates, about, employees on XING) and attaches it to all of that company's jobs. Companies are cached and fetched 10 at a time.
6. **De-duplicate and stream.** Jobs found by several searches or slices are saved once. Rows appear in the dataset while the run is still going.

The Actor connects to XING directly; if XING ever refuses the connection or hides geo-fenced jobs from the run's IP, it switches to Apify Proxy by itself. You don't need to configure a proxy.

***

### Input

You can combine everything below in one run. With no input at all, the Actor exports XING's whole job board (up to *Maximum jobs*).

#### Keyword + city (the most common search)

```json
{
  "keywords": ["Software Engineer", "Data Scientist"],
  "locations": ["Berlin", "München", "Hamburg"],
  "maxItems": 2000
}
```

Six searches (2 keywords × 3 cities). *Maximum jobs* is shared fairly between them; unused share goes to the searches that have more.

#### Every job in a city and its region

```json
{
  "locations": ["München"],
  "radiusKm": 50,
  "maxItems": 0
}
```

`maxItems: 0` means no limit — about 29,000 jobs within 50 km of Munich on 2026-10-15. `radiusKm: 0` searches the city itself.

#### All jobs of specific employers

```json
{
  "companies": ["https://www.xing.com/pages/deutschebahn", "BMW Group", "Siemens"],
  "maxItems": 0
}
```

XING company page URLs give an exact match; names are matched against the companies XING returns for that name.

#### Filters only (a whole discipline, industry or job type)

```json
{
  "disciplines": ["it_and_software_development"],
  "workplaces": ["remote", "hybrid"],
  "careerLevels": ["professional", "manager"],
  "salaryMin": 60000,
  "maxItems": 10000
}
```

#### Daily monitoring of new jobs

```json
{
  "keywords": ["Pflegefachkraft", "Altenpfleger"],
  "locations": ["Köln", "Düsseldorf"],
  "radiusKm": 25,
  "postedWithin": "24h",
  "maxItems": 0
}
```

Schedule it daily in Apify (Schedules) and send the new jobs to Google Sheets, Slack, a CRM or your own API.

#### XING URLs (job pages, searches with filters, company pages)

```json
{
  "startUrls": [
    { "url": "https://www.xing.com/jobs/hamburg-senior-software-gineer-all-genders-157800906" },
    { "url": "https://www.xing.com/jobs/search?keywords=python&location=Berlin&employmentType=FULL_TIME.ef2fe9&careerLevel=3.2ebf16" },
    { "url": "https://www.xing.com/pages/spaceteamsgmbh" }
  ]
}
```

Copy a search URL from your browser after setting filters on xing.com — the Actor reads keywords, location, radius and every filter from it.

#### All input fields

| Field | Type | Default | What it does |
|---|---|---|---|
| `keywords` | list of text | `[]` | Job titles, skills or any search words, one search per line. Empty = all jobs (within the other criteria). |
| `locations` | list of text | `[]` | City names in Germany, Austria or Switzerland. Each city is a separate search. |
| `radiusKm` | number | `0` | Radius around each city in km (0 = the city itself, up to 500). |
| `companies` | list of text | `[]` | Company names or XING company page URLs. |
| `startUrls` | list of URLs | `[]` | XING job URLs, job-search URLs or company pages. |
| `employmentTypes` | list | all | `full_time`, `part_time`, `freelance`, `internship`, `temporary`, `seasonal`, `voluntary`. |
| `careerLevels` | list | all | `student_intern`, `entry_level`, `professional`, `manager`, `executive`, `senior_executive`. |
| `disciplines` | list | all | XING's 22 disciplines, e.g. `it_and_software_development`, `engineering_and_technical`, `sales_and_commerce`, `health_medical_and_social`, `finance_accounting_and_controlling`, `hr`. |
| `industries` | list | all | XING's 23 industries (all their sub-industries included), e.g. `internet_and_it`, `health_and_social`, `banking_and_financial_services`, `automotive_and_vehicle_manufacturing`. |
| `workplaces` | list | all | `remote`, `hybrid`, `on_site`. |
| `salaryMin` / `salaryMax` | number | `0` | Yearly gross salary filter in EUR (0 = not set). |
| `postedWithin` | text | `any` | `24h`, `7d` or `30d`. |
| `postedSince` | date | — | Only jobs published or refreshed on or after this date (overrides `postedWithin`). |
| `maxItems` | number | `1000` | Maximum jobs in total. `0` = no limit. |
| `includeCompanyDetails` | true/false | `true` | Add website, email, phone, address and more from the company's XING page. |
| `includeDescriptionHtml` | true/false | `false` | Also keep the original HTML of the description. |
| `concurrency` | number | `20` | Parallel requests (1–50). |
| `proxyConfiguration` | proxy | direct | Optional; the Actor switches to Apify Proxy by itself when needed. |

***

### Output data dictionary

| Column | Example | Meaning |
|---|---|---|
| `jobId` | `158299917` | XING's job number (also at the end of the job URL). |
| `title` | `Recruiting Consultant – Telefonische Kandidatengewinnung (m/w/d/x)` | Job title as published. |
| `url` | `https://www.xing.com/jobs/berlin-recruiting-consultant-…-158299917` | The job's XING page. |
| `companyName` | `uCastMe GmbH` | Employer name shown on the job. |
| `companyId` | `964989.27a31d` | XING's company id (stable). |
| `companyXingUrl` | `https://www.xing.com/pages/ucastmegmbh` | The company's XING page. |
| `companySize` | `51-200 employees` | Company size band from XING. |
| `companyIndustry` | `HR services` | The company's industry on XING. |
| `companyLogoUrl` | `https://www.xing.com/imagecache/…` | Logo, 256 px. |
| `location` | `Berlin, Land Berlin, DE` | City, region and country of the job. |
| `city`, `region`, `countryCode`, `country` | `Berlin`, `Land Berlin`, `DE`, `Germany` | Job location parts. |
| `postalCode`, `street` | `22769`, `Eifflerstraße 43` | When the employer publishes them. |
| `allLocations` | `["Berlin, Land Berlin, DE", "Hamburg, …"]` | All locations of multi-location jobs (null for single-location jobs). |
| `workplace` | `Hybrid` | `Remote`, `Hybrid` or `On-site` (several are joined with " / "). |
| `isRemote` | `false` | True for fully remote jobs. |
| `employmentType` | `Full-time` | Full-time, Part-time, Freelance, Student/intern, Temporary, Seasonal, Volunteer. |
| `careerLevel` | `Professional/Experienced` | XING career level. |
| `discipline` | `IT and software development` | XING discipline (22 values). |
| `industry` | `Internet and IT` | XING industry or sub-industry of the posting. |
| `salaryMin`, `salaryMax` | `38500`, `51500` | Salary range (numbers, no formatting). |
| `salaryMedian` | `41500` | Median of XING's salary estimate (estimates only). |
| `salaryCurrency` | `EUR` | Currency (EUR or CHF). |
| `salaryPeriod` | `year` | `year`, `month` or `hour`. XING estimates are yearly; for employer ranges the period is inferred from the amount. |
| `salarySource` | `xing_estimate` | `employer` = published by the company · `xing_estimate` = XING's estimate for the job. |
| `salaryText` | `EUR 38,500 – 51,500 per year (XING estimate, median 41,500)` | Human-readable salary. |
| `postedAt` | `2026-10-02T20:30:25Z` | When the job was published (ISO 8601, UTC). |
| `refreshedAt` | `2026-10-02T20:30:25Z` | Last time the employer refreshed the posting. |
| `expiresAt` | `2027-04-03T11:25:01Z` | When the posting goes offline unless renewed. |
| `applyType` | `external_website` | `external_website` (company career site or ATS), `xing_easy_apply`, `email` or `xing_message`. |
| `applyUrl` | `https://ucm.jobs.personio.de/job/2812866?…` | Where to apply (`mailto:` for email applications). |
| `redirectsToExternalSite` | `false` | True when XING forwards the visitor straight to an external page. |
| `summary` | `Spaceteams sucht einen Softwareentwickler …` | XING's short summary of the job (when available). |
| `qualifications` | `["Mehrjährige Erfahrung …", …]` | Required qualifications as a list (when available). |
| `responsibilities` | `["Planung und Entwicklung …", …]` | Key responsibilities as a list (when available). |
| `description` | `Deine Aufgaben: …` | Full job description as clean text with paragraphs. |
| `descriptionHtml` | `<p>…</p>` | Original HTML (only with `includeDescriptionHtml`). |
| `descriptionFormat` | `html` | `html`, `template` (XING's structured template) or `external`. |
| `skills` | `["Recruiting"]` | Skills XING extracted from the posting. |
| `keywords` | `["consultant", "recruiting", …]` | Search keywords XING attaches to the posting. |
| `language` | `de` | Language of the posting. |
| `employerReference` | `8624996` | The employer's own job reference, when given. |
| `isPaidListing`, `isTopJob`, `isPromoted` | `true`, `false`, `true` | Paid XING posting / top job / promoted in search. |
| `companyWebsite` | `http://www.ucastme.de/` | Company website from its XING page. |
| `companyEmail` | `kontakt@ucm.agency` | Company contact email from its XING page. |
| `companyPhone` | `+49 30120865681` | Company phone with country code. |
| `companyAddress`, `companyPostalCode`, `companyCity`, `companyCountryCode` | `Heidestr 46`, `10823`, `Berlin`, `DE` | Company address (main location). |
| `companyLatitude`, `companyLongitude` | `52.5311673`, `13.3670148` | Company coordinates. |
| `companyAbout` | `Unkonventionell, charmant und menschlich …` | The company's "about us" text (up to 4,000 characters). |
| `companySlogan` | `Was ist dir wichtig?` | Company slogan on XING. |
| `companyEmployeesOnXing` | `22` | Number of XING members who list the company as employer. |
| `companySizeMin`, `companySizeMax` | `51`, `200` | Company size band as numbers. |
| `companyLocationsCount` | `1` | Locations listed on the company page. |
| `searchQuery` | `"Software Engineer" in Berlin` | Which of your searches found the job. |
| `xingJobId` | `158299917.62104a` | XING's full internal job id. |
| `scrapedAt` | `2026-10-15T10:05:34Z` | When the row was collected. |

Missing values are `null` — never `0` or an empty string pretending to be data.

***

### Output example (a real row from a test run, description shortened)

```json
{
  "jobId": "158299917",
  "title": "Recruiting Consultant – Telefonische Kandidatengewinnung (m/w/d/x)",
  "url": "https://www.xing.com/jobs/berlin-recruiting-consultant-telefonische-kandidatengewinnung-158299917",
  "companyName": "uCastMe GmbH",
  "companyId": "964989.27a31d",
  "companyXingUrl": "https://www.xing.com/pages/ucastmegmbh",
  "companySize": "51-200 employees",
  "companyIndustry": "HR services",
  "location": "Berlin, Land Berlin, DE",
  "city": "Berlin",
  "region": "Land Berlin",
  "countryCode": "DE",
  "country": "Germany",
  "workplace": "On-site",
  "isRemote": false,
  "employmentType": "Part-time",
  "careerLevel": "Professional/Experienced",
  "discipline": "HR",
  "industry": "HR services",
  "salaryMin": 38500,
  "salaryMax": 51500,
  "salaryMedian": 41500,
  "salaryCurrency": "EUR",
  "salaryPeriod": "year",
  "salarySource": "xing_estimate",
  "salaryText": "EUR 38,500 – 51,500 per year (XING estimate, median 41,500)",
  "postedAt": "2026-10-02T20:30:25Z",
  "refreshedAt": "2026-10-02T20:30:25Z",
  "expiresAt": "2027-04-03T11:25:01Z",
  "applyType": "external_website",
  "applyUrl": "https://ucm.jobs.personio.de/job/2812866?language=de&utm_source=xing.com",
  "description": "Deine Aufgaben:\nÜber ucm arbeiten mehr als 48.000 Studierende. Rund 2.000 stellen wir jedes Jahr neu ein – und am Anfang steht immer ein Anruf. …",
  "descriptionFormat": "html",
  "skills": ["Recruiting"],
  "keywords": ["consultant", "recruiting", "englischkenntnisse", "kundenbetreuung", "teamleitung", "verkauf", "promotion", "app"],
  "language": "de",
  "isPaidListing": false,
  "isTopJob": false,
  "isPromoted": false,
  "companyWebsite": "http://www.ucastme.de/",
  "companyEmail": "kontakt@ucm.agency",
  "companyPhone": "+49 30120865681",
  "companyAddress": "Heidestr 46",
  "companyPostalCode": "10823",
  "companyCity": "Berlin",
  "companyCountryCode": "DE",
  "companyLatitude": 52.5311673,
  "companyLongitude": 13.3670148,
  "companyAbout": "Unkonventionell, charmant und menschlich – kurz UCM! …",
  "companyEmployeesOnXing": 22,
  "companySizeMin": 51,
  "companySizeMax": 200,
  "searchQuery": "in Berlin",
  "xingJobId": "158299917.62104a",
  "scrapedAt": "2026-10-15T10:05:34.483Z"
}
```

***

### How much data can I get?

XING listed **642,900 jobs** on 2026-10-15. Measured sizes (jobs on XING that day):

| Slice | Jobs | Slice | Jobs |
|---|---|---|---|
| Berlin | 35,086 | Production and manufacturing | 140,815 |
| Hamburg | 20,675 | Health, medical and social | 118,170 |
| München (city) | 17,911 | Engineering and technical | 62,762 |
| München + 25 km | 23,596 | Sales and commerce | 60,459 |
| München + 100 km | 49,657 | Purchasing, materials management & logistics | 56,379 |
| Frankfurt am Main | 12,377 | IT and software development | 40,445 |
| Wien | 4,912 | Finance, accounting & controlling | 29,416 |
| Zürich | 4,995 | Hybrid jobs | 94,213 |
| New in the last 24 hours | ~62,000 | Fully remote jobs | 8,195 |
| New in the last 7 days | ~162,700 | Part-time jobs | 37,388 |
| New in the last 30 days | ~376,300 | Internships / student jobs | 16,470 |

**Measured runs (Apify platform, 2026-10-15):**

| Run | Jobs saved | Time | Duplicates |
|---|---|---|---|
| Every job in Berlin (`locations: ["Berlin"]`, `maxItems: 0`) | **34,850** of 35,086 listed (99.3 %) | 94 s | 0 |
| Health, medical and social discipline, `maxItems: 60000` | **60,000** | 6 min 43 s (1 GB memory; faster at the 2 GB default) | 0 |
| Keyword "Vertrieb", all of XING, `maxItems: 5000` | 5,000 | 11 s | 0 |
| 3 keywords × 2 cities, `maxItems: 3000` | 2,764 (every match) | 8 s | 0 |
| 1,000 jobs in Berlin | 1,000 | 5 s | 0 |
| Input-form example (50 jobs) | 50 | 3 s | 0 |

Why "99.3 %" and not 100 %? XING's job count includes a few postings that its own result pages never show or show twice; the Actor returns every distinct job XING actually serves for the search.

#### Big runs need a big enough "Maximum cost per run"

On pay-per-result Actors, Apify stops a run once its **Maximum cost per run** is used up. The Actor checks that budget at the start: if it covers fewer jobs than you asked for, it says so in the log, saves exactly as many jobs as the budget pays for and finishes as **Succeeded** with the message *"Saved N jobs — this run's maximum cost ($X) covers N results at the current price"*. For a 50,000-job export, set Maximum cost per run to at least 50,000 × your price per result (e.g. $75 at $1.50 per 1,000).

***

### Speed and what you pay

- **What you pay:** a fixed price **per job saved** — from **$1.50 per 1,000 jobs** on the Apify Free plan, lower on paid plans. Compute and proxy are included; there is no separate platform charge for this Actor's runs.
- **Speed:** ~1 s to the first rows, ~5 s for 1,000 jobs, ~94 s for 35,000 jobs (measured with company contacts on).
- **Memory:** 2 GB default. More memory = more CPU = faster large runs; small runs are fine with 1 GB.
- **No hidden costs:** no proxy subscription, no browser, no login, no third-party API key.

***

### Integrations

#### API (curl)

```bash
curl -X POST "https://api.apify.com/v2/acts/logiover~xing-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keywords":["Data Engineer"],"locations":["Berlin"],"maxItems":200}'
```

#### Node.js

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

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const run = await client.actor('logiover/xing-scraper').call({
    keywords: ['SAP Berater'],
    locations: ['Frankfurt am Main'],
    radiusKm: 50,
    maxItems: 2000,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length, items[0].title, items[0].companyEmail);
```

#### Python

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR_TOKEN")
run = client.actor("logiover/xing-scraper").call(run_input={
    "disciplines": ["it_and_software_development"],
    "workplaces": ["remote"],
    "postedWithin": "7d",
    "maxItems": 0,
})
for job in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(job["title"], job["companyName"], job["salaryText"])
```

#### Make, Zapier and n8n

Use the official Apify modules: *Run an Actor* → *Get dataset items*. Typical flow: daily schedule → XING Scraper with `postedWithin: "24h"` → filter rows → add to Google Sheets, HubSpot, Pipedrive, Airtable or Slack.

#### Google Sheets

Export the dataset as CSV or use the Apify integration for Google Sheets to append new jobs to a sheet after every run.

#### Webhooks

Add a webhook on *Run succeeded* to call your own endpoint with the run id, then fetch `https://api.apify.com/v2/datasets/{datasetId}/items?format=json`.

#### MCP and AI agents

The Actor works with the Apify MCP server, so Claude, ChatGPT or Cursor agents can call it ("find hybrid Python jobs in Munich paying over €70k and list the companies with their websites").

***

### Comparison

| | This XING Scraper | Copy-paste from xing.com | Typical scrapers |
|---|---|---|---|
| Jobs per search | **All of them** — automatic slicing past XING's 2,000 window | 2,000 max | Often stop at the first pages |
| Full description + structured qualifications | **Yes** | Manual | Often title + snippet only |
| Salary (employer range and XING estimate with median) | **Yes, as numbers** | Text only | Rarely |
| Company website, email, phone, address | **Yes** (from the company's XING page) | Manual | No |
| Employer filter by name or XING page | **Yes** | One at a time | Rarely |
| Filters (type, level, discipline, industry, remote, salary, date) | **All of XING's filters** | Yes | Few |
| De-duplication across searches | **Yes, by XING job id** | — | Rarely |
| Login / cookies needed | **No** | Yes for some jobs | Sometimes |

***

### Limits and tips

- **Keyword search is XING's AI search.** XING ranks jobs by meaning, not by exact words, so a search for "Vertrieb" also returns closely related sales and customer-facing jobs (in our 5,000-job test, 70 % were in XING's *Sales and commerce* discipline). Combine keywords with *Discipline* for stricter results, or filter by `title` after the run.
- **2,000 per search.** XING never shows more than 2,000 results for one search; the Actor slices bigger searches automatically. Only the very largest single slices (for example tens of thousands of full-time, experienced health-care jobs in the same industry) can still exceed it — the run summary reports how many jobs could not be reached that way (`notReachable`).
- **Company contacts come from XING company pages.** About two thirds of jobs belong to a company with a XING page; staffing agencies and large employers almost always have one. Jobs without a page have `null` contact fields.
- **Salary period.** XING estimates are yearly gross amounts. Employer-published ranges have no period on XING; the Actor infers it from the amount (`hour` under 300, `month` under 15,000, otherwise `year`).
- **Locations are cities.** Use city names ("Frankfurt am Main", "Wien", "Zürich"); regions and postcodes are not XING search locations. Use *Radius* for the surrounding area.
- **Daily monitoring:** schedule the run with *Posted within: Last 24 hours* and the same searches; compare `jobId` with yesterday's export to get only new jobs.

***

### FAQ

#### What is XING Scraper?

An Apify Actor that exports XING job postings — with full descriptions, salaries, apply links and the hiring company's contact details — to CSV, Excel, JSON or an API. It needs no XING account.

#### Is there an official XING API for job data?

XING does not offer an open developer API for job search data. This Actor reads the same public job data XING's own website loads for logged-out visitors, so you get the data without an API contract or partner access.

#### Do I need a XING account, login or cookies?

No. Everything the Actor collects is visible to logged-out visitors of xing.com.

#### Do I need a proxy?

No. The Actor connects directly and switches to Apify Proxy automatically if XING ever refuses the connection or geo-fences jobs for the run's IP address.

#### How many jobs can I get per run?

As many as match your input — set `maxItems: 0`. Measured: 34,850 jobs (every Berlin job) in 94 s and 60,000 jobs in one run. XING lists about 643,000 jobs in total.

#### How fast is it?

About 1 second to the first rows, 5 seconds for 1,000 jobs and around 1.5 minutes for 35,000 jobs including company contacts.

#### How much does it cost?

You pay per job saved — from $1.50 per 1,000 jobs on the Free plan, less on paid plans. Compute and proxy are included.

#### Can I get the email and phone number of the hiring company?

Yes. With *Add company contact details* on (default), every job from a company with a XING page gets the company's website, email, phone, address and coordinates. In our Berlin export, 66 % of jobs had a website, 58 % an email and 56 % a phone number.

#### Can I get the recruiter's or hiring manager's name?

No. XING shows contact persons only to logged-in members; this Actor collects only public data.

#### Does it include salary?

Yes, for about 82 % of jobs: either the salary range published by the employer (`salarySource: "employer"`) or XING's own estimate with minimum, maximum and median (`salarySource: "xing_estimate"`).

#### Can I scrape all jobs of one company?

Yes. Put the company's XING page URL (https://www.xing.com/pages/...) or its name into *Companies*. Example: all jobs of BMW Group, Deutsche Bahn and Siemens in one run.

#### Can I get only new jobs every day?

Yes. Use *Posted within: Last 24 hours* (or *Posted since*) and schedule the Actor daily. On 2026-10-15 about 62,000 jobs had been published or refreshed in the previous 24 hours.

#### Does it work for Austria and Switzerland?

Yes. Use Austrian or Swiss cities (Wien, Graz, Linz, Salzburg, Zürich, Bern, Basel, Genf …). Swiss salaries come in CHF where XING provides them.

#### Why did my run stop before reaching Maximum jobs?

Either every matching job was read (the status message says "every matching job read"), or the run's *Maximum cost per run* was reached (the status message says so and shows how many jobs the budget covers), or the run hit its time limit. The SUMMARY record in the run's key-value store lists every search with the number of jobs on XING and the number saved.

#### What happens if XING is down or blocks the run?

Failed requests are retried with backoff; refused connections move to Apify Proxy. If nothing at all could be read, the run fails with a clear message instead of finishing with an empty dataset — so an empty successful run always means "no job matched".

#### Can I export to Excel or Google Sheets?

Yes — the dataset exports to CSV, Excel (XLSX), JSON, XML and HTML, and integrates with Google Sheets, Make, Zapier and n8n.

#### I need another field or filter. Can you add it?

Yes — open an issue on the Actor's page with an example XING URL. We usually reply within 24 hours.

***

### Is it legal to scrape XING?

This Actor only collects data that XING publishes openly to every visitor without a login: job postings and public company pages. It does not log in, bypass access controls or collect members' private profiles. Company contact data comes from the companies' own public XING pages. Job-posting data is published by employers precisely so that it is found and read. You are responsible for how you use the data: if you process personal data (for example a named contact in a job description), make sure you have a legal basis under the GDPR, and respect XING's terms and applicable law in your jurisdiction. If in doubt, consult a lawyer.

**Disclaimer:** This Actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by XING or New Work SE** or any of their subsidiaries. "XING" is a trademark of its respective owner and is used here only to describe the data source.

***

### Changelog

- **1.0 (2026-10-15)** — First release: keyword, city + radius, company and filter searches; XING URLs; automatic slicing past the 2,000-results window; full descriptions, salaries, apply links; company website, email, phone, address and coordinates; de-duplication; pay-per-result budget awareness.

***

### Support

Questions, a missing field or a XING page that does not work? Open an issue on the Actor page — we reply **within 24 hours** on working days. Custom versions (extra fields, scheduled exports to your system) are possible on request.

# Changelog

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

# Actor input Schema

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

Job titles, skills or any search words — one search per line (e.g. "Software Engineer", "Pflegefachkraft", "SAP Berater"). Leave empty to get every job that matches the location, company and filters below (empty everywhere = the whole XING job board).

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

City names in Germany, Austria or Switzerland (e.g. Berlin, München, Wien, Zürich) — one per line. Each city is searched separately. Leave empty for all of XING.

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

0 = jobs in the city itself. 25, 50 or 100 include the surrounding region (München: 17.9k jobs in the city, 23.6k within 25 km, 49.7k within 100 km).

## `companies` (type: `array`):

Get the jobs of specific employers: company names (e.g. "Deutsche Bahn") or XING company page URLs (https://www.xing.com/pages/deutschebahn) — one per line. Page URLs give an exact match.

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

Optional. Paste XING job URLs (https://www.xing.com/jobs/berlin-software-engineer-157800906), job search URLs with your filters (https://www.xing.com/jobs/search?keywords=...), or company pages (https://www.xing.com/pages/...).

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

Only these employment types. Leave empty for all.

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

Only these career levels. Leave empty for all.

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

XING's job disciplines (IT and software development, Engineering, Sales, Health, ...). Leave empty for all.

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

The employer's industry (all sub-industries included). Leave empty for all.

## `workplaces` (type: `array`):

Remote, hybrid or on-site. Leave empty for all.

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

Only jobs whose salary (employer range or XING estimate) reaches this yearly gross amount. 0 = no filter.

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

Upper end of the salary filter. 0 = no upper limit.

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

Only jobs published or refreshed in this period — ideal for daily or weekly monitoring.

## `postedSince` (type: `string`):

Only jobs published or refreshed on or after this date (YYYY-MM-DD). Overrides "Posted within".

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

Stop after this many jobs in total (shared fairly between your searches). 0 = no limit: every matching job is collected — a run can return tens of thousands.

## `includeCompanyDetails` (type: `boolean`):

Adds the hiring company's website, email, phone, address, coordinates, about text and employee count on XING (from the company's XING page, cached per company).

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

The plain-text description is always included. Turn this on to also get the original HTML (larger dataset).

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

How many XING requests run at the same time. The default is fast and polite; there is rarely a reason to change it.

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

Not needed: the scraper connects directly and switches to Apify Proxy by itself if XING ever refuses the connection or hides geo-fenced jobs. Set a proxy here only if you want to force one.

## Actor input object example

```json
{
  "keywords": [
    "Software Engineer"
  ],
  "locations": [
    "Berlin"
  ],
  "radiusKm": 0,
  "companies": [],
  "startUrls": [],
  "employmentTypes": [],
  "careerLevels": [],
  "disciplines": [],
  "industries": [],
  "workplaces": [],
  "salaryMin": 0,
  "salaryMax": 0,
  "postedWithin": "any",
  "maxItems": 50,
  "includeCompanyDetails": true,
  "includeDescriptionHtml": false,
  "concurrency": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

All scraped XING jobs. Open the Dataset tab to browse them or export CSV, Excel or JSON.

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "Software Engineer"
    ],
    "locations": [
        "Berlin"
    ],
    "maxItems": 50,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

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

```

## Python example

```python
from apify_client import ApifyClient

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

# Prepare the Actor input
run_input = {
    "keywords": ["Software Engineer"],
    "locations": ["Berlin"],
    "maxItems": 50,
    "proxyConfiguration": { "useApifyProxy": False },
}

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

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

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

```

## CLI example

```bash
echo '{
  "keywords": [
    "Software Engineer"
  ],
  "locations": [
    "Berlin"
  ],
  "maxItems": 50,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call logiover/xing-scraper --silent --output-dataset

```

## MCP server setup

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