# Arbeitnow Scraper (`automation-lab/arbeitnow-eu-dach-jobs-scraper`) Actor

Extract current Arbeitnow EU and DACH vacancies with company, location, remote status, tags, job types, descriptions, timestamps, and application URLs.

- **URL**: https://apify.com/automation-lab/arbeitnow-eu-dach-jobs-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Jobs
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.76 / 1,000 item extracteds

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/actors/running/actors-in-store.md#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

## Arbeitnow Scraper

Collect current vacancies from the public Arbeitnow job board API and turn them into normalized, integration-ready records.

The Actor scans Arbeitnow pages, applies optional keyword, location, remote, tag, and job-type filters, and saves each matching vacancy to the default Apify dataset. Every row includes stable identity, employer, location, remote status, taxonomy, description, job URL, source timestamp, and collection timestamp.

Use it for one-time EU and DACH job research, scheduled recruiting-feed refreshes, labor-market snapshots, and downstream vacancy alerts.

### What can the Arbeitnow Scraper do?

- Export current Arbeitnow vacancies to JSON, CSV, Excel, XML, or RSS through Apify datasets.
- Search title, company, location, tags, job types, and description with one case-insensitive keyword.
- Restrict results to a location substring such as `Berlin` or `Germany`.
- Return only jobs that Arbeitnow marks as remote.
- Require one or more source tags or job types.
- Scan multiple public API pages while respecting explicit item and page limits.
- Preserve the source's Unix timestamp and provide an ISO 8601 equivalent.
- Produce a normalized plain-text description, with original HTML available on request.
- Run on an Apify schedule so a dataset or webhook can feed recurring monitoring.

The Actor uses Arbeitnow's public JSON job-board API. It does not need a browser, account, cookie, or proxy.

### Who is this Actor for?

#### Recruiters and talent teams

Build a current pipeline of EU and DACH vacancies, compare employer activity, or identify remote openings without manually copying job pages.

#### Job aggregation teams

Receive stable slugs, timestamps, source URLs, and structured arrays that can be mapped into an existing vacancy model.

#### Labor-market researchers

Create repeatable snapshots for counts by company, location, remote status, tag, or job type. Store snapshots in separate datasets or forward each run to a warehouse.

#### Developers and automation teams

Call the Actor from JavaScript, Python, cURL, Apify integrations, or MCP. The default dataset works directly with webhooks, Make, Zapier, Google Sheets, and cloud storage exports.

### What Arbeitnow data is extracted?

| Field | Type | Meaning |
| --- | --- | --- |
| `slug` | string | Stable source slug for deduplication and change tracking |
| `title` | string | Vacancy title |
| `company` | string | Employer name supplied by Arbeitnow |
| `location` | string | Source location text |
| `remote` | boolean | Arbeitnow's remote flag |
| `tags` | string\[] | Source categories or skills |
| `jobTypes` | string\[] | Source job types, such as `Full Time` |
| `description` | string | Normalized plain-text vacancy description |
| `descriptionHtml` | string, optional | Original source HTML when requested |
| `applicationUrl` | URL | Canonical Arbeitnow vacancy/application page |
| `sourceUrl` | URL | Canonical source page |
| `sourceCreatedAt` | date-time | Source timestamp converted to ISO 8601 |
| `sourceCreatedAtUnix` | integer | Original Unix source timestamp |
| `scrapedAt` | date-time | Time this Actor collected the row |
| `source` | string | Always `arbeitnow.com` |

Field values reflect the source. A remote flag of `false` means Arbeitnow did not mark the listing remote; it is not an independent work-policy assessment.

### Getting started

1. Open the Actor in Apify Console.
2. Enter a keyword or leave it empty to collect the latest jobs.
3. Add location, remote, tags, or job-type filters if needed.
4. Choose `maxItems` and keep `maxPages` large enough for narrow filters.
5. Click **Start**.
6. Open the default dataset when the run finishes.
7. Export it or connect a webhook, integration, API client, or scheduled Task.

A useful first input is:

