# XING Jobs Scraper (`automation-lab/xing-jobs-scraper`) Actor

Scrape public XING job listings by keyword and location for recruiting, hiring-signal monitoring, and DACH labor-market analysis.

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

## Pricing

Pay per event

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/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

## XING Jobs Scraper

Extract public job listings from XING search pages for recruiting, labor-market analysis, and hiring-signal monitoring in Germany, Austria, and Switzerland.

### What does XING Jobs Scraper do?

XING Jobs Scraper turns public XING job search pages into structured datasets.

It can search by keyword and location or accept direct XING jobs search URLs.

The actor saves job titles, URLs, company names, locations, salary hints, employment type, application links, and freshness metadata.

Use it when you need repeatable job-market exports instead of manually copying listings from XING.

### Who is it for?

Recruiters use it to monitor new roles in target cities.

Staffing agencies use it to track companies that are actively hiring.

Sales teams use hiring activity as a buying-signal feed.

Market analysts use it to compare demand by job family and location.

Job-board operators use it to benchmark listings across DACH markets.

### Why scrape XING jobs?

XING is especially relevant in German-speaking markets.

Many DACH employers post roles there even when they do not prioritize global job boards.

Structured XING exports help you find companies hiring for specific skills, locations, and seniority levels.

### How it works

The actor fetches public XING jobs search pages with HTTP.

XING includes job-search data in the page state, so the actor does not need a browser for normal public search pages.

It parses that state, follows result pages, de-duplicates jobs, and pushes clean records to the dataset.

### Input options

You can provide keywords such as `developer`, `sales`, or `product manager`.

You can provide locations such as `Berlin`, `München`, `Hamburg`, `Wien`, or `Zürich`.

You can also provide one or more direct XING jobs search URLs.

Use direct URLs when you want to copy a search from XING exactly.

### Output data

Each dataset row represents one public XING job listing.

| Field | Description |
| --- | --- |
| `jobId` | Numeric XING job ID when available |
| `title` | Job title |
| `url` | Public XING job URL |
| `companyName` | Employer name |
| `companyUrl` | Company page URL when available |
| `location` | Primary location |
| `locations` | All listed locations |
| `employmentType` | Full-time, student, self-employed, or other XING value |
| `salaryMinimum` | Salary minimum if public |
| `salaryMaximum` | Salary maximum if public |
| `salaryMedian` | Salary median estimate if public |
| `applicationUrl` | External application URL when public |
| `refreshedAt` | XING refreshed timestamp |
| `activeUntil` | Listing active-until timestamp |
| `sourceKeyword` | Keyword used for this search |
| `sourceLocation` | Location used for this search |
| `scrapedAt` | Extraction timestamp |

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

This actor uses pay-per-event pricing.

There is a small start charge for each run.

Each saved job listing is charged as one result.

Actual platform pricing may change after cost validation, but the actor is designed for low-cost HTTP extraction.

Start with a small `maxItems` value, review the output, and then scale your monitoring run.

### Example input

```json
{
  "keywords": ["developer"],
  "locations": ["Berlin"],
  "maxItems": 20,
  "maxPages": 1
}
````

### Example with direct search URL

```json
{
  "searchUrls": [
    { "url": "https://www.xing.com/jobs/search?keywords=sales&location=M%C3%BCnchen" }
  ],
  "maxItems": 40,
  "maxPages": 2
}
```

### Tips for better results

Use German and English keywords when researching DACH markets.

Try both broad roles and specific technologies.

Use cities for focused lead generation.

Use `maxPages` to control how deep each search goes.

Run the same inputs on a schedule to monitor hiring changes over time.

### Common recruiting workflows

Track new software engineering jobs in Berlin every morning.

Find companies hiring sales roles in Munich.

Monitor renewable-energy job postings across Germany.

Export application URLs for staffing outreach.

Compare salary estimates across cities and job families.

### Integrations

Send dataset results to Google Sheets for recruiter review.

Use Make or Zapier to alert Slack when new jobs appear.

Export JSON to enrich CRM company records.

Use Apify webhooks to trigger downstream workflows after every run.

Join XING job data with company enrichment actors from the automation-lab portfolio.

### API usage

#### Node.js

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

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/xing-jobs-scraper').call({
  keywords: ['developer'],
  locations: ['Berlin'],
  maxItems: 20,
  maxPages: 1,
});
console.log(run.defaultDatasetId);
```

#### Python

```python
from apify_client import ApifyClient
import os

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/xing-jobs-scraper').call(run_input={
    'keywords': ['developer'],
    'locations': ['Berlin'],
    'maxItems': 20,
    'maxPages': 1,
})
print(run['defaultDatasetId'])
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/automation-lab~xing-jobs-scraper/runs?token=YOUR_APIFY_TOKEN' \
  -H 'Content-Type: application/json' \
  -d '{"keywords":["developer"],"locations":["Berlin"],"maxItems":20,"maxPages":1}'
```

### MCP usage

Connect Apify MCP to Claude Code or Claude Desktop with this actor enabled.

Use the MCP URL with the actor tool selected:

`https://mcp.apify.com?tools=automation-lab/xing-jobs-scraper`

Claude Code setup:

```bash
claude mcp add apify https://mcp.apify.com?tools=automation-lab/xing-jobs-scraper
```

