# AMS Austria Scraper — Job Listings & Employer Data (`studio-amba/ams-scraper`) Actor

Scrape job listings, employers, locations, and posting dates from AMS (Arbeitsmarktservice), Austria's Public Employment Service job search (jobs.ams.at / alle jobs). No login required.

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

## Pricing

from $1.20 / 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.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## AMS Austria Scraper

Extract **job listings from [AMS](https://jobs.ams.at/public/emps/) (Arbeitsmarktservice)** — the public job search of Austria's Public Employment Service, branded "alle jobs" (the same search `www.allejobs.at` redirects to).

This Actor pulls **job titles, employers, locations, posting dates, employment type, and (when disclosed) salary** straight from AMS's search results. No login, no eAMS account, no cookies required to search.

### What does AMS Austria Scraper do?

Give it a German keyword (for example `Verkäufer`, `Buchhalter`, or `Softwareentwickler`) and, optionally, a location (city, region, or postal code). The Actor pages through AMS's job search 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.

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 AMS Austria Scraper?

- **The national job board.** AMS is Austria's state employment service — the widest single feed of Austrian vacancies, spanning every region and industry.
- **Labour-market research.** Track hiring demand by occupation, region, or employer over time.
- **Recruitment and sourcing.** Build lead lists of companies actively hiring for a role in Austria.
- **Salary transparency tracking.** Many AMS postings disclose a minimum salary — useful for compensation benchmarking.
- **Job aggregators.** Feed a niche job site or newsletter with fresh, structured Austrian listings.
- **Regional targeting.** Filter by city, Bundesland, or postal code to focus on one labour market (Vienna, Graz, Salzburg, ...).

### How to scrape AMS data

1. Open the Actor and go to the **Input** tab.
2. Enter a **Search Query** in German (e.g., `Verkäufer`, `Elektriker`, `Bürokauffrau`).
3. Optionally set a **Location** (city, region, or postal code, e.g. `Wien`, `Graz`, `1010`).
4. Set **Max Results** to control how many listings you want.
5. 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 be notified of new listings.

### How it works (technical note)

AMS's search results are served by a JSON API, but every request to it must carry a per-request signed token that only AMS's own Angular front end can compute — it isn't a simple public API key like some other national job boards. Rather than trying to forge that token, this Actor drives a real headless browser to the search results page for each page number and reads the JSON response the page itself receives. That's slower than a pure API call but far more reliable than reverse-engineering an anti-bot token scheme, and it's why a proxy option is exposed even though the site otherwise shows no IP-based blocking.

### Input

| Field | Type | Description |
| --- | --- | --- |
| `searchQuery` | string | German keyword to search for. Defaults to `Verkäufer`. |
| `location` | string | City, region, or postal code. Leave empty to search all of Austria. |
| `maxResults` | integer | Maximum number of listings to return (default 100). |
| `proxyConfiguration` | object | Proxy settings for the headless browser. |

#### Example input

```json
{
  "searchQuery": "Buchhalter",
  "location": "Wien",
  "maxResults": 100,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": ["RESIDENTIAL"]
  }
}
```

### 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": "dd8e1881-7fc4-3eb7-9f84-a48a36c1ab0e",
  "title": "Buchhalter/in",
  "company": "TPA Steuerberatung GmbH",
  "locationRaw": "1100, Wien,Favoriten, Wien",
  "locationParsed": {
    "city": "Wien,Favoriten",
    "country": "Austria"
  },
  "language": "de",
  "postedAt": "2026-08-03T00:00:00Z",
  "descriptionSnippet": "Buchhalter_in (w/m/d) Wir leben eine offene Unternehmenskultur, in der Wertschätzung und Teamgeist großgeschrieben werden. Eckdaten ab sofort Ab EUR 2.435,00 Brutto / VZ…",
  "url": "https://jobs.ams.at/public/emps/jobs/dd8e1881-7fc4-3eb7-9f84-a48a36c1ab0e",
  "employmentType": "Teilzeit/Vollzeit",
  "salaryRaw": "Ab EUR 2.435,00 Brutto",
  "source": "ams.at",
  "scrapedAt": "2026-08-04T17:29:21.405Z"
}
```

#### Data fields

| Field | Description |
| --- | --- |
| `id` | Stable AMS job UUID, used for de-duplication |
| `title` | Job posting title |
| `company` | Hiring employer name |
| `locationRaw` | Location as shown by AMS (postal code, town, federal state) |
| `locationParsed.city` | Parsed city/town, or `null` |
| `locationParsed.country` | Parsed country ("Austria"), or `null` |
| `language` | ISO 639-1 code detected from the posting content (`de` or `en`) |
| `postedAt` | ISO 8601 timestamp the posting was last updated/published |
| `descriptionSnippet` | Plain-text description excerpt (HTML stripped, ~300-400 chars) |
| `url` | AMS job detail page URL |
| `employmentType` | Working-time type as disclosed by AMS (e.g. "Teilzeit/Vollzeit") |
| `salaryRaw` | Salary text extracted from the posting, when disclosed |
| `source` | Always `ams.at` |
| `scrapedAt` | ISO 8601 collection timestamp |

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

Because this Actor drives a real headless browser (one page navigation per 12 results — AMS's fixed page size), it costs more compute per result than a pure-API actor, but a typical run of a hundred listings still finishes in a couple of minutes. 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. Usage cost only settles once a run reports **SUCCEEDED** — if you read the dataset from a still-running run, the cost shown will be incomplete until it finishes.

### Tips and advanced options

- **Narrow with location.** Use `location` (city, Bundesland, or postal code) to focus on one Austrian labour market — Vienna, Graz, Linz, Salzburg, Innsbruck, and so on.
- **German keywords.** AMS postings are almost entirely German. Use German job titles for the best coverage — a small number of English-language postings for international roles exist and are auto-detected via the `language` field.
- **Salary is best-effort.** Not every posting discloses a salary. When it does, `salaryRaw` captures the raw phrasing (AMS doesn't expose a clean numeric field).
- **Deduplication.** Results are de-duplicated by job UUID within a run.
- **10,000-result ceiling.** Like most search engines, AMS caps any single query at 10,000 matching results. Narrow your query or location if you need exhaustive coverage of a very broad term.

### FAQ, disclaimers, and support

**Is scraping AMS legal?** This Actor reads AMS's public job search, the same one anyone can browse anonymously at jobs.ams.at without an account. 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 eAMS account or API key?** No. Job search is fully public. An eAMS account is only needed for AMS's authenticated features (saved jobs, alerts), which this Actor doesn't use.

**Why does this take longer than a typical job-board scraper?** AMS protects its search API with a token that only its own front-end JavaScript can compute, so this Actor uses a real browser to get valid results instead of guessing at that token. See "How it works" above.

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

Looking for job data from neighbouring public employment services? Check out:

- [Arbeitsagentur Scraper](https://apify.com/studio-amba/arbeitsagentur-scraper) — Germany's Federal Employment Agency (same-language sibling)
- France Travail Scraper — France's public employment service
- VDAB Scraper — Flanders (Belgium) public employment service
- Le Forem Scraper — Wallonia (Belgium) public employment service
- Werk.nl Scraper — Netherlands public employment service
- Arbetsförmedlingen Scraper — Sweden public employment service

# Actor input Schema

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

Keyword to search for (German). Examples: 'Verkäufer' (sales assistant), 'Buchhalter' (accountant), 'Softwareentwickler' (software developer), 'Pflegekraft' (care worker).

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

Filter by city, region, or postal code (e.g., 'Wien', 'Graz', 'Salzburg', '1010'). Leave empty to search all of Austria.

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

Maximum number of job listings to return. Each page returns 12 results (AMS's fixed page size), so larger values take more browser navigations.

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

Proxy settings for the headless browser. AMS's search page is public and showed no IP/geo blocking during testing, but residential proxies are recommended for larger runs.

## Actor input object example

```json
{
  "searchQuery": "Verkäufer",
  "maxResults": 5,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "Verkäufer",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

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