# XING Jobs Scraper (`scrapers-hub/xing-jobs-scraper`) Actor

XING Jobs scraper to extract job listings, company names, job titles, locations, posting dates, and other publicly available job data from XING Jobs 💼📊 Perfect for job market research, recruitment, talent sourcing, and employment trend analysis.

- **URL**: https://apify.com/scrapers-hub/xing-jobs-scraper.md
- **Developed by:** [Scrapers Hub](https://apify.com/scrapers-hub) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 1 total users, 0 monthly users, 55.3% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## XING Jobs Scraper

An [Apify](https://apify.com) actor that searches [XING](https://www.xing.com) job
listings by keyword and, optionally, enriches every posting with the full
description, responsibilities, requirements, benefits, company profile and
metadata.

### Input

```json
{
  "queries": ["software engineer"],
  "limit": 100,
  "enrich_data": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `queries` | `string[]` | `["software engineer"]` | Keywords to search. Each runs its own paginated search. |
| `startUrls` | `string[]` | – | Full `xing.com/jobs/search?...` URLs to scrape instead of / alongside `queries`. |
| `location` | `string` | – | City filter applied to every query. |
| `radius` | `integer` | `20` | Search radius in km around `location`. |
| `limit` | `integer` | `100` | Max postings per query. XING caps guest browsing at ~200 per search. |
| `enrich_data` | `boolean` | `true` | Fetch each detail page for full description + sections. |
| `proxyConfiguration` | `object` | RESIDENTIAL | **Required.** XING blocks datacenter IPs — use residential. |
| `maxConcurrency` | `integer` | `5` | Parallel detail-page fetches. Keep low to avoid blocks. |
| `maxRequestRetries` | `integer` | `5` | Retries per blocked/failed request. |

### Output

One dataset item per job posting. Card-level fields come from the search API;
the `enrichment` block and long-text fields are added when `enrich_data` is on.

```jsonc
{
  "id": "155102097.afd464",
  "url": "https://www.xing.com/jobs/heimertingen-software-engineer-...",
  "title": "Software Engineer - Mobile Application | Android (m/w/d)",
  "company": "blackned GmbH",
  "location": "Heimertingen",
  "employmentType": "Full-time",
  "salaryMin": 59500,
  "salaryMax": 78500,
  "salaryMedian": 64000,
  "currency": "EUR",
  "applyUrl": "https://t.gohiring.com/h/...",
  "refreshedAt": "2026-06-24T11:50:15+00:00",
  "activeUntil": "2026-08-08T11:50:17+00:00",
  "fullDescription": "…",
  "responsibilities": "…",
  "requirements": "…",
  "benefits": "…",
  "companyProfileUrl": "https://www.xing.com/pages/blacknedgmbh",
  "companyLogoUrl": "https://www.xing.com/imagecache/...",
  "companySize": "51-200 employees",
  "companyIndustry": "Software",
  "companyLocation": "Heimertingen, Germany",
  "enrichment": {
    "detailUrl": "…",
    "sections": {
      "companyDescription": { "title": "Über uns:", "text": "…", "html": "…" },
      "responsibilities":   { "title": "Deine Aufgaben:", "text": "…", "html": "…" },
      "benefits":           { "title": "Wir bieten Dir:", "text": "…", "html": "…" }
    },
    "company": { "profileUrl": "…", "logoUrl": "…", "size": "…", "industry": "…", "location": "…" },
    "metadata": { "language": "de", "remoteOptions": ["NON_REMOTE"], "activatedAt": "…", "activeUntil": "…" }
  },
  "source_context": {
    "source_url": "https://www.xing.com/jobs/search?keywords=software+engineer",
    "seed_type": "query",
    "seed_value": "software engineer",
    "page_index": 1
  }
}
```

### How it works

1. **Search** — [`src/xing_client.py`](src/xing_client.py) calls XING's
   `JobSearchByQuery` GraphQL operation (`https://www.xing.com/xing-one/api`)
   with a guest consent cookie, paginating in pages of 20 until `limit` is
   reached or results run out. Each result maps to the flat card-level fields.
2. **Enrich** (optional) — [`src/parse_detail.py`](src/parse_detail.py) fetches
   each job's detail page, extracts the `JobPosting` JSON-LD block for the
   description/salary/apply URL, and pulls the titled content sections from the
   embedded page state.
3. **Output** — [`src/main.py`](src/main.py) deduplicates by `id`, attaches
   `source_context`, and pushes to the dataset incrementally.

### Notes & maintenance

- **Residential proxy is essential.** XING challenges datacenter IPs and requires
  the consent cookie (already sent by the client). Without it you will get
  blocked/empty results.
- **If XING changes their GraphQL schema**, the query string in
  [`src/xing_client.py`](src/xing_client.py) (`JOB_SEARCH_QUERY`) is the single
  place to update. All field reads are defensive (`.get(...)`), so a partial
  change degrades to missing fields rather than a crash.
- **Section detection is heuristic** (`classify_section` in `parse_detail.py`):
  German and English headlines are matched to canonical keys
  (`companyDescription`, `responsibilities`, `requirements`, `benefits`,
  `contactInfo`). Add synonyms to `SECTION_KEYS` as needed.
- XING limits guest browsing to ~200 results per search — split broad searches
  into several keywords or cities to collect more.

### Run locally

```bash
python -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\activate
pip install -r requirements.txt
## set APIFY_TOKEN in your env for Apify Proxy, then:
apify run   # or: python -m src   (uses ./storage for input/output)
```

Requires Python 3.10+ (the actor image uses 3.13).

# Actor input Schema

## `enrich_data` (type: `boolean`):

Turn this on to open each individual XING listing page and collect richer job and company details: full description, responsibilities, requirements, benefits, company profile and metadata.

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

Use search words or phrases when you want the actor to build the search URLs for you. Each term runs its own paginated search. Example: \["software engineer", "backend developer"].

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

Add a location filter (city name) applied to every query, e.g. "Berlin".

## `radius` (type: `string`):

Search radius around the location, in kilometers. Only applies when a location is set.

## `date_posted` (type: `string`):

Limit query-built searches to recently posted jobs.

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

Filter by workplace / remote arrangement. Choose one or more.

## `employment_type` (type: `array`):

Filter by employment type. Choose one or more.

## `seniority` (type: `array`):

Filter by career level. Choose one or more.

## `min_price` (type: `integer`):

Only keep jobs whose salary range is at or above this value (EUR).

## `max_price` (type: `integer`):

Only keep jobs whose salary range is at or below this value (EUR).

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

Alternative to the query-building logic: full XING job search URLs to scrape, e.g. https://www.xing.com/jobs/search?keywords=python\&location=Berlin\&radius=20. Scraped in addition to any search terms.

## `limit` (type: `integer`):

Maximum number of job postings to collect per query. XING limits guest browsing to ~200 results per search.

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

XING blocks datacenter IPs and requires a consent cookie. RESIDENTIAL Apify Proxy is strongly recommended.

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

Maximum number of detail pages fetched in parallel. Keep low to avoid blocking.

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

How many times to retry a blocked/failed request before giving up.

## `introspect` (type: `boolean`):

Debug mode: instead of scraping, dump XING's real GraphQL job-search input schema into the log, then exit. Use to discover the correct query shape if a run fails with a GraphQL schema error.

## Actor input object example

```json
{
  "enrich_data": true,
  "queries": [
    "software engineer"
  ],
  "radius": "20",
  "limit": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  },
  "maxConcurrency": 5,
  "maxRequestRetries": 5,
  "introspect": false
}
```

# 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"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/7veuoCIr1b81PfFPd/builds/74HR73faoc3TJ2dEq/openapi.json