# Jobware Jobs Search Scraper (`alexist/jobware-jobs-search-scraper`) Actor

Scrape German job listings from Jobware.de search pages in seconds. Collect job titles, salaries, locations, company info, and 17+ data fields per listing — perfect for job aggregators, market research, and recruitment analytics.

- **URL**: https://apify.com/alexist/jobware-jobs-search-scraper.md
- **Developed by:** [Alex](https://apify.com/alexist) (community)
- **Categories:** Automation, Jobs, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

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

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

## Jobware.de Jobs Search Scraper: Bulk Extract German Job Listings

---

### What Is Jobware.de?

Jobware.de is Germany's prominent online job portal specializing in IT, engineering, and technical roles across German-speaking regions. It hosts thousands of active listings daily and serves as a key recruitment channel for employers targeting the German tech talent market. Manually extracting job search results is inefficient and error-prone — the **Jobware Jobs Search Scraper** automates bulk data collection from search pages, delivering structured records ready for analysis, aggregation, or reporting.

---

### Overview

The **Jobware Jobs Search Scraper** extracts job listings from Jobware.de search results pages (not individual job detail pages). It is optimized for:

- **Job aggregators** building multi-source job databases
- **HR professionals** conducting market research on German tech hiring
- **Recruitment agencies** tracking competitor postings and market gaps
- **Data analysts** studying employment trends in technical sectors
- **Career platforms** enriching job catalogs with German listings

Key features include flexible URL handling, configurable item limits per search page, and robust error handling via `ignore_url_failures`.

---

### Input Format

The scraper accepts a minimal JSON configuration:

```json
{
  "urls": [
    "https://www.jobware.de/jobs/it",
    "https://www.jobware.de/jobs/python",
    "https://www.jobware.de/jobs/berlin"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
````

#### Configuration Fields

| Parameter | Type | Description |
|---|---|---|
| `urls` | Array | Collection of Jobware search page URLs. Start with a category URL (e.g., `/jobs/it`) or location-based search (e.g., `/jobs/berlin`). Multiple URLs allow you to cover different job categories in a single run. |
| `max_items_per_url` | Integer | Maximum number of job listings to extract per URL. Default: `20`. Increase for larger datasets, but be aware that pagination or result depth may limit actual items returned. |
| `ignore_url_failures` | Boolean | If `true`, the scraper continues running even if some URLs fail to load (network errors, page structure changes, etc.). If `false`, a single failed URL halts the entire run. Recommended: `true` for reliability. |

> **Pro tip:** Combine multiple search URLs to build comprehensive datasets — e.g., one URL per job category (IT, engineering, finance) or one per region (Berlin, Munich, Hamburg).

***

### Output Format

#### Example Output Record

```json
{
  "advertiser": {
    "logo": "https://www.jobware.de/jobresources/logo/473/5473/341/001048341/32/11288_4_160x80.gif",
    "name": "BYK-Gardner GmbH",
    "dummy": false
  },
  "apply": {
    "type": "EXTERN",
    "url": "https://www.jobware.de/apply/zBXNqSAJ1WoLI4k7VNXfGQS9aX2iq7EHcDRjfm5asdnhSlDS-3fK821EKbVSqtXcqBq5RaXiCg1nf_GnEsSKrc6jGUo6bg_RyRNRHbF99foH6OHf7o6ojVABNsvPCYRwXkcjNLwNk7E6umfoUvd2YGCAT7iTdlp6YWPMlxlJraXVRNwikcM2fx_9rp9EmMlJN2PAcS_HF1RNcUu_DBiQbXX06jYEzubTURB2j64zjUEEDtwqBv8_ifzhqCQMUU9fhiNxK-aZ9o307O7upJWW1zR9e2FOjEfv_I22cKXCWw"
  },
  "business_reference": "063007766",
  "date": 1784178000000,
  "id": "2009652865",
  "jobtypes": [
    {
      "id": 2031,
      "name": "Vollzeit"
    }
  ],
  "labels": [],
  "location": "Geretsried",
  "location_infos": [
    {
      "address": "Lausitzer Straße 8, 82538 Geretsried (GPS: 11.49, 47.85)",
      "lat": "47.857475",
      "lon": "11.493724",
      "strasse": "Lausitzer Straße",
      "hausnummer": "8",
      "plz": "82538",
      "ort": "Geretsried",
      "iso2_country_code": "DE",
      "type": "ADRESSE",
      "land": "Deutschland"
    }
  ],
  "mandant": "jw",
  "product_type": "Job",
  "title": "Senior Full Stack Developer (m/w/d)",
  "url": "senior-full-stack-developer-m-w-d.2009652865.html",
  "resource_url": "/jobresources/job/473/5473/766/063007766/063243137/index.html",
  "resource_url_with_tracking": "https://www.jobware.de/jobsearch/embed/job/4135/473/5473/766/063007766/063243137/index.html",
  "task": "Koordination aller Softwareprojekte mit unserem Dienstleister inklusive technischer Planung und Steuerung\nFrontend-Entwicklung: Konzeption und Implementierung von User-Interfaces in BYK-Webanwendungen mit Angular und TypeScript\nBackend-Entwicklung: Entwicklung und Wartung der Backend-Services, Business-Logik und APIs unter Verwendung von C# und ASP.NET Core\nAuthentifizierung und Sicherheit: Implementierung und Wartung von sicheren Auth-Lösungen (OAuth2, OpenID Connect, JWT, Azure Entra ID)\nDatenbanken: Anbindung relationaler Datenbanken (z. B. MS SQL Server, PostgreSQL) an und Optimierung von Abfragen mittels Entity Framework Core\nCI/CD und DevOps: Gestaltung und Pflege von Build- und Deployment-Pipelines (z. B. Azure DevOps Pipelines), um automatisierte Qualitätssicherung zu gewährleisten\nTechnische Koordination (~20 %) der technischen Planung und Steuerung von Entwicklungsprojekten, Definition von Arbeitspaketen und Schnittstelle zwischen Produkt-Management und Softwareentwicklung",
  "salary": {
    "from": "70000",
    "to": "90000",
    "origin": "estimation"
  },
  "from_url": "https://www.jobware.de/jobs/it"
}
```

Each scraped job listing returns a record with 17 fields:

#### Core Job Information

| Field | Meaning |
|---|---|
| `ID` | Unique identifier assigned by Jobware to the job posting |
| `Title` | Job title as displayed on the search result (e.g., "Senior Python Developer") |
| `URL` | Direct link to the full job detail page on Jobware.de |
| `Task` | Brief job summary or headline (often similar to or a snippet of the full description) |

#### Company & Posting Details

| Field | Meaning |
|---|---|
| `Advertiser` | Name of the company or recruiter posting the job |
| `Mandant` | Internal Jobware account/entity managing the listing |
| `Business Reference` | Reference code or internal company job ID for tracking |
| `Product Type` | Jobware's classification of the posting type (e.g., standard, featured, premium) |

#### Employment & Compensation

| Field | Meaning |
|---|---|
| `Job Types` | Employment type(s): Full-time, Part-time, Contract, Freelance, Internship, etc. |
| `Salary` | Stated salary or salary range in EUR (may be absent if not disclosed by employer) |
| `Location` | Primary work location (city/region in Germany or elsewhere) |
| `Location Infos` | Additional location context (e.g., remote work options, flexibility, relocation support) |

#### Categorization & Tracking

| Field | Meaning |
|---|---|
| `Labels` | Tags or categories assigned to the job (e.g., "Remote OK", "Startup", "Tech Stack: Python") |
| `Date` | Publication or last update date of the listing |
| `Apply` | Application method or CTA text (e.g., "Apply Now", external link) |
| `Resource URL` | URL pointing to the original posting if sourced from an external platform |
| `Resource URL With Tracking` | Tracked version of the resource URL for analytics purposes |

***

### How to Use

1. **Identify search URLs** — Navigate to Jobware.de and build search URLs matching your criteria:
   - Category-based: `https://www.jobware.de/jobs/[category]` (e.g., `/jobs/python`, `/jobs/devops`)
   - Location-based: `https://www.jobware.de/jobs/[location]` (e.g., `/jobs/berlin`, `/jobs/munich`)
   - Keyword search: `https://www.jobware.de/jobs?q=[keyword]` (if supported)

2. **Prepare configuration** — List URLs in the `urls` array. Keep `ignore_url_failures: true` to handle occasional page load issues.

3. **Set item limits** — Define `max_items_per_url` based on your needs. Higher values capture more listings but increase runtime and potential blocking risk.

4. **Execute the scraper** — Start the run and monitor the log for status updates.

5. **Download results** — Export data as JSON, CSV, or Excel for integration into your database, BI tool, or reporting system.

**Best practices:**

- Run searches during off-peak hours to minimize blocking risk
- Combine multiple narrowly-focused URLs rather than one broad search
- Use reasonable `max_items_per_url` limits (20–50 per URL is typical)
- Filter duplicates in post-processing, as some jobs may appear across multiple searches

***

### Use Cases & Business Value

- **Job aggregation:** Populate a multi-source job board with German tech listings
- **Market intelligence:** Track hiring trends, salary benchmarks, and skill demand in Germany
- **Talent sourcing:** Build pipelines of candidates from high-volume search results
- **Recruitment analytics:** Analyze competitor hiring volumes, benefits packages, and job descriptions
- **Automation:** Feed data into CRM or applicant tracking systems (ATS) for streamlined workflows

The Jobware Jobs Search Scraper turns raw search results into structured, actionable data that powers recruitment strategies, market analysis, and automated hiring workflows.

***

### Conclusion

The **Jobware.de Jobs Search Scraper** is an efficient tool for extracting German job market data at scale. With support for multiple search URLs, configurable item limits, and robust error handling, it streamlines the process of building job datasets. Whether you're building a job aggregator, conducting market research, or automating recruitment pipelines, this scraper delivers clean, structured records ready for immediate use.

# Actor input Schema

## `urls` (type: `array`):

Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.

## `ignore_url_failures` (type: `boolean`):

If true, the scraper will continue running even if some URLs fail to be scraped.

## `max_items_per_url` (type: `integer`):

The maximum number of items to scrape per URL.

## Actor input object example

```json
{
  "urls": [
    "https://www.jobware.de/jobs/it"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}
```

# 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 = {
    "urls": [
        "https://www.jobware.de/jobs/it"
    ],
    "ignore_url_failures": true,
    "max_items_per_url": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexist/jobware-jobs-search-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 = {
    "urls": ["https://www.jobware.de/jobs/it"],
    "ignore_url_failures": True,
    "max_items_per_url": 20,
}

# Run the Actor and wait for it to finish
run = client.actor("alexist/jobware-jobs-search-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 '{
  "urls": [
    "https://www.jobware.de/jobs/it"
  ],
  "ignore_url_failures": true,
  "max_items_per_url": 20
}' |
apify call alexist/jobware-jobs-search-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Jobware Jobs Search Scraper",
        "description": "Scrape German job listings from Jobware.de search pages in seconds. Collect job titles, salaries, locations, company info, and 17+ data fields per listing — perfect for job aggregators, market research, and recruitment analytics.",
        "version": "0.0",
        "x-build-id": "tQ53HXCVRt4qmR7Wr"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/alexist~jobware-jobs-search-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-alexist-jobware-jobs-search-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/alexist~jobware-jobs-search-scraper/runs": {
            "post": {
                "operationId": "runs-sync-alexist-jobware-jobs-search-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/alexist~jobware-jobs-search-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-alexist-jobware-jobs-search-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": {
                    "urls": {
                        "title": "URLs of the Jobs list urls to scrape",
                        "type": "array",
                        "description": "Add the URLs of the Jobs list urls you want to scrape. You can paste URLs one by one, or use the Bulk edit section to add a prepared list.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "ignore_url_failures": {
                        "title": "Continue running even if some URLs fail to be scraped",
                        "type": "boolean",
                        "description": "If true, the scraper will continue running even if some URLs fail to be scraped."
                    },
                    "max_items_per_url": {
                        "title": "Max items per URL",
                        "type": "integer",
                        "description": "The maximum number of items to scrape per URL."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
