# XING Jobs Scraper - German Job Listings & Salary Data API (`parseforge/xing-scraper`) Actor

Extract public XING job postings across the DACH market: title, company, location, employment type, career level, industry and XING's own structured salary estimate with minimum, median and maximum.

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

## Pricing

from $4.45 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/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

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### XING Jobs Scraper - German Job Listings & Salary Data API

Scrape public job postings from XING, the professional network of the DACH region, and get back 43 flat fields per job — including XING's own salary band with **minimum, median and maximum**, the employer's company size and industry, the career level, the discipline, and the full advert body. No login, no API key, no cookies. Export to CSV, JSON, Excel, or XML.

XING has no public jobs API. Its search endpoint answers anonymous callers but hands back a walled `UnauthorizedJob` for every hit — an id and nothing else. This Actor takes the surface XING does publish for search engines, roughly **650,000 live postings**, and resolves each one to its complete public payload.

| Who uses it | What they scrape XING for |
| --- | --- |
| Salary benchmarking and comp teams | A modelled salary band on ~85% of postings, broken into min, median and max, with city, discipline and career level attached |
| Recruiters and staffing agencies | Fresh DACH vacancies with the employer named, the company size, and whether you can apply on XING or get bounced to a careers site |
| Job boards and aggregators | A daily German-market feed in one fixed schema, deduplicated by a stable numeric job id |
| Labour-market researchers | Volume by city, discipline, industry and seniority across Germany, Austria and Switzerland |
| Sales teams selling to HR | Companies actively hiring, with headcount bracket, industry and their XING company page |

### What it does

This Actor collects XING job postings by keyword, by city, or by exact URL, and returns each one as a flat row.

🇩🇪 **The DACH market, not just Germany.** Postings carry an ISO country code — DE, AT or CH — and a filter to keep only the ones you want.

💶 **Salary as three numbers, not a string.** `salaryMin`, `salaryMedian` and `salaryMax` come back as integers with a currency, plus a `salaryIsEstimate` flag telling you whether XING modelled the band or the employer typed it.

🏢 **The employer, not just its name.** `companySize` as a headcount bracket, `companyIndustry`, the XING company page URL, and a stable `companyId` you can join on across runs.

📍 **Location split into columns.** City, region, country, country code, street and postal code as separate fields — plus XING's internal `cityId`, which is stable across spellings.

🗂️ **XING's own taxonomy.** `discipline` from XING's list of 17 job families, `industry` from its list of around 55, and `careerLevel` from six seniority bands.

📝 **The advert body, HTML or plain text.** Optional, like the salary band, the employer profile and the full address — each is a checkbox that is off until you want it, and billed only then.

Results export to CSV, JSON, Excel, or XML, or stream from the API.

### What you can do with XING data

📊 **Benchmark German salaries by role and city.**

Pull every IT posting in München with a salary band and read the median directly — no scraping salary text out of prose, no currency parsing.

🎯 **Track who is hiring, and how hard.**

`postedAt`, `refreshedAt` and `daysOnline` on every row show which vacancies keep getting refreshed — the ones an employer is struggling to fill.

📈 **Build a DACH labour-market panel.**

Run it on a schedule and key on `jobId`. New ids are new vacancies; ids that vanish are filled or expired.

🧠 **Feed a recruiting or matching product.**

`keywords`, `discipline`, `careerLevel` and `remoteOptions` give you the structured signals a matching model needs, without an NLP pass over the advert.

### Why choose this scraper

| What you get | |
| --- | --- |
| Salary in three numbers | `salaryMin`, `salaryMedian`, `salaryMax` and a currency, on roughly 85% of postings. The median is the field competitors do not return. Optional, so you only pay for it when you want it. |
| Predictable bill | One per-row price by default. Every extra data block is a checkbox that is off until you tick it, so a run cannot surprise you with charges you did not ask for. |
| 43 fields per job | Every field XING publishes to anonymous callers, verified against the live endpoint rather than guessed. |
| No proxy, no login | XING answers plain requests. The Actor runs proxy-free by default, so a run costs you nothing in proxy traffic. |
| 16 filters that cut the bill | Keyword, city, salary range, employment type, career level, discipline, industry, country, language, remote option, posting age and direct-apply. Filtered rows are never written and never charged. |
| Company beyond the name | `companyId`, `companySize`, `companyIndustry` and the XING company page, when the employer has one. |
| Direct-apply flag | `directApply` and `redirectsToThirdPartyUrl` tell you whether the posting is a real XING vacancy or an aggregator bounce. |
| Honest empties | A field XING does not publish for a job is absent, never a guessed value and never a null. |
| Stable join key | `jobId` is XING's own numeric id and survives title edits and refreshes. |
| Four export formats | CSV, JSON, Excel, and XML, from the dashboard or the API. |

