# Germany Jobs Scraper & Market Monitor (`xtech/germany-job-market-monitor-pro`) Actor

Scrape 𝗚𝗲𝗿𝗺𝗮𝗻𝘆 𝗷𝗼𝗯𝘀 by role, skill, location, radius, and publication date. Collect titles, employers, occupations, locations, dates, coordinates, and available application links. Build recurring snapshots to track 𝗵𝗶𝗿𝗶𝗻𝗴 𝗱𝗲𝗺𝗮𝗻𝗱 from Federal Employment Agency vacancies.

- **URL**: https://apify.com/xtech/germany-job-market-monitor-pro.md
- **Developed by:** [Xtech](https://apify.com/xtech) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.00 / 1,000 job-market observations

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.

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

Germany Jobs Scraper & Market Monitor collects active German job listings by role, skill, location, radius, opportunity type, and publication date. Use repeatable runs to compare employers, occupations, regions, and hiring demand over time.

**Unofficial tool. Not affiliated with, endorsed by, or sponsored by Germany's Federal Employment Agency.**

### Scrape Germany job listings

Search Federal Employment Agency vacancies with a German job title, skill, or keyword. Add a city, postcode, state, or country and an optional radius when you need a regional view. You can focus the search on employment, apprenticeships and dual study, internships and traineeships, or self-employment.

Each result is a listing summary. It can include the job title, occupation, employer, address, region, coordinates, publication date, source update time, proposed start date, reference number, and an application link when the source provides one.

### Germany jobs scraper input

- **Role or skill:** Required search term such as `Softwareentwickler`, `Pflegefachkraft`, or `SAP`.
- **Location and radius:** Optional geographic focus with a radius from 1 to 200 km.
- **Publication date:** Limit results to vacancies published within the last 0 to 100 days.
- **Opportunity type:** Choose employment, apprenticeship, internship, or self-employment.
- **Agency filters:** Include or exclude private agencies and temporary-work listings.
- **Result limit:** Save from 1 to 10,000 unique listings per run.

```json
{
  "searchTerm": "Softwareentwickler",
  "location": "Berlin",
  "radiusKm": 25,
  "publishedWithinDays": 7,
  "monitorName": "Berlin software jobs weekly",
  "maxJobs": 250
}
````

### Track German hiring demand over time

Give each recurring search a stable monitor name and run it daily, weekly, or monthly. Every row includes the monitor name, monitor ID, observation time, and source reference number. Compare `refnr` and the source update timestamp across exports to identify listings that are new, retained, or revised.

Common uses include regional workforce analysis, competitor hiring research, staffing demand discovery, apprenticeship monitoring, and recurring German job-market dashboards.

### Pricing

Pricing is based on job-listing results. Review the current rate and set a maximum run cost in the Apify pricing panel before running a large search. Start with 50–100 results to confirm relevance, then increase the limit.

### Germany jobs scraper FAQ

**Does this include full descriptions or salaries?** No. The Actor returns structured vacancy summaries and available application links, not full job descriptions, salaries, contacts, or contract details.

**Can it return only new jobs?** Use the publication-age filter for a fresh search. For exact changes, compare repeated snapshots using the reference and update fields.

**Is this the entire German labour market?** No. Results reflect active vacancies available from the source at run time. Some optional fields may be blank.

# Actor input Schema

## `searchTerm` (type: `string`):

Use a job title, skill, or keyword, for example Softwareentwickler, Pflegefachkraft, or SAP.

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

Optional city, postal code, German state, or country to focus the monitor, for example Berlin or 80331.

## `radiusKm` (type: `integer`):

Optional radius around the location. Leave empty to use the source's location search without an explicit radius.

## `publishedWithinDays` (type: `integer`):

Optional freshness filter for scheduled runs. Enter 1 for a daily new-listing monitor, 7 for a weekly monitor, or leave empty for all active matches.

## `offerType` (type: `string`):

Choose the kind of opportunity to include.

## `includePrivateAgencies` (type: `boolean`):

Include listings marked as private employment-agency offers.

## `includeTemporaryWork` (type: `boolean`):

Keep temporary-work listings in the market view. Turn this off for direct-hire demand only.

## `monitorName` (type: `string`):

Optional label repeated in every result, useful when several scheduled monitors feed the same analysis workflow.

## `maxJobs` (type: `integer`):

Maximum number of unique listings to save. Start with a smaller limit to check relevance, then increase it for broader market analysis.

## Actor input object example

```json
{
  "searchTerm": "Softwareentwickler",
  "offerType": "employment",
  "includePrivateAgencies": false,
  "includeTemporaryWork": true,
  "maxJobs": 100
}
```

# Actor output Schema

## `jobListings` (type: `string`):

One dataset item per unique vacancy observed in this run. Compare refnr and source modification timestamps across runs to identify changes.

## `runSummary` (type: `string`):

The monitor settings, source result count, collection total, and data-quality counters for this run.

# 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 = {
    "searchTerm": "Softwareentwickler"
};

// Run the Actor and wait for it to finish
const run = await client.actor("xtech/germany-job-market-monitor-pro").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 = { "searchTerm": "Softwareentwickler" }

# Run the Actor and wait for it to finish
run = client.actor("xtech/germany-job-market-monitor-pro").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 '{
  "searchTerm": "Softwareentwickler"
}' |
apify call xtech/germany-job-market-monitor-pro --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=xtech/germany-job-market-monitor-pro",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Germany Jobs Scraper & Market Monitor",
        "description": "Scrape 𝗚𝗲𝗿𝗺𝗮𝗻𝘆 𝗷𝗼𝗯𝘀 by role, skill, location, radius, and publication date. Collect titles, employers, occupations, locations, dates, coordinates, and available application links. Build recurring snapshots to track 𝗵𝗶𝗿𝗶𝗻𝗴 𝗱𝗲𝗺𝗮𝗻𝗱 from Federal Employment Agency vacancies.",
        "version": "1.1",
        "x-build-id": "lbPyUykJmYaTMXmpF"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/xtech~germany-job-market-monitor-pro/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-xtech-germany-job-market-monitor-pro",
                "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/xtech~germany-job-market-monitor-pro/runs": {
            "post": {
                "operationId": "runs-sync-xtech-germany-job-market-monitor-pro",
                "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/xtech~germany-job-market-monitor-pro/run-sync": {
            "post": {
                "operationId": "run-sync-xtech-germany-job-market-monitor-pro",
                "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",
                "required": [
                    "searchTerm"
                ],
                "properties": {
                    "searchTerm": {
                        "title": "Role or skill to monitor",
                        "minLength": 1,
                        "maxLength": 200,
                        "type": "string",
                        "description": "Use a job title, skill, or keyword, for example Softwareentwickler, Pflegefachkraft, or SAP."
                    },
                    "location": {
                        "title": "Location",
                        "maxLength": 200,
                        "type": "string",
                        "description": "Optional city, postal code, German state, or country to focus the monitor, for example Berlin or 80331."
                    },
                    "radiusKm": {
                        "title": "Search radius",
                        "minimum": 1,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Optional radius around the location. Leave empty to use the source's location search without an explicit radius."
                    },
                    "publishedWithinDays": {
                        "title": "Only listings published in the last",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Optional freshness filter for scheduled runs. Enter 1 for a daily new-listing monitor, 7 for a weekly monitor, or leave empty for all active matches."
                    },
                    "offerType": {
                        "title": "Opportunity type",
                        "enum": [
                            "employment",
                            "apprenticeship",
                            "internshipOrTraineeship",
                            "selfEmployment"
                        ],
                        "type": "string",
                        "description": "Choose the kind of opportunity to include.",
                        "default": "employment"
                    },
                    "includePrivateAgencies": {
                        "title": "Include private employment agencies",
                        "type": "boolean",
                        "description": "Include listings marked as private employment-agency offers.",
                        "default": false
                    },
                    "includeTemporaryWork": {
                        "title": "Include temporary-work listings",
                        "type": "boolean",
                        "description": "Keep temporary-work listings in the market view. Turn this off for direct-hire demand only.",
                        "default": true
                    },
                    "monitorName": {
                        "title": "Monitor name",
                        "maxLength": 100,
                        "type": "string",
                        "description": "Optional label repeated in every result, useful when several scheduled monitors feed the same analysis workflow."
                    },
                    "maxJobs": {
                        "title": "Maximum listings per run",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of unique listings to save. Start with a smaller limit to check relevance, then increase it for broader market analysis.",
                        "default": 100
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```