# Arbeitnow Jobs Scraper · Visa & remote filters · $1.6/1K (`mlg14/arbeitnow-scraper`) Actor

Collect Arbeitnow job listings for job market research, recruiting and relocation searches in Germany and Europe. Filter by keyword, location, remote and visa sponsorship. Returns descriptions, job types, tags and dates. $1.6/1K jobs.

- **URL**: https://apify.com/mlg14/arbeitnow-scraper.md
- **Developed by:** [MLG Data](https://apify.com/mlg14) (community)
- **Categories:** Jobs, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$1.60 / 1,000 results

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

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

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Arbeitnow Scraper

Scrape Arbeitnow jobs and export Arbeitnow data to CSV, JSON, or Excel as a clean dataset of current public listings. This Arbeitnow API alternative reads the site's paginated job feed and returns stable job identifiers, searchable fields, readable descriptions, and direct listing URLs.

### What data can you extract from Arbeitnow?

Each dataset row describes one job listing. The output uses consistent camelCase names and flat values so it can be joined to other job feeds, stored in a warehouse, or loaded into a spreadsheet without unpacking nested objects. The fields below come from the public job feed or are derived from it. A field can be empty when the underlying posting omits that information; the actor does not invent a location, employment type, or description to fill a gap.

| Field | Description | Example |
|---|---|---|
| `jobId` | Stable job slug for identifying the listing and comparing later runs. | `software-engineer-munich-281854` |
| `title` | Job title as published. | `Software Engineer – Cloud Services` |
| `company` | Hiring organization name supplied with the job. | `[redacted]` |
| `location` | City or location text supplied with the listing. | `Munich` |
| `remote` | Boolean flag Arbeitnow provides for remote eligibility. | `false` |
| `visaSponsorship` | Boolean estimate based on sponsorship language in the description. | `false` |
| `jobTypes` | Array of employment-type labels. It may be empty if none are published. | `["Full-time"]` |
| `tags` | Array of categories or skills associated with the listing. | `["Engineering"]` |
| `description` | Description converted from markup to readable text, retaining paragraph and list breaks. | `Build and maintain cloud services.` |
| `postedAt` | Source posting timestamp converted to UTC ISO 8601. | `2026-10-25T16:08:03.000Z` |
| `applyUrl` | Application URL when present; otherwise the job page URL. | `https://www.arbeitnow.com/jobs/...` |
| `url` | Canonical public job page URL. | `https://www.arbeitnow.com/jobs/...` |
| `scrapedAt` | UTC time when this run collected the records. | `2026-10-25T16:10:00.000Z` |

The source feed is useful because it already exposes the job attributes as structured records. The actor does not need to infer `remote`, `jobTypes`, or `tags` from page layout. It preserves the source job slug as `jobId`, converts the creation timestamp to a standard date string, and converts encoded HTML descriptions into text. `applyUrl` and `url` may be the same when the feed does not provide a separate application destination.

`visaSponsorship` is different from the other fields. The public feed does not include a dedicated sponsorship flag, so this actor checks the description for common affirmative visa-sponsorship terms and excludes clear negative statements. That check is a text-based estimate, not an official employer commitment. A posting can discuss work authorization without promising sponsorship, and a posting may provide sponsorship information in wording the check does not recognize. Treat this field as a discovery aid and open the listing before making a decision.

### How to scrape Arbeitnow

1. Start with the default input to collect the most recent public job records. No account credentials, login cookies, or hand-entered job URL are needed.
2. Set `maxJobs` to choose how many matching rows to return. Set `maxPages` to control how many pages of the feed the actor can inspect when you apply selective filters.
3. Add a title keyword or location substring if you need a narrower result set. Turn on `remote` to keep remote-eligible roles, or `visaSponsorship` to keep descriptions that indicate sponsorship.
4. Run the actor and review the dataset. Export the rows in JSON, CSV, or Excel format, or retrieve them through the dataset API.

The public endpoint currently returns approximately 300 jobs per page and provides a next-page link. The actor follows that pagination up to your `maxPages` value, deduplicates records by `jobId`, and stops when it reaches `maxJobs` or the feed has no next page. The actual number of results depends on how many source records match your filters and how many pages are available when the run starts.

### Input

All parameters are optional. An empty input uses the same practical defaults as the prefilled configuration. The feed has no login requirement. The proxy setting is available for request routing, but the public endpoint responded without a challenge during verification.

| Name | Type | Default | Description |
|---|---|---|---|
| `keywords` | string | `""` | Case-insensitive substring matched against job titles. Empty includes all titles. |
| `visaSponsorship` | boolean | `false` | Keep only jobs whose description text indicates visa sponsorship. This flag is inferred from text. |
| `remote` | boolean | `false` | Keep only jobs Arbeitnow marks as remote. |
| `location` | string | `""` | Case-insensitive substring matched against the published location. |
| `maxJobs` | integer | `50` | Maximum number of matching rows returned; accepted range is 1 to 500. |
| `maxPages` | integer | `2` | Maximum public feed pages to inspect; accepted range is 1 to 20. |
| `proxyConfiguration` | object | Proxy enabled | Optional proxy configuration for source requests. |

Example: collect up to 100 remote backend roles in Germany, checking up to five feed pages:

```json
{
  "keywords": "backend",
  "location": "Germany",
  "remote": true,
  "visaSponsorship": false,
  "maxJobs": 100,
  "maxPages": 5
}
```

Set `keywords` and `location` to empty strings when you want all titles and locations. The keyword is checked against the title only; it does not search the description, tags, or company name. The location value is a substring, so a broad term can match multiple cities or countries as they appear in the source text. Matching ignores capitalization but otherwise uses literal text, which makes short and distinctive values easier to interpret than ambiguous fragments.

Filters are evaluated as each API page arrives. The public feed documents pagination through a `page` parameter, and verification showed that adding keyword, location, remote, or sponsorship parameters does not narrow the response. Consequently, a selective run may inspect many source records to return a small number of matches. Increase `maxPages` when a filter is selective; increase `maxJobs` only when you need more output rows. A run that finds no matching jobs fails with a message asking you to broaden the filters or inspect more pages.

### Output example

The example below follows the output shape from a live golden run. The hiring organization is masked, and the description is shortened to keep the example readable.

```json
{
  "jobId": "software-engineer-cloud-services-rust-munich-281854",
  "title": "Software Engineer – Cloud Services – Rust",
  "company": "[redacted]",
  "location": "Munich",
  "remote": false,
  "visaSponsorship": false,
  "jobTypes": [],
  "tags": ["Engineering"],
  "description": "Design and develop distributed cloud services in Rust. Maintain software and build APIs for generative systems. [Description shortened.]",
  "postedAt": "2026-10-25T12:55:19.000Z",
  "applyUrl": "https://www.arbeitnow.com/jobs/companies/[redacted]/software-engineer-cloud-services-rust-munich-281854",
  "url": "https://www.arbeitnow.com/jobs/companies/[redacted]/software-engineer-cloud-services-rust-munich-281854",
  "scrapedAt": "2026-10-25T16:31:50.779Z"
}
```

The values in a live run will change as listings are added, edited, or removed. Descriptions are intentionally shortened in this documentation sample, while dataset records contain the readable description supplied by the feed. Timestamps use UTC so listings collected in different regions can be sorted consistently. Empty arrays for `jobTypes` or `tags` mean the source did not provide values for that listing; they do not mean the actor failed to parse the record.

### Use cases

- **Recruiting research:** Build a recurring shortlist by title, location, and remote eligibility, then compare new `jobId` values with a prior dataset to spot fresh listings.
- **Job-board aggregation:** Combine public roles from this source with other sources while preserving a canonical URL for attribution and follow-up.
- **Relocation research:** Find listings in a chosen city or country and use the sponsorship estimate to identify descriptions worth reviewing manually.
- **Skills and category tracking:** Count source tags and job types over time to see which functions and employment arrangements appear in current listings.
- **Newsletter preparation:** Collect a bounded set of recent jobs, review the source URLs, and select suitable listings for a human-edited digest.
- **Market monitoring:** Schedule periodic runs and compare titles, locations, and posting dates to observe changes in the publicly listed role mix.

The data is a snapshot of what the source API returned during a run. It is not an employment database with guaranteed status updates. A role may close after collection, and an unchanged URL does not guarantee the employer is still accepting applications. For recruiting decisions, confirm the listing at its source before contacting an employer or advising a candidate.

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

The configured pay-per-result rate is $1.60 per 1,000 jobs. You are charged for rows delivered to the dataset, rather than for every source record examined. This matters when filters are selective: inspecting extra feed pages does not add output rows by itself. These estimates use the configured rate and exclude any account-specific discounts or taxes.

- **50 jobs:** 50 × $1.60 ÷ 1,000 = **$0.08**.
- **500 jobs:** 500 × $1.60 ÷ 1,000 = **$0.80**. This uses the full per-run output limit.
- **5,000 jobs:** 5,000 × $1.60 ÷ 1,000 = **$8.00**, collected over at least ten runs because each run is capped at 500 jobs.

The cost estimate counts returned jobs. A narrow filter can produce fewer rows than `maxJobs`, and no result is billed as a delivered job. If you need a recurring feed, choose a batch size that fits your review process and compare `jobId` values between runs so downstream systems do not treat unchanged listings as new records.

### Tips for best results

- Begin with 50 jobs and two pages to inspect the output shape before increasing collection size.
- Use a specific title phrase for keyword filtering. Since the filter checks titles only, a technology or benefit that appears solely in the description will not match.
- Use a distinctive city or country substring. Location values follow the source spelling and may be blank or abbreviated for some listings.
- Turn on `remote` only when you want the source's remote flag. The actor does not infer remote status from words in the description.
- Treat the sponsorship estimate as a review queue. Read the source description before relying on it for eligibility or relocation decisions.
- Increase `maxPages` for selective filters. The actor stops after the requested number of pages even if few matching rows have appeared.
- Set `maxJobs` to the volume your downstream process can review. The schema allows at most 500 results per run.
- Store `jobId` and `url` with each result. They help you compare snapshots and open the original listing later.
- Use `postedAt` for source ordering and `scrapedAt` to record when your own snapshot was collected. The two timestamps answer different questions.
- Keep the full description in the dataset for search or later review. It is normalized into text, so HTML formatting and embedded page layout are not preserved.

### Limits

The dataset reflects only public jobs returned by Arbeitnow's own API. The feed is paginated and can change while pages are being inspected. Its pagination may expose overlapping records across pages; the actor deduplicates by job slug, but a newly posted role can shift which records are visible during a multi-page run. A configured `maxPages` is therefore a collection bound, not a promise that every currently open role will be returned.

The feed does not apply the actor's keyword, location, remote, or sponsorship filters. The actor checks those conditions on returned page records, so narrow criteria can require additional pages and can still find no matches. The source currently returns about 300 records per page; that quantity and the fields on each record are controlled by the site and can change. The actor stops at 20 pages or 500 matching output rows even when more source data exists.

Some postings omit location, job types, tags, or a separate apply URL. When no application destination is present, `applyUrl` uses the canonical listing URL. The description may be long and may contain source-specific spacing or wording; markup is converted to plain text but the content is not translated, summarized, or corrected. A missing posting timestamp is returned as `null`.

`visaSponsorship` is inferred from text because there is no dedicated field in the API records. It may miss indirect wording or overinterpret a description that mentions sponsorship in a different context. `remote` is the source's own boolean and may not distinguish fully remote work from hybrid arrangements unless the listing does so. The actor does not verify whether a job is still open and does not submit applications.

The source API is public and asks users to respect its terms and avoid excessive requests. Keep `maxPages` and run frequency proportionate to your use case, and use collected data only in ways that comply with applicable terms, privacy rules, and local law. This actor does not circumvent a login wall; the public feed responded without one during verification.

### Use with AI agents (MCP)

Add this actor to any MCP client (Claude, Cursor, VS Code, n8n and others) with one URL:

`https://mcp.apify.com?tools=mlg14/arbeitnow-scraper`

The actor returns one dataset item per Arbeitnow job (title, company, location, job type, tags, description, posting date, URL). Set `maxJobs` to keep results bounded.

**Prompt 1:** "Find up to 20 remote jobs on Arbeitnow."

```json
{
  "remote": true,
  "maxJobs": 20
}
```

**Prompt 2:** "Find Arbeitnow jobs in Berlin with a title containing data engineer."

```json
{
  "keywords": "data engineer",
  "location": "Berlin",
  "maxJobs": 30,
  "maxPages": 4
}
```

**Prompt 3:** "Find 20 Arbeitnow jobs that mention visa sponsorship."

```json
{
  "visaSponsorship": true,
  "maxJobs": 20
}
```

### FAQ

**Is it legal to collect public job listings?** The actor reads public job data, but the rules for collection and reuse depend on applicable law and the source's terms. Review those terms, collect only what you need, and do not use the data to misuse personal information.

**Do I need to configure a proxy?** No special proxy setting is required for the public API in the observed responses. The input includes proxy configuration for request routing if your environment needs it. No login or cookie is required.

**How quickly does a run finish?** The actor requests structured JSON rather than rendering job pages, so it avoids browser startup. Runtime depends on the number of pages, source response times, and how selective your filters are; a larger page limit may take longer when many records must be checked.

**Can I schedule recurring collection?** Yes. Schedule runs at an interval that is useful for your monitoring needs, store each dataset, and compare stable `jobId` values to detect additions. The source says its jobs are refreshed hourly, but that does not guarantee every listing changes on a fixed schedule.

**Can I export to a spreadsheet?** Yes. Download the dataset as CSV or Excel, or retrieve JSON through the dataset API and load it into your own spreadsheet or reporting process.

**Why is a field empty?** The source may omit that value. `jobTypes` and `tags` are empty arrays when there is no corresponding feed value, and a missing posting timestamp is `null`. The actor does not fill missing source information with guesses.

**Why is visa sponsorship an estimate?** The API records inspected for this actor do not include a separate sponsorship field. The actor checks description text for common sponsorship language; open the job listing to confirm the employer's current policy.

### Integrations

Retrieve dataset rows through the API, send completed-run webhooks to your own endpoint, or connect a scheduled run to an automation workflow. CSV and Excel exports can feed spreadsheet reviews, while JSON is suitable for a database, internal dashboard, or job-alert service. Use `jobId` as a deduplication key and retain `url` so every downstream row can be traced to its public listing.

### Support

Open an issue on the Issues tab; we reply within 24h and add fields on request.

# Actor input Schema

## `keywords` (type: `string`):

Case-insensitive text to find in job titles. Example: data engineer. Use it to narrow to a role; leave empty to include every title.

## `visaSponsorship` (type: `boolean`):

Keep jobs whose description suggests visa sponsorship (true or false). Example: true for relocation searches. Inferred from description text, not an official flag; leave false for all jobs.

## `remote` (type: `boolean`):

Keep only jobs Arbeitnow marks as remote (true or false). Example: true for remote-only roles. Leave false to include on-site jobs too.

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

Case-insensitive city or location text to match. Example: Berlin. Use it to focus on one place; leave empty for all locations.

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

Maximum matching job records to return (integer, up to 500). Example: 50. Use a small value for quick runs.

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

Maximum public feed pages to inspect (integer, up to 20). Example: 2. Each page holds about 300 jobs; raise it when filters match few jobs.

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

Apify Proxy settings for requests to Arbeitnow. Example: {"useApifyProxy": true}. The public feed currently needs no special proxy.

## Actor input object example

```json
{
  "keywords": "",
  "visaSponsorship": false,
  "remote": false,
  "location": "",
  "maxJobs": 50,
  "maxPages": 2,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All collected jobs in the default dataset.

# 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 = {
    "keywords": "",
    "visaSponsorship": false,
    "remote": false,
    "location": "",
    "maxJobs": 50,
    "maxPages": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("mlg14/arbeitnow-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 = {
    "keywords": "",
    "visaSponsorship": False,
    "remote": False,
    "location": "",
    "maxJobs": 50,
    "maxPages": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("mlg14/arbeitnow-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 '{
  "keywords": "",
  "visaSponsorship": false,
  "remote": false,
  "location": "",
  "maxJobs": 50,
  "maxPages": 2
}' |
apify call mlg14/arbeitnow-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,mlg14/arbeitnow-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/Ycg3xYTsRXvq2wYUs/builds/DPnGjQm2oNGDk3kbs/openapi.json