### How it compares

The competitor columns below reflect what each Actor's own public listing states, not a test run of it.

| Feature | ParseForge | shahidirfan | memo23 | fatihtahta | solidcode |
| --- | --- | --- | --- | --- | --- |
| Salary minimum and maximum | Yes | Not stated | Not stated | Yes | Yes |
| Salary **median** | Yes | No | No | No | No |
| Company size and industry | Yes | Not stated | Company pages, billed separately | Yes | Not stated |
| Discipline and career level | XING's own taxonomy, filterable | Not stated | Filterable | Not stated | Not stated |
| Filter before you pay | 16 filters, rejected rows unbilled | Not stated | Keyword, location, discipline | Not stated | Keyword and city |
| Fetch an exact posting by URL | Yes, URL, slug or bare id | Not stated | Yes, any xing.com URL | Not stated | Not stated |
| Profiles and company pages | No, jobs only | Yes | Yes | No | No |
| Runs without a proxy | Yes | Not stated | Not stated | Not stated | Not stated |
| Base price per result | $0.005 | $0.001 | $0.00119 | $0.00079 | $0.001 |

If you need XING **profiles or company pages** as well as jobs, memo23's actor covers all three. Come here when the job data itself is the product — particularly if you need the salary median or want to filter hard before paying.

### What a job looks like

Every posting returns as one flat JSON row. Here is a real record, unedited apart from a shortened description:

```json
{
  "jobId": "157336394",
  "jobHashId": "157336394.b53792",
  "slug": "herford-software-entwickler-microsoft-dynamics-365-business-central-157336394",
  "url": "https://www.xing.com/jobs/herford-software-entwickler-microsoft-dynamics-365-business-central-157336394",
  "title": "Software-Entwickler*in Microsoft Dynamics 365 Business Central",
  "company": "ATEGRAM GmbH",
  "companyId": "2021241.c27f57",
  "companyUrl": "https://www.xing.com/pages/ategram-gmbh",
  "companySize": "51-200 Mitarbeitende",
  "companyIndustry": "Großhandel",
  "city": "Herford",
  "region": "Nordrhein-Westfalen",
  "country": "Deutschland",
  "countryCode": "DE",
  "street": "Mindener Str. 9",
  "zipCode": "32049",
  "cityId": 2906121,
  "salaryCurrency": "EUR",
  "salaryMin": 54500,
  "salaryMax": 68500,
  "salaryMedian": 62500,
  "salaryIsEstimate": true,
  "employmentType": "Teilzeit",
  "careerLevel": "Mit Berufserfahrung",
  "industry": "Großhandel",
  "discipline": "IT und Softwareentwicklung",
  "remoteOptions": ["NON_REMOTE"],
  "isRemote": false,
  "language": "de",
  "keywords": ["softwareentwickler", "projektleitung", "wirtschaftsinformatik"],
  "jobCode": "10001-1003559130-S",
  "applicationType": "JobXingApplication",
  "directApply": true,
  "redirectsToThirdPartyUrl": false,
  "isPaidListing": false,
  "isTopJob": false,
  "postedAt": "2026-08-20T00:19:07Z",
  "refreshedAt": "2026-08-20T00:19:07Z",
  "activeUntil": "2027-08-20T00:20:35Z",
  "daysOnline": 0,
  "description": "<P>Zur Verstärkung unseres Teams suchen wir …</P>",
  "descriptionFormat": "html",
  "scrapedAt": "2026-08-20T13:38:10.863Z"
}
```

### Configure the run

| Setting | What it does |
| --- | --- |
| `keyword` / `keywords` | Job title, skill or keyword. Matched against the posting title, XING's own keyword tags, and the URL slug. A job matching any keyword is kept. |
| `city` / `cities` | City name. Umlauts are handled in both spellings, so `München`, `Munchen` and `muenchen` all match. |
| `jobUrls` | Exact postings to fetch, skipping discovery. Accepts a full URL, a bare slug, or the numeric job id. |
| `maxItems` | Ceiling on rows written. Not a target — a narrow filter returns fewer. |
| `maxSitemapShards` | How deep discovery may dig, 1 to 13. It stops as soon as it has enough, so a broad run reads one shard. |