Claude Desktop JSON setup:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/xing-jobs-scraper"
    }
  }
}
```

Example prompts:

- Scrape 20 XING developer jobs in Berlin.
- Find sales jobs on XING in München and summarize the hiring companies.
- Export XING product manager roles in Hamburg to a table.

### Data quality notes

The actor extracts only fields present in public XING page data.

Salary and application URLs are not available for every listing.

Some jobs use XING application flows instead of external application URLs.

Locations can include multiple cities for nationwide or hybrid roles.

### Limitations

The actor does not log in to XING.

It does not scrape private profiles or restricted pages.

It focuses on public jobs search/listing metadata.

If XING changes its public page state, extraction logic may need an update.

### Legality

This actor extracts publicly available job-listing data.

Always use the data responsibly and follow applicable laws, XING terms, and privacy requirements.

Do not use scraped data for spam, harassment, or unlawful automated decisions.

### FAQ

#### Does it require a XING account?

No. The actor is designed for public logged-out job search pages.

#### Why are some salary fields empty?

XING does not publish salary data for every job. Empty salary fields mean the source did not expose that value.

#### Why is `applicationUrl` empty for some jobs?

Some jobs use XING application flows or custom application types without a public external URL.

#### Can I scrape more than one city?

Yes. Add multiple locations; the actor will search each keyword/location combination.

#### Can I schedule monitoring?

Yes. Use Apify schedules and keep the same input to monitor a market over time.

### Related scrapers

- https://apify.com/automation-lab/xing-companies-scraper
- https://apify.com/automation-lab/linkedin-jobs-scraper
- https://apify.com/automation-lab/indeed-jobs-scraper

### Changelog

Initial version extracts public XING job search results from SSR page state.

### Support

Open an issue on the Apify actor page if a XING layout change breaks extraction.

Include your run ID and input so we can reproduce the problem quickly.

### Responsible scaling

Start with 20 jobs.

Increase to 100 jobs after reviewing the dataset.

Use reasonable schedules for monitoring.

Avoid duplicate searches when one direct URL is enough.

### Field reference

`paid` indicates whether XING marks the job as paid placement.

`topJob` indicates whether XING marks the job as a top job.

`redirectsToThirdPartyUrl` indicates whether the listing points users to an external application flow.

`sourceUrl` shows the exact result page that produced the row.

`page` and `position` help debug ranking and pagination.

# Actor input Schema

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

Job keywords to search for on XING, for example developer, sales, marketing, or product manager.

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

Optional XING location text. Use DACH cities such as Berlin, München, Hamburg, Wien, or Zürich.

## `searchUrls` (type: `array`):

Optional direct XING jobs search URLs. If provided, these are scraped instead of generated keyword/location searches.

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

Maximum number of unique job listings to save across all searches.

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

Maximum XING result pages to fetch per search URL or keyword/location combination. Each page usually contains up to 20 jobs.

## Actor input object example

```json
{
  "keywords": [
    "developer"
  ],
  "locations": [
    "Berlin"
  ],
  "searchUrls": [
    {
      "url": "https://www.xing.com/jobs/search?keywords=developer&location=Berlin"
    }
  ],
  "maxItems": 20,
  "maxPages": 1
}
```

# Actor output Schema

## `overview` (type: `string`):

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "keywords": [
        "developer"
    ],
    "locations": [
        "Berlin"
    ],
    "searchUrls": [
        {
            "url": "https://www.xing.com/jobs/search?keywords=developer&location=Berlin"
        }
    ],
    "maxItems": 20,
    "maxPages": 1
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/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 = {
    "keywords": ["developer"],
    "locations": ["Berlin"],
    "searchUrls": [{ "url": "https://www.xing.com/jobs/search?keywords=developer&location=Berlin" }],
    "maxItems": 20,
    "maxPages": 1,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/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 '{
  "keywords": [
    "developer"
  ],
  "locations": [
    "Berlin"
  ],
  "searchUrls": [
    {
      "url": "https://www.xing.com/jobs/search?keywords=developer&location=Berlin"
    }
  ],
  "maxItems": 20,
  "maxPages": 1
}' |
apify call automation-lab/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XING Jobs Scraper",
        "description": "Scrape public XING job listings by keyword and location for recruiting, hiring-signal monitoring, and DACH labor-market analysis.",
        "version": "0.1",
        "x-build-id": "Rmgw5jXDmSEb4wApi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~xing-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-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/automation-lab~xing-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-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/automation-lab~xing-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-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": {
                    "keywords": {
                        "title": "Keywords",
                        "type": "array",
                        "description": "Job keywords to search for on XING, for example developer, sales, marketing, or product manager.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "locations": {
                        "title": "Locations",
                        "type": "array",
                        "description": "Optional XING location text. Use DACH cities such as Berlin, München, Hamburg, Wien, or Zürich.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "XING search URLs",
                        "type": "array",
                        "description": "Optional direct XING jobs search URLs. If provided, these are scraped instead of generated keyword/location searches.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "maxItems": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 5000,
                        "type": "integer",
                        "description": "Maximum number of unique job listings to save across all searches.",
                        "default": 50
                    },
                    "maxPages": {
                        "title": "Maximum pages per search",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum XING result pages to fetch per search URL or keyword/location combination. Each page usually contains up to 20 jobs.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
