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

Extract public XING job listings with title, employer, location, salary estimate, employment type, apply URL, and source timestamps.

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

## Pricing

from $1.50 / 1,000 job returneds

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 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/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

Collect public XING job listings for DACH hiring research. Each dataset record contains the job title, employer, location, employment type, salary estimate when XING displays one, XING job URL, public apply URL, XING refresh time, and collection time.

Use this actor for public vacancy discovery, compensation benchmarking, recruiting intelligence, and labour-market analysis. Its focused scope is public XING job listings; profile and private-account workflows belong in purpose-built tools with the appropriate permissions.

### A practical recruiting workflow

Start with a narrow role and location such as `data analyst` in `Berlin`. The actor returns normalized job rows that can be grouped by employer, city, employment type, and annual salary range. Keep `jobUrl` and `refreshedAt` for later monitoring; use `applyUrl` only as the public destination supplied by XING.

### Input modes

| Input | Use it when |
| --- | --- |
| `searchQuery` + `location` | You want the actor to generate a public XING Jobs search. |
| `startUrls` | You already have public XING job or job-search URLs, including advanced filters created on XING. |
| `maxResults` | You need a hard cap of 1–100 validated job rows. |

```json
{
  "searchQuery": "software engineer",
  "location": "Berlin",
  "maxResults": 20
}
````

### Output data

```json
{
  "jobId": "153735338",
  "title": "Software Engineer (m/w/d)",
  "companyName": "Example GmbH",
  "location": "Berlin",
  "employmentType": "Vollzeit",
  "salaryMin": 60000,
  "salaryMax": 80000,
  "salaryCurrency": "EUR",
  "jobUrl": "https://www.xing.com/jobs/berlin-software-engineer-153735338",
  "applyUrl": "https://careers.example.com/jobs/123",
  "refreshedAt": "ISO-8601 timestamp when supplied by XING",
  "sourceUrl": "https://www.xing.com/jobs/t-software-engineer?keywords=software+engineer",
  "scrapedAt": "ISO-8601 collection timestamp"
}
```

Records only include public fields that XING exposes on the page. Salary and application fields are `null` when XING does not show them.

| Field | Meaning |
| --- | --- |
| `title`, `companyName`, `location` | Core vacancy identity and employer context. |
| `salaryMin`, `salaryMax`, `salaryCurrency` | XING’s displayed salary estimate, with `null` for an unavailable estimate. |
| `jobUrl`, `applyUrl` | The public XING source and its public application destination. |
| `refreshedAt`, `sourceUrl`, `scrapedAt` | Freshness and provenance fields for follow-up monitoring. |

### Pricing

This actor uses Pay per event with platform usage passed through. A `job-found` event is charged only after a validated job record is written to the default dataset. An `apify-actor-start` event covers actor setup. See the live Pricing tab for the effective prices and platform-usage component.

### API and agent use

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~xing-jobs-scraper/runs" \
  -H "Authorization: Bearer YOUR_APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"searchQuery":"software engineer","location":"Berlin","maxResults":20}'
```

AI agent / MCP prompt:

> Find up to 20 public XING software-engineer jobs in Berlin. Return title, employer, location, salary range, job URL, and apply URL. Report missing salary fields as null, then read `OUTPUT` and `RUN_SUMMARY` before using the dataset.

The default dataset is paginated by the Apify API; request a small page first and increase the offset for later rows. Every result carries `sourceUrl` and `scrapedAt` so an agent can preserve its provenance and freshness context. `OUTPUT` and `RUN_SUMMARY` use `COMPLETE`, `PARTIAL`, `VALID_EMPTY`, `INVALID_INPUT`, or `UPSTREAM_FAILED` to state the terminal result clearly.

### Best results and limits

- Use a precise role query and a practical result cap.
- Use a public XING search URL when you need XING-specific filters beyond role and location.
- Preserve `jobUrl`, `sourceUrl`, and `scrapedAt` for provenance.
- XING pages can evolve and optional fields can be absent. Check `RUN_SUMMARY` for guidance and use `OUTPUT.outcome` to distinguish complete, partial, valid-empty, and upstream-status runs.

### Builder's note

I designed the actor around the structured state that XING renders with its public job pages instead of guessing from visual card markup. That keeps the record contract compact, preserves the public source and refresh timestamps, and allows missing salary or apply fields to remain explicit `null` values rather than misleading placeholders.

### Focused standalone workflow

This actor is designed as a focused standalone workflow for public XING vacancy collection. Pair its normalized output with your ATS, spreadsheet, BI, or market-analysis workflow after inspecting the run outcome and source timestamps.