```json
{
  "query": "software",
  "maxItems": 10,
  "maxPages": 5
}
```

### Input parameters

| Parameter | Type | Default | Description |
| --- | --- | --- | --- |
| `query` | string | none | Text matched across title, company, location, tags, job types, and description |
| `location` | string | none | Substring matched against the source location |
| `remoteOnly` | boolean | `false` | Keep only source records marked remote |
| `tags` | string\[] | none | Require every supplied tag substring |
| `jobTypes` | string\[] | none | Require every supplied job-type substring |
| `includeDescriptionHtml` | boolean | `false` | Include original source description HTML |
| `maxItems` | integer | `20` | Maximum matching rows, from 1 to 10,000 |
| `maxPages` | integer | `20` | Maximum public API pages scanned, from 1 to 100 |

All text matching is case-insensitive. Multiple tags and job types use **AND** logic. For example, two required tags must both match the source tag list.

An invalid empty keyword, empty array value, fractional limit, or out-of-range limit fails the run clearly instead of changing the requested scope.

### Filter examples

#### Remote jobs

```json
{
  "remoteOnly": true,
  "maxItems": 25,
  "maxPages": 10
}
```

#### Berlin software vacancies

```json
{
  "query": "software",
  "location": "Berlin",
  "maxItems": 50,
  "maxPages": 20
}
```

#### Full-time roles with original HTML

```json
{
  "jobTypes": ["Full Time"],
  "includeDescriptionHtml": true,
  "maxItems": 100,
  "maxPages": 20
}
```

### Output example

A current row has this shape (values change as Arbeitnow refreshes its board):

```json
{
  "slug": "finanzbuchhalter-voll-oder-teilzeit-boblingen-hybrid-433749",
  "title": "Finanzbuchhalter (m/w/d) Voll- oder Teilzeit, Böblingen (hybrid)",
  "company": "Thorit",
  "location": "Böblingen Headquater",
  "remote": false,
  "tags": ["Finance Team"],
  "jobTypes": ["Full Time"],
  "description": "Worum es geht\nDie Stelle ist in Vollzeit und in Teilzeit ...",
  "applicationUrl": "https://www.arbeitnow.com/jobs/companies/thorit/finanzbuchhalter-voll-oder-teilzeit-boblingen-hybrid-433749",
  "sourceUrl": "https://www.arbeitnow.com/jobs/companies/thorit/finanzbuchhalter-voll-oder-teilzeit-boblingen-hybrid-433749",
  "sourceCreatedAt": "2026-08-26T16:20:24.000Z",
  "sourceCreatedAtUnix": 1787766024,
  "scrapedAt": "2026-08-26T20:00:00.000Z",
  "source": "arbeitnow.com"
}
```

The default dataset contains only accepted matching rows. Duplicates in one run are removed by source slug, and rejected or malformed rows are not charged as items.

### How much does it cost to extract Arbeitnow jobs?

The Actor uses pay-per-event pricing:

- **Start:** $0.001 once per run.
- **Job item:** tiered by your Apify plan; the BRONZE price is $0.0012667 per saved vacancy.

Example event counts are straightforward: a run saving 10 jobs creates one start event and 10 item events; 100 saved jobs creates one start event and 100 item events; 1,000 saved jobs creates one start event and 1,000 item events. Multiply those counts by the active prices shown above for your plan.

Your active Apify plan determines the exact item tier. Failed fetches, filtered-out records, and duplicate rows do not create item charges.

### Recurring EU and DACH vacancy feeds

Create an Apify Task from a tested input and schedule it hourly, daily, or weekly. Then choose one of these patterns:

1. Export each run's dataset to a dated object in cloud storage.
2. Send the dataset ID to a warehouse loader through a webhook.
3. Compare `slug` and `sourceCreatedAt` against a previous snapshot.
4. Notify a recruiting channel only when a new matching slug appears.
5. Aggregate counts by company, location, remote flag, tag, or job type.

