# XING Jobs Scraper — DACH Job Listings | from $1.09/1K (`bovi/xing-jobs-scraper`) Actor

Scrape XING job listings for the DACH market (Germany, Austria, Switzerland). Returns job ID, title, company, location, salary, employment type, posted date, and description snippet. No login required. Paginated search with keyword + optional location filter.

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

## Pricing

from $1.09 / 1,000 job-listings

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

Scrape public job listings from **XING** — the leading professional network and job board for the DACH market (Germany, Austria, Switzerland). Extracts job titles, companies, locations, salary ranges, employment types, and more. **No login required. No external API key needed.**

### What it does

The actor fetches XING's jobs search page (`/jobs/search`) and extracts all job data from XING's embedded Apollo/GraphQL cache — the same structured data that powers the XING website. Because it reads the server-side-rendered data directly (not scraped HTML classes), the parser is resilient to frontend redesigns.

- **Keyword search** with optional location filter
- **Pagination** — up to 5 pages × 20 jobs = 100 results per keyword (XING's logged-out cap)
- **Multi-keyword support** — pass multiple keywords; results are deduplicated by job ID
- **Salary extraction** — normalized as `"55,000–70,000 EUR/yr"` when XING provides it
- **Confidence scoring** — each record has a `parse_confidence` (0.0–1.0) and `warnings` field so you know how complete the parse was
- **PPE pricing** — you pay only for records successfully extracted and pushed

### How to use

#### Basic: scrape software jobs in Berlin

```json
{
  "searchKeywords": ["Software Engineer"],
  "location": "Berlin",
  "maxItems": 100
}
````

#### Multiple keywords across Germany

```json
{
  "searchKeywords": ["Product Manager", "UX Designer", "DevOps Engineer"],
  "location": "",
  "maxItems": 300,
  "maxPages": 5
}
```

#### Full input reference

| Field | Type | Default | Description |
|---|---|---|---|
| `searchKeywords` | string\[] | `["Software Engineer"]` | Job search keywords. Each runs a separate search. |
| `location` | string | `""` | City or region: `"Berlin"`, `"München"`, `"Zürich"`, etc. Empty = all DACH. |
| `maxItems` | integer | `100` | Total job records cap across all keywords. |
| `maxPages` | integer | `5` | Pages per keyword (max 10). Each page = ~20 jobs. |
| `proxyConfiguration` | proxy | RESIDENTIAL | Proxy settings. Actor works without proxy via TLS impersonation; RESIDENTIAL is fallback for geo-restrictions. |

### Output schema

Each record contains:

```json
{
  "job_id": "3423872",
  "title": "Senior Backend Engineer (Python)",
  "company": "TechCorp GmbH",
  "company_id": "2239127",
  "location": "Berlin",
  "zip_code": null,
  "region": "Berlin",
  "country_code": null,
  "employment_type": "FULL_TIME",
  "salary": "70,000–90,000 EUR/yr",
  "salary_min": 70000,
  "salary_max": 90000,
  "salary_currency": "EUR",
  "remote_option": "REMOTE",
  "career_level": "SENIOR",
  "posted_date": "2026-06-01T08:00:00",
  "active_until": "2026-07-01T08:00:00",
  "job_url": "https://www.xing.com/jobs/berlin-senior-backend-engineer-3423872",
  "apply_url": null,
  "description_snippet": "We are looking for a Senior Backend Engineer to join our growing team…",
  "source_query": "Software Engineer",
  "source_page": 1,
  "scraped_at": "2026-06-07T12:00:00Z",
  "parse_confidence": 1.0,
  "warnings": []
}
```

Fields that XING doesn't expose for a given listing will be `null` — this is normal. Salary and country code are only available when XING includes them in the search result cache.

### Pricing

**$1.09 per 1,000 job listings** — charged per record pushed to the dataset.

Example:

- 100 jobs → $0.11
- 1,500 jobs → $1.64
- XING caps logged-out results at ~100/keyword — to get more, use more keywords.

You supply compute via your Apify account. No external API keys, no subscriptions.

### Anti-bot & proxy

XING serves job data to logged-out users without aggressive bot protection. The actor uses **Chrome 131 TLS impersonation** (`curl_cffi`) which passes XING's fingerprint checks without proxy in most cases.

RESIDENTIAL proxy is enabled by default as a fallback for geo-restricted requests. Proxy compute is billed to your Apify account at standard Apify rates — no markup.

### XING data limits

XING limits logged-out job searches to approximately **100 results per query** (5 pages × 20 items). The `boundedTotal` field on the XING results page reflects this cap. To collect more jobs across different specializations, use multiple keywords.

### FAQ

**Does it require XING login?**
No. All data is extracted from the public logged-out job search.

**What DACH locations are supported?**
Any city or region XING recognizes: `Berlin`, `München`, `Hamburg`, `Frankfurt am Main`, `Zürich`, `Wien`, `Köln`, etc. Leave `location` empty to search all of DACH.

**Why do some jobs have `salary: null`?**
XING only shows salary ranges when the employer explicitly provides them. Most job listings on XING do not include salary data.

**Can I get full job descriptions?**
The `description_snippet` is extracted from the search result page (up to 350 characters). Full descriptions require loading each job detail page — this increases run time and proxy usage significantly and is not enabled by default.

**Why does `country_code` show null?**
The XING jobs search page Apollo cache does not include country at the listing level — only city/region. Country is available on individual job detail pages.

**How often should I run it?**
XING job listings refresh continuously. For monitoring purposes, daily or weekly runs are typical.

**The actor returned fewer than expected results.**
XING's logged-out search cap is 100 results per keyword. If you need broader coverage, pass more specific or varied keywords (e.g. `["Python Engineer", "Django Developer", "Backend Python"]`).

### Legal disclaimer

This actor scrapes **publicly available job listings** from XING's job search — the same data visible to any logged-out visitor. Job listings are not personal data under GDPR (they describe a position, not an individual).

This actor is not affiliated with, endorsed by, or sponsored by XING SE (a New Work SE company). Use of this tool must comply with XING's Terms of Service and applicable law.

# Actor input Schema

## `searchKeywords` (type: `array`):

Job search keywords. Each keyword runs a separate search. E.g. \["Software Engineer", "Product Manager"].

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

City or region to filter jobs. E.g. 'Berlin', 'München', 'Hamburg', 'Zürich'. Leave empty for all DACH locations.

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

Maximum total job records to return across all keywords. XING caps search at ~100 results per query.

## `maxPages` (type: `integer`):

Max pages to fetch per keyword. Each page returns up to 20 jobs. XING caps at ~5 pages (100 results).

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

Proxy settings. The actor works without proxy using Chrome TLS impersonation. If geo-blocked, use Apify RESIDENTIAL proxy.

## Actor input object example

```json
{
  "searchKeywords": [
    "Software Engineer"
  ],
  "location": "Berlin",
  "maxItems": 100,
  "maxPages": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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 = {
    "searchKeywords": [
        "Software Engineer"
    ],
    "location": "Berlin",
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("bovi/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 = {
    "searchKeywords": ["Software Engineer"],
    "location": "Berlin",
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

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

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

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

```

## CLI example

```bash
echo '{
  "searchKeywords": [
    "Software Engineer"
  ],
  "location": "Berlin",
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call bovi/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bovi/xing-jobs-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XING Jobs Scraper — DACH Job Listings | from $1.09/1K",
        "description": "Scrape XING job listings for the DACH market (Germany, Austria, Switzerland). Returns job ID, title, company, location, salary, employment type, posted date, and description snippet. No login required. Paginated search with keyword + optional location filter.",
        "version": "0.1",
        "x-build-id": "449kaYWXx287XX9Gc"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bovi~xing-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bovi-xing-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bovi~xing-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-bovi-xing-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bovi~xing-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-bovi-xing-jobs-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "searchKeywords": {
                        "title": "Search keywords",
                        "type": "array",
                        "description": "Job search keywords. Each keyword runs a separate search. E.g. [\"Software Engineer\", \"Product Manager\"].",
                        "items": {
                            "type": "string"
                        }
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "City or region to filter jobs. E.g. 'Berlin', 'München', 'Hamburg', 'Zürich'. Leave empty for all DACH locations."
                    },
                    "maxItems": {
                        "title": "Max items total",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum total job records to return across all keywords. XING caps search at ~100 results per query.",
                        "default": 100
                    },
                    "maxPages": {
                        "title": "Max pages per keyword",
                        "minimum": 1,
                        "maximum": 10,
                        "type": "integer",
                        "description": "Max pages to fetch per keyword. Each page returns up to 20 jobs. XING caps at ~5 pages (100 results).",
                        "default": 5
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration",
                        "type": "object",
                        "description": "Proxy settings. The actor works without proxy using Chrome TLS impersonation. If geo-blocked, use Apify RESIDENTIAL proxy."
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```