### Responsible use

This actor collects public job-listing information. Use it for legitimate research in accordance with applicable law, XING’s terms, and your organisation’s data-governance requirements. Keep workflows focused on public listings, authorised access, and human-reviewed employment decisions.

# Actor input Schema

## `searchQuery` (type: `string`):

Free-text role or skill terms to search on XING Jobs, such as 'software engineer'. Use ordinary job-search words; XING matches them against public job postings. Defaults to 'software engineer' and is ignored when direct URLs are supplied. This is not a profile, employer, or candidate query.

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

Optional city or region appended to a generated public XING job search, for example 'Berlin'. Use it to narrow a search query geographically. Leave it blank to search across locations, and use a direct XING search URL for advanced XING filters. This is not a country-code or radius field.

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

Optional public XING job-detail or job-search URLs to extract, for example 'https://www.xing.com/jobs/berlin-software-engineer-153735338'. When supplied, these URLs take precedence over generated search input. Supply only public xing.com/jobs URLs, not XING profile, login, or company pages. At most 10 URLs are accepted.

## `maxResults` (type: `integer`):

Maximum number of validated job records to return across the run. Enter an integer from 1 through 100; the default is 20 to keep a typical request small and predictable. The actor stops writing after the cap, even if XING shows more jobs. This does not request unlimited pagination.

## Actor input object example

```json
{
  "searchQuery": "data analyst",
  "location": "Munich",
  "startUrls": [
    {
      "url": "https://www.xing.com/jobs/berlin-software-engineer-153735338"
    }
  ],
  "maxResults": 25
}
```

# Actor output Schema

## `jobs` (type: `string`):

No description

## `output` (type: `string`):

No description

## `runSummary` (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 = {
    "searchQuery": "software engineer",
    "location": "Berlin",
    "startUrls": [],
    "maxResults": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/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 = {
    "searchQuery": "software engineer",
    "location": "Berlin",
    "startUrls": [],
    "maxResults": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/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 '{
  "searchQuery": "software engineer",
  "location": "Berlin",
  "startUrls": [],
  "maxResults": 20
}' |
apify call khadinakbar/xing-jobs-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "XING Jobs Scraper",
        "description": "Extract public XING job listings with title, employer, location, salary estimate, employment type, apply URL, and source timestamps.",
        "version": "1.0",
        "x-build-id": "lsWHBuWJj5brkMAWj"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/khadinakbar~xing-jobs-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-khadinakbar-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/khadinakbar~xing-jobs-scraper/runs": {
            "post": {
                "operationId": "runs-sync-khadinakbar-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/khadinakbar~xing-jobs-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-khadinakbar-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": {
                    "searchQuery": {
                        "title": "Job search query",
                        "type": "string",
                        "description": "Free-text role or skill terms to search on XING Jobs, such as 'software engineer'. Use ordinary job-search words; XING matches them against public job postings. Defaults to 'software engineer' and is ignored when direct URLs are supplied. This is not a profile, employer, or candidate query.",
                        "default": "software engineer"
                    },
                    "location": {
                        "title": "Location",
                        "type": "string",
                        "description": "Optional city or region appended to a generated public XING job search, for example 'Berlin'. Use it to narrow a search query geographically. Leave it blank to search across locations, and use a direct XING search URL for advanced XING filters. This is not a country-code or radius field.",
                        "default": "Berlin"
                    },
                    "startUrls": {
                        "title": "Direct XING job URLs",
                        "type": "array",
                        "description": "Optional public XING job-detail or job-search URLs to extract, for example 'https://www.xing.com/jobs/berlin-software-engineer-153735338'. When supplied, these URLs take precedence over generated search input. Supply only public xing.com/jobs URLs, not XING profile, login, or company pages. At most 10 URLs are accepted.",
                        "items": {
                            "type": "object",
                            "properties": {
                                "url": {
                                    "title": "Public XING Jobs URL",
                                    "description": "A public XING job-detail or job-search URL, for example 'https://www.xing.com/jobs/berlin-software-engineer-153735338'. Use only pages under xing.com/jobs. The actor validates the HTTPS host and path before collection. This is not a profile or login URL.",
                                    "type": "string"
                                }
                            },
                            "required": [
                                "url"
                            ]
                        },
                        "default": []
                    },
                    "maxResults": {
                        "title": "Maximum jobs",
                        "minimum": 1,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of validated job records to return across the run. Enter an integer from 1 through 100; the default is 20 to keep a typical request small and predictable. The actor stops writing after the cap, even if XING shows more jobs. This does not request unlimited pagination.",
                        "default": 20
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