This Actor emits current source data; it does not maintain historical state or send alerts by itself. Apify schedules, datasets, webhooks, and your destination system provide those workflow layers.

### Pagination, freshness, and limits

Arbeitnow states that its public job-board API is updated hourly and ordered by `created_at`. Source availability and timestamp semantics remain controlled by Arbeitnow.

`maxItems` limits saved matches, not scanned source rows. A narrow query may need more pages to find enough matches. Increase `maxPages` when appropriate, but avoid scanning unnecessary pages.

The Actor requests pages sequentially to avoid abusing the free public API. Transient network failures and server errors receive bounded retries; deterministic client errors fail immediately.

### API usage with cURL

Start a run and wait for its dataset items:

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~arbeitnow-eu-dach-jobs-scraper/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"remoteOnly":true,"maxItems":10,"maxPages":5}'
```

For production systems, keep tokens in secret storage rather than source code or shell history.

### API usage with JavaScript

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/arbeitnow-eu-dach-jobs-scraper').call({
  query: 'software',
  maxItems: 25,
  maxPages: 10,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### API usage with Python

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/arbeitnow-eu-dach-jobs-scraper').call(
    run_input={'location': 'Berlin', 'maxItems': 25, 'maxPages': 10}
)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Use with Apify MCP

Add Apify MCP to Claude Code:

```bash
claude mcp add --transport http apify \
  "https://mcp.apify.com?tools=automation-lab/arbeitnow-eu-dach-jobs-scraper"
```

**Claude Desktop, Cursor, and VS Code setup:** add this HTTP server configuration in the client's MCP settings:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/arbeitnow-eu-dach-jobs-scraper"
    }
  }
}
```

Example prompts:

- “Run the Arbeitnow scraper for 20 remote jobs and summarize companies and locations.”
- “Collect current software vacancies from Arbeitnow and return a CSV-ready table.”
- “Fetch 50 Arbeitnow jobs for this week's DACH hiring snapshot.”

### Integrations

#### Google Sheets

Schedule the Actor and use the Apify Google Sheets integration to append current rows. Use `slug` as a deduplication key in your sheet or automation.

#### Webhooks

Trigger a webhook when the run succeeds. The webhook payload provides the dataset ID so a downstream service can fetch only that run's rows.

#### Make and Zapier

Start an Actor run from a workflow, wait for completion, and iterate over dataset items. Route remote jobs, specific companies, or selected tags to separate destinations.

#### Data warehouses

Export JSON or CSV, or use the dataset API to load records into BigQuery, Snowflake, PostgreSQL, or another warehouse. Preserve both source and scrape timestamps to distinguish publication time from collection time.

### Legality and responsible use

Arbeitnow exposes the route as a free public jobs API and asks users not to abuse it. Use reasonable item/page limits and schedules, link back to source job pages, and review Arbeitnow's current terms before production use.

Job listings may contain personal or employer information. Process and retain data only where you have a lawful purpose, respect applicable privacy and employment rules, and avoid republishing misleading, expired, or altered listings.

The Actor does not bypass access controls, log in, or collect private account data.

### Limitations

- Results are limited to records currently returned by the Arbeitnow public API.
- The Actor cannot independently verify whether a vacancy remains open.
- `applicationUrl` is the canonical Arbeitnow job page; the source API does not expose a separate employer ATS apply URL.
- Filters are text matches against source-provided values, not semantic classification.
- Location strings are not geocoded or normalized into country/region fields.
- Visa sponsorship is not a dedicated source field, so this Actor does not claim a verified sponsorship filter.
- Source descriptions may contain formatting artifacts after HTML-to-text conversion.
- A low `maxPages` value can stop before enough narrow-filter matches are found.
- The Actor does not store prior runs, compare changes, or send alerts on its own.

### Troubleshooting

#### My run returned fewer jobs than `maxItems`

`maxItems` is a ceiling, not a guaranteed count. Filters may have fewer current matches, or `maxPages` may stop scanning first. Check the input and increase `maxPages` for narrow searches.

#### My run returned zero jobs

