# Jobware Scraper — German Job Listings with Salary Data (`studio-amba/jobware-scraper`) Actor

Scrape job listings from Jobware.de, the German professional job board. Get titles, companies, locations, salary ranges, posting dates, and full descriptions. Fast JSON-API access, no login.

- **URL**: https://apify.com/studio-amba/jobware-scraper.md
- **Developed by:** [Studio Amba](https://apify.com/studio-amba) (community)
- **Categories:** Jobs
- **Stats:** 1 total users, 1 monthly users, 55.6% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 result scrapeds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Jobware Scraper

Extract **job listings from [Jobware.de](https://www.jobware.de/)**, one of Germany's longest-running professional job boards ("da hab' ich den Job her"). Jobware focuses on qualified professionals and specialists — engineering, IT, healthcare, finance, and public sector roles across all of Germany.

This Actor pulls **job titles, companies, locations, salary ranges, employment types, posting dates, and (optionally) full job descriptions** directly from Jobware's JSON API. No login, no cookies, no browser automation. It reads structured data straight from the source instead of parsing HTML, so runs are fast and stable.

A distinctive extra: **salary data with an origin flag**. Jobware shows a salary range for most postings and the API tells you whether that range was stated in the ad itself (`extraction`) or is Jobware's own estimate (`estimation`). The Actor passes this flag through, so you always know how much to trust the number.

### What does Jobware Scraper do?

Give it a German keyword (for example `Ingenieur`, `Softwareentwickler`, or `Krankenpfleger`) and, optionally, a city. The Actor queries Jobware's search API, paginates through the results, and returns clean, structured records you can download as JSON, CSV, Excel, or HTML — or pull through the Apify API into your own systems.

Turn on **Fetch Full Details** and it visits each job's detail endpoint too, adding the full plain-text description and the posting's expiry date.

Because it runs on the Apify platform, you also get scheduling, monitoring, proxy rotation, and integrations (webhooks, Make, Zapier, Google Sheets) out of the box.

### Why use Jobware Scraper?

- **Salary transparency.** Most listings carry a salary range, each flagged as ad-stated or estimated.
- **Professional-grade postings.** Jobware skews toward qualified roles from direct employers, not aggregated noise.
- **Labour-market research.** Track hiring demand and salary levels by role, region, or employer over time.
- **Recruitment and sourcing.** Build lead lists of companies actively hiring for a role.
- **Job aggregators.** Feed a niche job site or newsletter with fresh, structured listings including expiry dates.
- **No anti-bot headaches.** The API is open, so runs are quick and reliable.

### How to scrape Jobware data

1. Open the Actor and go to the **Input** tab.
2. Enter a **Search Query** in German (e.g., `Ingenieur`, `Elektroniker`, `Pflegekraft`).
3. Optionally set a **Location** (e.g., `Berlin`, `München`) to narrow the search.
4. Optionally enable **Fetch Full Details** to get the full job description and expiry date for every listing.
5. Set **Max Results** to control how many listings you want.
6. Click **Start**. When the run finishes, open the **Output** tab and download your data as JSON, CSV, Excel, or HTML.

That's it. You can also schedule the Actor to run daily and feed new listings into your own pipeline.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | string | German keyword to search for. Defaults to `Ingenieur`. |
| `location` | string | City or region (e.g., `Berlin`). Leave empty to search all of Germany. |
| `fetchDetails` | boolean | Fetch each job's detail page for the full description and expiry date. Default `false`. |
| `maxResults` | integer | Maximum number of listings to return (default 100, max 5,000 per query). |
| `proxyConfiguration` | object | Proxy settings. Apify datacenter proxies work well. |

#### Example input

```json
{
  "searchQuery": "Softwareentwickler",
  "location": "Berlin",
  "fetchDetails": true,
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

### Output

Each job is returned as one dataset record. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output item

```json
{
  "id": "2003879205",
  "title": "Software-Ingenieurin oder Software-Ingenieur (m/w/d)",
  "company": "Technische Hochschule Rosenheim",
  "companyLogo": "https://www.jobware.de/jobresources/logo/859/61859/447/001232447/68/logo_160x80.gif",
  "location": "Rosenheim",
  "postalCode": "83024",
  "country": "DE",
  "salaryFrom": 45000,
  "salaryTo": 65000,
  "salaryOrigin": "estimation",
  "jobTypes": ["Homeoffice Option", "Vollzeit", "Teilzeit", "Home Office"],
  "snippet": "Mitarbeit bei der Analyse und Optimierung von Geschäftsprozessen\nNeu- und Weiterentwicklung von Webanwendungen und Workflows\nMitarbeit bei der Benutzerbetreuung und Second-Level-Support",
  "publicationDate": "2026-07-04T05:00:00.000Z",
  "url": "https://www.jobware.de/job/software-ingenieurin-oder-software-ingenieur-m-w-d.2003879205.html",
  "applyUrl": "https://www.jobware.de/apply/...",
  "description": "Die Technische Hochschule Rosenheim sucht ... (full plain-text ad, only with Fetch Full Details)",
  "expiryDate": "2026-07-22T21:59:59.000Z",
  "scrapedAt": "2026-07-11T09:00:00.000Z"
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `id` | Jobware internal job ID |
| `title` | Job posting title |
| `company` | Hiring company or organisation |
| `companyLogo` | URL of the company logo |
| `location` | City or town of the workplace |
| `postalCode` | Postal code (PLZ) |
| `country` | ISO country code of the workplace |
| `salaryFrom` / `salaryTo` | Annual salary range in EUR |
| `salaryOrigin` | `extraction` = stated in the ad, `estimation` = Jobware's estimate |
| `jobTypes` | Employment tags (Vollzeit, Teilzeit, Homeoffice, ...) |
| `snippet` | Short description snippet from the search results |
| `publicationDate` | ISO 8601 date the job was published |
| `url` | Jobware job page URL |
| `applyUrl` | Application link |
| `description` | Full plain-text job description (with Fetch Full Details, capped at 3,000 characters) |
| `expiryDate` | ISO 8601 date the posting expires (with Fetch Full Details) |
| `scrapedAt` | ISO 8601 collection timestamp |

### How much does it cost to scrape Jobware?

The Actor reads a lightweight JSON API, so runs are cheap and fast. A typical run of a few hundred listings finishes in under a minute without details, or a few minutes with **Fetch Full Details** on. Pricing follows this Actor's pay-per-result configuration on the Apify Store — check the pricing box on the Actor page for the current rate. Larger runs scale linearly with the number of results.

### Tips and advanced options

- **German keywords.** The board is German. Use German job titles (`Ingenieur`, not `engineer`) for the best coverage.
- **Salary filtering.** Filter on `salaryOrigin: "extraction"` downstream if you only want salaries that employers actually stated.
- **The 5,000-result window.** Jobware serves at most 5,000 results per query. For broader coverage, run the Actor several times with different keywords or locations.
- **Details cost time.** `fetchDetails` adds one request per job. For a few hundred jobs that is fine; for thousands, expect a longer run. The Actor saves its progress, so long runs survive platform restarts without duplicating rows.
- **Deduplication.** Results are de-duplicated by job ID within a run.

### FAQ, disclaimers, and support

**Is scraping Jobware legal?** This Actor reads the same JSON API that Jobware's own website uses to display public job listings. Use the data responsibly and in line with applicable terms and data-protection law. You are responsible for how you use the extracted data.

**Do I need an account or API key?** No. The Actor handles API access for you. No login or cookies are required.

**Why is a salary marked as "estimation"?** Jobware estimates a salary range for postings that don't state one. The `salaryOrigin` field lets you tell estimates apart from ranges taken from the ad text (`extraction`).

**Why did my run fail with an API-hash message?** Jobware occasionally rotates its internal API endpoint names when it redeploys its site. The Actor detects this and fails with a clear message instead of returning zero items — report it via the **Issues** tab and it will be fixed quickly.

**Something's not working.** Open an issue on the Actor's **Issues** tab with your input and the run link. Custom fields or a tailored version can also be arranged.

### Related scrapers

- [Arbeitsagentur Scraper](https://apify.com/studio-amba/arbeitsagentur-scraper) — Germany's Federal Employment Agency job board
- [StepStone Scraper](https://apify.com/studio-amba/stepstone-scraper) — Germany's leading commercial job board
- [Jobindex Scraper](https://apify.com/studio-amba/jobindex-scraper) — Denmark's largest job board
- [Kariyer.net Scraper](https://apify.com/studio-amba/kariyer-net-scraper) — Turkey's leading job board

# Actor input Schema

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

Keyword to search for (German). Examples: 'Ingenieur' (engineer), 'Softwareentwickler' (software developer), 'Krankenpfleger' (nurse), 'Vertrieb' (sales).

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

Filter by city or region (e.g., 'Berlin', 'München', 'Hamburg'). Leave empty to search all of Germany.

## `fetchDetails` (type: `boolean`):

Fetch the detail page of every job to add the full plain-text description and the posting expiry date. Adds one extra request per job, so runs take longer.

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

Maximum number of job listings to return. Jobware serves at most 5,000 results per query — narrow with keyword and location for full coverage.

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

Proxy settings. The Jobware API is open and works well through Apify datacenter proxies.

## Actor input object example

```json
{
  "searchQuery": "Ingenieur",
  "fetchDetails": false,
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# Actor output Schema

## `results` (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": "Ingenieur",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/jobware-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": "Ingenieur",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/jobware-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

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