| `descriptionFormat` | `html` keeps XING's markup, `text` flattens it to readable plain text. |
| `sortBy` | Discovery order (fastest), newest first, highest salary first, or title A–Z. |
| `proxyConfiguration` | Off by default. XING answers plain requests; enable only if your runs start getting rate-limited. |

#### Narrow the run with filters

Every filter runs before the row is written, so **rows you filter out are never charged**.

| Filter | What it keeps |
| --- | --- |
| `salaryMin` / `salaryMax` | Postings whose band overlaps the range you gave. Postings with no band are dropped by these. |
| `onlyWithSalary` | Only postings carrying a salary band at all. |
| `employmentTypes` | Vollzeit, Teilzeit, Studierende, Aushilfe, Selbstständig, Praktikum. |
| `careerLevels` | Six seniority bands, from Berufseinsteiger·in to Geschäftsführer·in. |
| `disciplines` | XING's 17 job families. Matched as a substring, so `IT` finds `IT und Softwareentwicklung`. |
| `industries` | Free text against XING's ~55 industry labels, for example `Software`, `Gesundheit`, `Automobil`. |
| `countries` | DE, AT, CH. |
| `languages` | German or English adverts. |
| `remoteOptions` | On site, hybrid, or fully remote. |
| `postedWithinDays` | Postings activated in the last N days. |
| `onlyDirectEmployer` | Drops postings that bounce the applicant to an external careers site. |

#### Why discovery works the way it does

XING's search API answers without a login, but every result comes back as `UnauthorizedJob` — the posting id and nothing else. Measured 20/08/2026: zero of ten search hits resolved to a readable job.

The sitemap XING publishes for search engines is a different story. It carries roughly 650,000 postings across 13 shards, and the jobs on it resolve to their full public payload. Around 15% sit behind the login wall anyway — they are skipped, logged, and never charged.

That is why the keyword and city filters are matched against the slug during discovery: it lets the Actor throw away non-matching postings before spending a request on them.

### Pricing

This Actor is **pay per event**, and a run left at its defaults has exactly one per-row price. Every optional data block is **off by default**: if you do not tick it, you do not receive it and you are not charged for it. Nothing is billed for rows a filter rejected.

| Event | Price | When it fires |
| --- | --- | --- |
| `result-item` | $0.005 | One job row. Covers the title, employer name, city and country, employment type, career level, industry, discipline, keywords, dates and apply flags. |
| `sitemap-scan` | $0.003 | One sitemap shard read. A broad run reads one; only a narrow filter reaches more. |
| `apify-actor-start` | $0.02 | Once when the run starts, per GB of memory. |

**Optional, and off unless you ask for them:**

| Event | Price | Switched on by |
| --- | --- | --- |
| `salary-data` | $0.001 | `includeSalary` — minimum, median and maximum with a currency. ~85% of postings carry one. |
| `company-data` | $0.0006 | `includeCompanyProfile` — company id, XING page, headcount bracket, industry. ~67% carry them. |
| `location-detail` | $0.0004 | `includeLocationDetail` — street, postal code, region, city id. |
| `description-text` | $0.0006 | `includeDescription` — the full advert body. ~91% carry one. |

A default run costs **$0.005 per job**, or $5.00 per 1,000. With all four optional blocks switched on it is **$0.0076** per job, or $7.60 per 1,000.

The salary filters are the exception worth knowing about: `salaryMin` and `salaryMax` work whether or not `includeSalary` is on. You can filter to the jobs that pay over €70,000 without buying the salary column.

### Free users

Apify free-plan runs are capped at **100 jobs per run**. Everything else works the same: all 43 fields, all 16 filters, and every optional block available to tick. Upgrade your Apify plan to lift the cap.

### Run it

1. Open the Actor in Apify Console and set a `keyword`, a `city`, or both.
2. Set `maxItems` to the number of jobs you want.
3. Click **Start**, then export the dataset as CSV, JSON, Excel, or XML.

Or from the API:

```bash
curl -X POST "https://api.apify.com/v2/acts/parseforge~xing-scraper/runs?token=YOUR_TOKEN" \
  -H 'Content-Type: application/json' \
  -d '{"keyword":"entwickler","city":"Berlin","salaryMin":55000,"maxItems":100}'
```

### Use with AI agents (MCP)

The Actor is exposed over Apify's MCP server, so an agent can call it as a tool:

```
https://mcp.apify.com/sse?actors=parseforge/xing-scraper
```