Remove filters one at a time and test a broad input such as `{"maxItems": 10, "maxPages": 5}`. Source taxonomies and location text can change, so inspect a broad dataset before choosing exact tags or job types.

#### The run failed with an Arbeitnow API error

Check the run log and Arbeitnow's public API availability. Transient errors already receive bounded retries. Retry later rather than launching many simultaneous runs.

#### Why is `descriptionHtml` missing?

It is opt-in to keep normal datasets smaller. Set `includeDescriptionHtml` to `true` when your downstream renderer needs the original formatting.

### FAQ

#### Does the Actor require an Arbeitnow API key?

No. It uses Arbeitnow's public job-board API without login.

#### Does it require a proxy?

No. The current route is a direct public JSON API, so proxy configuration would add cost without adding value.

#### Can it collect all current jobs?

Use no filters, a sufficiently high `maxItems`, and enough `maxPages`. The exact total and page availability are controlled by the source and can change.

#### Can it find Arbeitnow Germany jobs?

Yes, when Germany or a German place appears in source title, location, tags, or description. Use `location` for source location text or `query` for broader matching. The Actor does not infer country from every place name.

#### Can it filter visa sponsorship jobs?

There is no verified sponsorship field in the public API. A keyword can find listings that mention sponsorship, but that text match should not be treated as a guarantee.

#### Can I monitor new or changed jobs?

Schedule repeated runs and compare `slug`, `sourceCreatedAt`, and relevant fields in your own storage or automation. The Actor supplies snapshot data; it does not retain a cross-run change ledger.

#### Can I use the output commercially?

Review Arbeitnow's current terms and applicable law for your use case. This Actor is a collection tool, not legal advice or a license to republish source content.

### Related Automation Lab Actors

- [Remote Jobs Multi-Board Feed](https://apify.com/automation-lab/remote-jobs-multi-board-feed) combines supported remote-job boards into a normalized source-attributed feed.
- [Company Career Page Jobs Scraper](https://apify.com/automation-lab/company-career-page-jobs-scraper) extracts supplied public employer career pages.
- [StepStone Group Jobs Feed](https://apify.com/automation-lab/stepstone-group-jobs-feed) targets supported StepStone Group portals for broader regional hiring research.

Choose this Actor when Arbeitnow itself is the required source and you need its full current API records, source timestamps, descriptions, and filters.

### Support

For reproducible help, include the run URL, input with secrets removed, expected result, and one example source job. Do not post API tokens or private candidate data.

# Actor input Schema

## `query` (type: `string`):

Case-insensitive text matched against title, company, location, tags, job types, and description.

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

Case-insensitive substring matched against Arbeitnow's location field, for example Berlin or Germany.

## `remoteOnly` (type: `boolean`):

Return only listings marked remote by Arbeitnow.

## `tags` (type: `array`):

Return jobs matching every supplied tag substring.

## `jobTypes` (type: `array`):

Return jobs matching every supplied type, such as Full Time.

## `includeDescriptionHtml` (type: `boolean`):

Add descriptionHtml alongside the normalized plain-text description.

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

Maximum number of matching vacancies saved to the dataset.

## `maxPages` (type: `integer`):

Safety bound for Arbeitnow API pagination. Increase it for narrow filters that require deeper scanning.

## Actor input object example

```json
{
  "query": "software",
  "remoteOnly": false,
  "includeDescriptionHtml": false,
  "maxItems": 20,
  "maxPages": 20
}
```

# Actor output Schema

## `overview` (type: `string`):

Normalized vacancy rows in the overview dataset view.

# 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 = {
    "query": "software"
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/arbeitnow-eu-dach-jobs-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "query": "software" }

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/arbeitnow-eu-dach-jobs-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 '{
  "query": "software"
}' |
apify call automation-lab/arbeitnow-eu-dach-jobs-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,automation-lab/arbeitnow-eu-dach-jobs-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/F9yfp7hc1Xidj1qSP/builds/5QWWcy1Uiav6vf8S2/openapi.json