# Xing Jobs Scraper - DACH Job Listings & Salaries (`haketa/xing-jobs-scraper`) Actor

XING Jobs scraper & API for DACH (Germany, Austria, Switzerland): search jobs by keyword and location and export title, company, location, salary range, employment type, date and apply URL. Recruitment and DACH job-market data — fast, no login.

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

## Pricing

from $1.50 / 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 Jobs Scraper – DACH Job Listings, Salaries & Companies

[![Apify Actor](https://img.shields.io/badge/Apify-Actor-00C853?style=for-the-badge\&logo=apify\&logoColor=white)](https://apify.com/haketa/xing-jobs-scraper)
[![DACH Coverage](https://img.shields.io/badge/Region-Germany_%7C_Austria_%7C_Switzerland-1E88E5?style=for-the-badge)](https://www.xing.com/jobs)
[![Export Formats](https://img.shields.io/badge/Export-JSON_%7C_CSV_%7C_Excel_%7C_API-FF6F00?style=for-the-badge)](https://apify.com/haketa/xing-jobs-scraper)
[![Pagination](https://img.shields.io/badge/Scale-1,000%2B_Jobs_Unlocked-8E24AA?style=for-the-badge)](https://apify.com/haketa/xing-jobs-scraper)

**Extract job listings from [Xing.com](https://www.xing.com/jobs), the leading professional network in the DACH region (Germany, Austria, Switzerland), in minutes.** This **Xing jobs scraper** and **Xing data extractor** turns any keyword into a clean, structured database of job postings — complete with **job title, company, location, salary range, employment type, posting date and apply URL** — ready for recruiting, salary benchmarking, job-market research and **B2B lead generation**.

Use this **Xing scraper** to **scrape Xing** job search results at scale — a verified run pulled **450 unique listings in under 100 seconds**, with full support for **1,000+ results pagination**. Bulk export everything as **JSON, CSV, Excel, or via the Apify API** — no login, no manual copy-paste, no coding required.

> 💡 Built for recruiters, sourcers, HR teams, job boards, market researchers and sales teams that target the German-speaking (DACH) market.

***

### ⚡ At a glance

| Feature | Details |
|---|---|
| **Data source** | [Xing.com/jobs](https://www.xing.com/jobs) — Germany (DE), Austria (AT) & Switzerland (CH) |
| **Captured fields** | Job Title, Hiring Company, City, Additional Locations, Employment Type, Salary Text + Numeric Min/Max, Posted Date, Urgency Badge, Job ID & Apply URL |
| **Salary intelligence** | Parses German/Swiss salary bands (`73.500 € – 96.500 €`, `CHF`) into numeric `salaryMin` & `salaryMax` |
| **Location targeting** | 24 built-in DACH cities (Berlin, München, Hamburg, Wien, Zürich, etc.) + custom location support |
| **Scale & pagination** | **1,000+ jobs per run** (~20 listings/page, up to 500 pages per query, de-duplicated by `jobId`) |
| **Export formats** | JSON, CSV, Excel (XLSX), XML, RSS & **Apify REST API** |

***

### 🔎 Why scrape Xing jobs?

Xing is the dominant professional network and job board in the DACH region, with millions of job seekers and thousands of new postings every day. Its job listings are a goldmine for anyone hiring, selling to HR, or researching the German-speaking labour market — and unlike many job boards, Xing publishes **salary ranges** right on the listing.

But Xing has no public bulk export, and copying listings by hand is slow. This scraper automates the whole process: you give it keywords (and optionally a city), and it returns hundreds of clean job records you can filter, sort and import anywhere.

**Common reasons people scrape Xing jobs:**

- Build **talent-sourcing and recruiting pipelines** for the DACH market
- Benchmark **salaries** by role, seniority and location
- Track **competitor hiring** — who's hiring for what, where
- Power a **job board or aggregator** with fresh DACH listings
- Generate **leads for recruiting/HR-tech vendors** (companies that are actively hiring)
- Run **labour-market and talent-demand research**

***

### ✨ What this Xing jobs scraper does

- ✅ Searches Xing jobs by **any keyword** (e.g. `software engineer`, `marketing manager`, `Projektleiter`)
- ✅ Optional **city/region targeting** (Berlin, München, Wien, Zürich…)
- ✅ Returns **hundreds of jobs per keyword** with automatic pagination (de-duplicated by job ID)
- ✅ Captures **job title, company, location, salary range, employment type, posting date, urgency flag and apply URL**
- ✅ Parses salary into **numeric min/max** for easy sorting and analysis
- ✅ Exports to **JSON, CSV, Excel, XML** and integrates with Google Sheets, Make, Zapier, Slack and your own apps
- ✅ **Fast and reliable** — Xing renders listings server-side, so no fragile headless browser needed

***

### 🎯 Use cases

#### 1. Recruiting & talent sourcing

Build lists of open roles in your niche across the DACH region. Each listing includes the **company, location and apply URL**, so recruiters and sourcers can map demand, find hiring companies and reach out fast.

#### 2. Salary benchmarking

Xing publishes **salary ranges** on many listings. Pull a role across cities and seniorities to benchmark compensation — invaluable for HR, comp & benefits teams and candidates negotiating offers.

#### 3. Competitor hiring intelligence

Track which companies are hiring, for which roles, in which cities, and how urgently. A spike in postings is a strong signal of growth, new initiatives or team expansion.

#### 4. Job board & aggregator content

Feed a job board, vertical aggregator or internal portal with fresh, structured DACH listings — title, company, location, salary, type and apply link — updated on a schedule.

#### 5. Lead generation for HR-tech & staffing

Companies posting jobs are active buyers for recruiting tools, staffing agencies and HR services. Use the company + role data to build targeted, timely prospect lists.

#### 6. Labour-market & talent-demand research

Quantify demand for skills and roles across Germany, Austria and Switzerland — which functions are in demand, where, and at what pay — for analysts, consultancies and workforce planners.

***

### 🌍 Built for the DACH market

Xing is the go-to professional platform in **Germany, Austria and Switzerland**. This scraper is tuned for that market: it understands German-language listings (Vollzeit/Teilzeit, salary in € and CHF, German posting dates like "Vor 2 Tagen") and lets you target cities like **Berlin, München, Hamburg, Köln, Frankfurt, Wien and Zürich** via the `location` input.

***

### 💼 Popular job searches

You can scrape any keyword. Popular roles recruiters and researchers track on Xing include:

- **Tech** — software engineer, DevOps engineer, data scientist, IT project manager, cloud architect, cybersecurity
- **Engineering** — Maschinenbau, Elektrotechnik, Konstrukteur, Projektingenieur, Qualitätsmanagement
- **Business & sales** — sales manager, account executive, business development, Vertrieb, key account
- **Marketing** — marketing manager, online marketing, SEO, content manager, social media
- **Finance** — controller, accountant, Buchhalter, financial analyst, Steuerberater
- **Healthcare** — Pflegefachkraft, Arzt, medical, pharma
- **Skilled trades** — Elektriker, Mechatroniker, Techniker, Meister

Pair any role with a city via the `location` input for a focused, market-specific search.

### 🏙️ Supported cities & regions

Xing covers the entire DACH market. Popular `location` values:

- **Germany** — Berlin, München, Hamburg, Köln, Frankfurt, Stuttgart, Düsseldorf, Leipzig
- **Austria** — Wien, Graz, Linz, Salzburg
- **Switzerland** — Zürich, Genf, Basel, Bern

Salaries are returned in **€** for Germany/Austria and **CHF** for Switzerland, and the scraper parses both into numeric ranges.

### ⚙️ How it works

1. **Enter one or more job keywords** — exactly what you'd type into Xing job search.
2. **Optionally set a location** and how many jobs you want per keyword.
3. **Run the Actor** — it collects, de-duplicates and structures the data, then makes it available for download or via API.

No login, no captcha solving, and a sensible proxy default (DE) is built in.

***

### 🔧 Input parameters

| Parameter | Type | Required | Description |
| --- | --- | --- | --- |
| `queries` | array | ✅ Yes | Job search keywords (e.g. `software engineer`, `Projektleiter`). |
| `location` | string | No | City or region to bias the search (Berlin, München, Wien, Zürich…). Pick from the dropdown or leave as "Everywhere" to search all of DACH. |
| `locationCustom` | string | No | Advanced: type any city/region not in the dropdown (e.g. `Mannheim`). If set, it overrides `location`. |
| `maxItemsPerQuery` | integer | No | Max jobs to collect per keyword. ~20 per page, paginated automatically. Set `0` for no limit. Default `60`. |
| `proxyConfiguration` | object | No | Apify Proxy settings. A DE/EU proxy is recommended for the DACH market. |

#### Example input — simple job search

```json
{
    "queries": ["software engineer"],
    "maxItemsPerQuery": 100
}
```

#### Example input — role in a specific city

```json
{
    "queries": ["marketing manager"],
    "location": "Berlin",
    "maxItemsPerQuery": 80
}
```

#### Example input — multiple roles

```json
{
    "queries": ["data analyst", "data engineer", "data scientist"],
    "location": "München",
    "maxItemsPerQuery": 150
}
```

***

### 📤 Output

The Actor stores one row per job listing. Data can be downloaded as **JSON, CSV, Excel, XML** or pulled via the Apify API.

#### Sample output record

```json
{
    "jobTitle": "Lead Software Engineer / Developer (m/w/d) - Mission Planning",
    "company": "Hensoldt",
    "location": "Berlin",
    "additionalLocations": 0,
    "employmentType": "Vollzeit",
    "salary": "73.500 € – 96.500 €",
    "salaryMin": 73500,
    "salaryMax": 96500,
    "postedDate": "Vor 2 Tagen",
    "isUrgent": true,
    "jobId": "157639041",
    "jobUrl": "https://www.xing.com/jobs/berlin-lead-software-engineer-developer-mission-planning-157639041",
    "searchKeyword": "software engineer",
    "scrapedAt": "2026-11-02T00:05:49.959Z"
}
```

#### Output fields reference

##### 💼 Job Identity & Employer

| Field | Coverage | Description |
| --- | --- | --- |
| `jobTitle` | 🟢 High (100%) | Clean job title (soft hyphens stripped for clean matching). |
| `company` | 🟢 High (100%) | Hiring company name. |
| `jobId` | 🟢 High (93%+) | Xing job ID (used for automatic de-duplication across pages and keywords). |
| `jobUrl` | 🟢 High (100%) | Direct link to the job listing on Xing.com. |

##### 📍 Location & Contract Details

| Field | Coverage | Description |
| --- | --- | --- |
| `location` | 🟢 High (100%) | Primary job location (city). |
| `additionalLocations` | 🟢 High (100%) | Count of extra office locations (`+ N weitere`). |
| `employmentType` | 🟢 High (99%) | Contract type (`Vollzeit`, `Teilzeit`, `Full-time`, `Part-time`, `Internship`, `Werkstudent`). |
| `isUrgent` | 🟢 High (100%) | Boolean flag indicating whether the listing is marked urgent (`Dringend gesucht`). |

##### 💶 Compensation & Metadata

| Field | Coverage | Description |
| --- | --- | --- |
| `salary` | 🟢 High (~86%) | Raw salary range as displayed on Xing (e.g. `73.500 € – 96.500 €`). |
| `salaryMin` / `salaryMax` | 🟢 High (~86%) | Numeric minimum and maximum annual salary parsed from `salary`. |
| `postedDate` | 🟡 Conditional | Recency label when displayed by Xing (e.g. `Vor 2 Tagen`, `Vor 11 Stunden`, `Heute`). |
| `searchKeyword` | 🟢 High (100%) | The search keyword that discovered this listing. |
| `scrapedAt` | 🟢 High (100%) | ISO 8601 timestamp of extraction. |

All text fields are cleaned on the way out — Xing injects invisible soft hyphens into long German compound words for line-breaking, and this **Xing jobs scraper** strips them so `jobTitle`, `company` and `location` match cleanly when you group, filter or join downstream.

***

### 🔁 Pagination & scale

Xing's job search is paginated at roughly **20 listings per page**, and this scraper walks the pages automatically. It starts at page 1 for each keyword, parses every job card, enqueues the next page, and keeps going until it hits your limit, runs out of results, or reaches the end — so a single keyword can yield **hundreds to thousands of de-duplicated job listings**.

- **`maxItemsPerQuery`** controls how many jobs you collect per keyword. Set it to a number (e.g. `100`, `300`, `1000`) to cap the run, or `0` for **no limit** (collect everything Xing lists for that term and location).
- **De-duplication is built in** — every listing is keyed by its Xing `jobId`, so overlapping keywords never produce duplicate rows in your output.
- **Multiple keywords** run in the same job, each paginated independently, and all results land in one combined dataset.

Because Xing renders listings server-side, pagination is fast and stable — no headless browser, no fragile scrolling, just clean HTTP requests through a residential DE proxy.

***

### ✅ Proven results (fresh verification run)

A fresh run for `software engineer` across **all of DACH** returned **450 unique job listings in ~98 seconds with 0 duplicates**. Measured field coverage on that sample:

| Field | Fill rate |
| --- | --- |
| `jobTitle`, `company`, `location`, `jobUrl`, `isUrgent`, `additionalLocations` | **100%** |
| `employmentType` | **98.9%** |
| `jobId` | **93.3%** (present on native Xing listings; empty on externally-aggregated ones) |
| `salary` + numeric `salaryMin` / `salaryMax` | **~86%** (shown only where the employer publishes a range) |
| `postedDate` | **~25%** (Xing shows a recency label on only some cards) |

Salary parsing works on German number formats (e.g. `73.500 € – 96.500 €` → min `73500`, max `96500`), and every job is de-duplicated by its Xing `jobId` (falling back to `jobUrl` for aggregated listings).

> ℹ️ **About aggregated listings:** some Xing search results are sponsored/aggregated from partner sites (e.g. jobware.de). For those, `jobUrl` points to the external apply page and `jobId` is empty — that is expected, and they are still de-duplicated by URL so you never get repeats.

### ⭐ What makes this scraper stand out

- **Salary ranges, parsed.** Not just the text — numeric `salaryMin`/`salaryMax` for instant sorting and benchmarking.
- **DACH-native.** Handles German employment types, currencies and posting dates correctly.
- **No headless browser.** Xing renders server-side, so runs are fast and cheap.
- **Clean, de-duplicated output** ready for spreadsheets, BI tools or your CRM.

***

### 🛠️ Example workflows

Concrete, zero-code ways teams use this **Xing jobs scraper** end to end — just combine it with Apify Schedules, integrations and webhooks:

- **Recruiting pipeline.** Run target roles for a city each morning and push new listings straight to Google Sheets for your sourcers — hiring company, location and apply link included.
- **Salary benchmark.** Scrape one role (e.g. `data engineer`) across Berlin, München and Hamburg, export to CSV, and pivot `salaryMin`/`salaryMax` by city in minutes.
- **Competitor hiring monitor.** Schedule weekly runs, store each dataset, and chart posting volume over time — spikes reveal expansion before press releases do.
- **HR-tech lead list.** Group output by `company`, rank by posting count, and hand sales a timely, prioritized prospect list of actively-hiring firms.
- **Job board feed.** Pipe the structured output (title, company, location, salary, type, apply URL) straight into your aggregator via webhook or API.

### 🔌 Integrations

Send your Xing jobs data anywhere with Apify's built-in integrations and webhooks:

- **Google Sheets** — push job lists straight into a spreadsheet
- **Make (Integromat) & Zapier** — trigger workflows on every run
- **Slack / email** — get notified when new jobs are scraped
- **ATS / CRM / databases** — via API, webhooks or no-code connectors
- **Your own app** — pull results through the Apify API in JSON

***

### ▶️ How to use this Xing jobs scraper (step by step)

1. Click **Try for free** at the top of this page.
2. In the **Input** tab, add your keywords under `queries`.
3. Optionally set a `location` and the `maxItemsPerQuery` you need.
4. Click **Start** and wait for the run to finish.
5. Open the **Output / Dataset** tab and download your data as **JSON, CSV or Excel**, or copy the API endpoint to pull it programmatically.

You can also **schedule** the Actor to run daily/weekly to keep your job data fresh.

***

### ❓ Frequently asked questions

**Does it include salary data?**
Yes — Xing shows salary ranges on most listings, and the scraper returns both the text (`salary`) and parsed `salaryMin`/`salaryMax` numbers.

**Can I search in a specific city?**
Yes — set the `location` parameter (e.g. `Berlin`, `München`, `Wien`, `Zürich`) to bias results toward that area.

**How many jobs can I get?**
Xing paginates results, so a single keyword can return many hundreds of jobs. Set `maxItemsPerQuery` to your target.

**Does it work for Austria and Switzerland too?**
Yes — Xing covers the whole DACH region. Use `location` with Austrian or Swiss cities, and the scraper handles € and CHF salaries.

**Will I get duplicate jobs?**
No. Listings are de-duplicated by Xing job ID, so overlapping keywords won't create duplicate rows.

**Does it need a Xing login?**
No. The scraper reads public job search results — no account, no captcha solving.

**What export formats are supported?**
JSON, CSV, Excel (XLSX), XML and RSS — plus direct API access.

**Can I run it on a schedule?**
Yes. Use Apify Schedules to run the scraper automatically and keep your job database current.

**How fresh is the data?**
Every run scrapes Xing live, so listings reflect what's posted at the time you run it. Schedule recurring runs to catch new postings.

**Is scraping Xing legal?**
This Actor collects only publicly available job listings. You are responsible for using the data in compliance with Xing's terms of use and applicable laws (including data-protection rules such as GDPR where relevant).

**Why does it need a residential proxy?**
Xing refuses datacenter IP addresses, so the Actor defaults to a residential DE proxy. This is built in — you don't need to configure anything for it to work out of the box.

**Can I track competitor hiring over time?**
Yes. Schedule the Actor to run regularly for your competitors' typical roles and locations; a rising number of postings is a strong growth signal. Export each run and compare over time.

**Can I get jobs from a specific company?**
Search the role keywords you care about and filter the output by the `company` field, or add the company name to your keyword. Every record includes the hiring company.

**Does it return remote jobs?**
Remote and hybrid roles appear in the results like any other listing; the location and title usually indicate remote eligibility (e.g. "Remote", "Homeoffice").

**How do I build a salary benchmark report?**
Run a role across several cities, export to a spreadsheet, and analyze `salaryMin`/`salaryMax` by location and seniority — a ready-made compensation benchmark for the DACH market.

**What happens if a keyword returns no salary?**
Salary is shown only where the employer publishes it. Listings without a salary simply have empty `salary`/`salaryMin`/`salaryMax` fields; all other data is still captured.

***

### 💡 Tips & best practices

- **Use specific keywords.** `senior backend engineer` returns more relevant roles than just `engineer`. Combine related keywords for broader coverage.
- **Target a city** with `location` to focus on a single market and cut noise.
- **Set a realistic `maxItemsPerQuery`.** 100–300 per keyword suits most recruiting and research projects.
- **Export to a spreadsheet** and sort by `salaryMax` to find the best-paying roles, or by `postedDate` for the freshest listings.
- **Watch `isUrgent`** — urgently flagged roles are strong, time-sensitive outreach targets.
- **Schedule recurring runs** to monitor new postings and hiring trends over time.
- **De-duplication is automatic** — feel free to add overlapping keywords.
- **Run roles separately** to keep your output clean and easy to segment by function.
- **Use German keywords** for German-market roles (e.g. `Vertrieb` vs `sales`) to maximize relevant results.
- **Combine with Apify Schedules** to capture new postings the day they go live — recruiting is a speed game.
- **Filter the output by `employmentType`** to focus on full-time, part-time or contract roles as needed.

***

### ⚠️ Limitations

- Salary appears only on listings where the employer publishes it; some roles will have empty salary fields.
- Posting-date format varies by recency; very fresh or undated listings may have an empty `postedDate`.
- Result volume per keyword depends on how many jobs Xing lists for that term and location.

***

### ❔ Need company or people data too?

This Actor focuses on **job listings** — the highest-value, most-requested Xing dataset for recruiting and market research. If you also need Xing company profiles or people data, let us know via the Actor's issues page so we can prioritize it.

### 🌐 About Xing & the DACH job market

Xing (owned by New Work SE) is the leading professional network in the German-speaking world, with a strong focus on **Germany, Austria and Switzerland**. For recruiters and researchers targeting these markets, Xing is often more relevant than global platforms because:

- It is **DACH-native** — most listings, companies and candidates are local to the region.
- It publishes **salary ranges** openly on many job listings, which is rare among job boards.
- It covers the full spectrum from **skilled trades to executive roles**, across every major industry.
- German-language search terms surface roles that English-only tools miss entirely.

That makes Xing one of the best public sources for DACH labour-market data — and this **Xing jobs scraper** turns it into a structured dataset you can actually work with at scale.

### 🔗 Related scrapers

Building a cross-market talent pipeline or salary benchmark? Pair this **Xing jobs scraper** with our other job-board scrapers for global coverage:

- [Arbeitsagentur Job Scraper — Germany Jobs, Salary & Contacts](https://apify.com/haketa/arbeitsagentur-scraper) — Germany's official federal jobs portal, a perfect DACH companion to Xing.
- [SEEK Scraper — Australia & New Zealand Job Listings](https://apify.com/haketa/seek-scraper) — jobs with salary across the AU/NZ market.
- [ZipRecruiter Job & Salary Scraper (US, UK, IE, CA)](https://apify.com/haketa/ziprecruiter-scraper) — English-speaking job markets with salary data.
- [Naukri Scraper — India Jobs, Salary & Company Ratings](https://apify.com/haketa/naukri-scraper) — India's largest job board.
- [GulfTalent Jobs Scraper — Gulf Jobs, Salaries & Leads](https://apify.com/haketa/gulftalent-jobs-scraper) — Middle East / GCC hiring data.
- [Workana Jobs Scraper — Freelance Projects, Budgets & Skills](https://apify.com/haketa/workana-scraper) — freelance and remote project listings.

### 🚀 Get started

Click **Try for free**, enter a keyword like `software engineer` or `Projektleiter`, optionally pick a city, and get a clean list of DACH job listings — with company, location, salary and apply links — in minutes. Perfect for **recruiting, salary benchmarking, competitor hiring intelligence and job-market research**.

Have a feature request or question? Open an issue from the Actor's page and we'll help.

### 📋 Changelog

- **v1.2 (2026-11)** — Unlocked **1,000+ deep pagination** across single and multi-keyword runs (honoring explicit user limits on default-query runs), hardened null-safe text and date parsing, added automatic residential DE proxy upgrade, and refreshed documentation with `⚡ At a glance` and field coverage tables.
- **v1.1 (2026-11)** — Fixed `postedDate` regex alternation so full German plural recency labels (`Vor 2 Tagen`, `Vor 11 Stunden`) are captured cleanly; verified with a 450-listing DACH run (`0` duplicates).
- **v1.0 (2026-05)** — Initial release with DACH keyword & city search, German/Swiss salary range parser (`salaryMin`/`salaryMax`), soft-hyphen cleanup, and `jobId` deduplication.

# Changelog

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

# Actor input Schema

## `queries` (type: `array`):

Type the job titles or keywords you want, just like in the Xing job search (e.g. "software engineer", "marketing manager", "Projektleiter"). Add as many as you like. Leave empty to get a ready-made mix of popular DACH roles.

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

Pick a city or region to focus the search on the DACH job market. Choose "Everywhere" to search all of Germany, Austria and Switzerland.

## `locationCustom` (type: `string`):

Optional: type any other city or region if it is not in the list above. If filled, this overrides the dropdown.

## `maxItemsPerQuery` (type: `integer`):

Maximum number of job listings to collect for each keyword. Set to 0 for no limit (supports 1,000+ jobs across pages and queries). Xing returns ~20 jobs per page and is paginated automatically.

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

A DE/EU residential proxy is recommended for the best coverage of the DACH job market.

## Actor input object example

```json
{
  "queries": [
    "software engineer",
    "data analyst"
  ],
  "location": "",
  "locationCustom": "Mannheim",
  "maxItemsPerQuery": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}
```

# Actor output Schema

## `dataset` (type: `string`):

Open to view, filter and export all scraped results from this run (JSON, CSV, Excel).

# 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 = {
    "queries": [
        "software engineer"
    ],
    "maxItemsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ],
        "apifyProxyCountry": "DE"
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("haketa/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 = {
    "queries": ["software engineer"],
    "maxItemsPerQuery": 60,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
        "apifyProxyCountry": "DE",
    },
}

# Run the Actor and wait for it to finish
run = client.actor("haketa/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 '{
  "queries": [
    "software engineer"
  ],
  "maxItemsPerQuery": 60,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ],
    "apifyProxyCountry": "DE"
  }
}' |
apify call haketa/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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