Ask things like *"find Berlin software jobs on XING paying over 70,000 euros"* and the agent fills the input itself.

### Troubleshooting

**No jobs came back.**

The filters are ANDed. A keyword plus a city plus a salary floor plus a discipline can genuinely match nothing in the shards read. Drop one filter at a time, and raise `maxSitemapShards` if it is not already 13.

**Fewer rows than `maxItems`.**

`maxItems` is a ceiling. Discovery stops when the shard budget is exhausted, and roughly 15% of sitemap postings are login-walled by XING. The log prints exactly how many were walled, expired, or filtered.

**Why is `street`, `zipCode` or `jobCode` empty?**

XING only carries them when the employer filled them in — measured at 53%, 57% and 61% of postings. An absent field is the source's real state, not a parsing failure.

**Why is `companyId` missing on some rows?**

About a third of employers post without a XING company page. `company` still holds the name they published.

**Why are salaries "estimates"?**

XING models a band for most postings from role, location and seniority. `salaryIsEstimate` is `true` in that case. It is XING's own figure, published on its own pages.

**Why is the run slow with a narrow filter?**

Each sitemap shard is a 1 MB download holding 50,000 URLs. A filter matching almost nothing forces the Actor through more of them. Widen the filter or lower `maxSitemapShards`.

**A field stopped filling.**

XING changed its GraphQL schema. Email us with your run ID so we can update the query.

### FAQ

| Question | Answer |
| --- | --- |
| Do I need a XING account or API key? | No. XING has no public jobs API. This reads public data only, so there is nothing to register or authenticate. |
| Does it cover Austria and Switzerland? | Yes. Postings carry an ISO country code and `countries` filters on it, though the market is overwhelmingly German. |
| Does it scrape XING profiles or company pages? | No. This Actor is jobs only. |
| Are the salaries real or estimated? | Mostly estimated — XING models a band and publishes it on the posting. `salaryIsEstimate` marks which. |
| Can I fetch one specific posting? | Yes. Put its URL, slug or numeric id in `jobUrls`. |
| How current is the data? | The sitemap is rebuilt daily and the Actor reads the newest shard first. `postedAt` and `daysOnline` are on every row. |
| How many jobs are reachable? | Around 650,000 across the 13 shards, of which roughly 85% resolve to a full public payload. |
| How many rows per run? | Free plan: 100. Paid: up to 100,000, bounded by how many postings match your filters and by the run timeout. |
| Does it need a proxy? | No. It runs proxy-free by default. |
| Is this an official XING product? | No. It is unofficial and reads only publicly available XING data. |

### Related actors

- [Bayt Scraper](https://apify.com/parseforge/bayt-scraper?fpr=vmoqkp): Middle East job listings across 18 markets.
- [InfoJobs Scraper](https://apify.com/parseforge/infojobs-scraper?fpr=vmoqkp): Spanish job board listings with salary and contract data.
- [D\&B Scraper](https://apify.com/parseforge/dnb-scraper?fpr=vmoqkp): company profiles, DUNS numbers, revenue and key principals.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

🆘 **Need help?** Email parseforge@protonmail.com with your run ID, your input, and what you expected.

⚠️ **Disclaimer.** This Actor is unofficial and is not affiliated with, endorsed by, or sponsored by XING, New Work SE, or its owners. It collects only publicly available XING data — job postings published for search engines — and no personal profiles. You are responsible for using the data in compliance with XING's terms and applicable laws, including GDPR. Job postings are corporate publications; do not use this data to identify, profile, or target individuals.

# Actor input Schema

## `keyword` (type: `string`):

Job title, skill or keyword. Matched against the posting title and XING's own keyword list. Leave empty to take every job in the scanned sitemap shards.

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

Run several keyword filters in one go. A job matching any of them is kept.

## `city` (type: `string`):

German, Austrian or Swiss city name, for example Berlin, Hamburg, Wien or Zürich.

## `cities` (type: `array`):

Several cities in one run. A job in any of them is kept.

## `jobUrls` (type: `array`):

Specific XING job URLs or slugs to fetch, skipping discovery entirely. Accepts https://www.xing.com/jobs/<slug>, a bare slug, or the numeric job id.

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

Maximum number of jobs written to the dataset. A ceiling, not a target — a narrow filter returns fewer.

## `maxSitemapShards` (type: `integer`):

Upper bound on how deep discovery digs. XING publishes its jobs across 13 sitemap shards of 50,000 URLs each, oldest first, and this Actor reads them newest-first. It stops as soon as it has enough candidates, so a broad run touches one shard and only a narrow filter reaches the full 13. Each shard actually read is one sitemap-scan event.

## `salaryMin` (type: `integer`):

Keep only jobs whose salary range reaches at least this figure. Jobs with no salary published are dropped by this filter.

## `salaryMax` (type: `integer`):

Keep only jobs whose salary range starts at or below this figure.

## `onlyWithSalary` (type: `boolean`):

Drop postings where XING publishes no salary figures. Around 85 percent of postings carry one.

## `employmentTypes` (type: `array`):

Keep only these employment types. XING labels these in German on every posting, whatever language the ad is written in.

## `careerLevels` (type: `array`):

Keep only these seniority levels.

## `remoteOptions` (type: `array`):

Keep only jobs offering these working arrangements.

## `disciplines` (type: `array`):

Keep only these job families. Matched as a substring, so "IT" also finds "IT und Softwareentwicklung".

## `industries` (type: `array`):

Keep only jobs in industries whose XING label contains any of these strings, for example "Software", "Gesundheit" or "Automobil". XING uses around 55 German industry labels.

## `countries` (type: `array`):

Keep only jobs in these countries. XING is the DACH network, so postings are overwhelmingly German.

## `languages` (type: `array`):

Keep only postings written in these languages.

## `postedWithinDays` (type: `integer`):

Keep only jobs activated in the last N days. Sitemap shards are ordered oldest to newest, so pair a tight window with a low shard count.

## `onlyDirectEmployer` (type: `boolean`):

Drop postings that hand the applicant off to an external site, keeping only jobs you can apply to on XING itself.

## `includeSalary` (type: `boolean`):

Adds XING's salary estimate — minimum, median and maximum with a currency — to every job that publishes one. Billed per row that actually carries a band, around 85% of postings. Off by default so a run costs only the base row price. The salaryMin and salaryMax filters work whether or not this is on.

## `includeCompanyProfile` (type: `boolean`):

Adds the XING company id, company page URL, headcount bracket and industry. Billed per row that carries them, around 67% of postings. The employer's name is always included and costs nothing extra.

## `includeLocationDetail` (type: `boolean`):

Adds street, postal code, federal state or canton, and XING's internal city id. Billed per row that carries them. City, country and country code are always included.

## `includeDescription` (type: `boolean`):

Adds the full advert body. Billed per row that carries one, around 91% of postings. Leaving it off also makes the run noticeably faster, because XING does not have to send the body.

## `descriptionFormat` (type: `string`):

Only applies when the description is switched on. HTML keeps XING's markup; plain text flattens it.

## `sortBy` (type: `string`):

Sorting collects candidates before writing, so the run takes longer than the default streaming order.

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

Optional. XING answers plain requests, so this Actor runs without a proxy by default and costs you nothing in proxy traffic. Enable it only if your runs start getting rate-limited.

## Actor input object example

```json
{
  "keyword": "entwickler",
  "keywords": [
    "entwickler",
    "pflegekraft"
  ],
  "cities": [],
  "jobUrls": [],
  "maxItems": 100,
  "maxSitemapShards": 13,
  "onlyWithSalary": false,
  "employmentTypes": [],
  "careerLevels": [],
  "remoteOptions": [],
  "disciplines": [],
  "industries": [],
  "countries": [],
  "languages": [],
  "onlyDirectEmployer": false,
  "includeSalary": false,
  "includeCompanyProfile": false,
  "includeLocationDetail": false,
  "includeDescription": false,
  "descriptionFormat": "html",
  "sortBy": "none",
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Every job row this run saved.

# 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 = {
    "keyword": "entwickler",
    "keywords": [
        "entwickler",
        "pflegekraft"
    ],
    "maxItems": 100,
    "maxSitemapShards": 13
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/xing-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 = {
    "keyword": "entwickler",
    "keywords": [
        "entwickler",
        "pflegekraft",
    ],
    "maxItems": 100,
    "maxSitemapShards": 13,
}

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

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

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

```

## CLI example

```bash
echo '{
  "keyword": "entwickler",
  "keywords": [
    "entwickler",
    "pflegekraft"
  ],
  "maxItems": 100,
  "maxSitemapShards": 13
}' |
apify call parseforge/xing-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/xing-scraper"
        }
    }
}

```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/rIdojHd0c9sSfHt1r/builds/YZYEmK8UVK6iuyaDK/openapi.json