# AMS Austria Jobs Scraper: Bulk Austrian Job Leads (`getascraper/jobs-ams-at-scraper`) Actor

Scrape job listings from AMS Austria's public employment service portal (jobs.ams.at). Extracts job titles, hiring company details, working hours, education requirements, and salary ranges. Runs fast and reliably without needing any user login. $1.49/1k.

- **URL**: https://apify.com/getascraper/jobs-ams-at-scraper.md
- **Developed by:** [GetAScraper](https://apify.com/getascraper) (community)
- **Categories:** Jobs, Automation, Lead generation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.49 / 1,000 job leads

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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

### What does AMS Austria Jobs Scraper do?

Get complete, structured job listings and employer contacts from AMS Austria (jobs.ams.at), the national employment portal of Austria's Public Employment Service: job titles, direct employer names, full corporate street addresses, federal state, city, postal code, wage details, working hours, education/experience levels, full descriptions, and Green Job flags, ready for your CRM in under 10 seconds. This scraper utilizes standard web connections to load the live Austrian job directory, and translates listings automatically into clean, spreadsheet-ready tables. Built for recruiting agencies, HR tech platforms, sales lead prospectors, and labor market researchers.

### Why use AMS Austria Jobs Scraper?

- **I am a European recruiter** compiling high-value job openings and employer leads in Austria to match with qualified international talent.
- **I am an immigration specialist** identifying businesses with active vacancies to support foreign workers with EU Blue Card applications.
- **I am a lead generation specialist** collecting verified Austrian business contacts and active requirements to offer B2B sales leads.
- **I am a green-tech researcher** compiling regional data on environmentally friendly "Green Jobs" across federal Austrian states.

### How to use AMS Austria Jobs Scraper

1. Create a free Apify account (no credit card needed).
2. Open the AMS Austria Jobs Scraper in the Apify Console.
3. Enter your target search keyword (such as `techniker`, `sales`, or `nurse`).
4. Set optional filters to isolate specific locations (such as `Wien` or `Tirol`), Green Jobs, or specific job sources.
5. Click **Start** and download your structured Austrian job leads database as CSV, Excel, or JSON.

### Input

| Field | Type | Required | Description |
| --- | --- | --- | --- |
| `query` | string | No | The job title, business keyword, or skill to search for in Austria (for example, `sales`, `engineer`, or `nurse`). |
| `location` | string | No | City, town, or federal state in Austria where the jobs are located (for example, `Wien`, `Klagenfurt`, or `Kärnten`). |
| `sortBy` | string | No | Order the listings by best keyword relevance or by most recently posted. Defaults to relevance. |
| `greenJobsOnly` | boolean | No | If enabled, returns only environmentally friendly Green Jobs as flagged by AMS Austria. Defaults to false. |
| `jobSource` | string | No | Restrict to a single source of listings (such as Company offers, Internet job boards, EURES), or include all. Defaults to all. |
| `maxItems` | integer | No | The maximum number of job postings to extract and save. Defaults to 100. |
| `proxyConfiguration` | object | Yes | Network connection settings. Standard Datacenter Proxies are highly recommended. |

### Output

A structured dataset of Austrian job postings with direct employer names, detailed address segments, contract terms, wage estimates, and Green Job flags. Free users get up to 100 results per run, paid plans scale to 1,000,000.

```json
{
  "uuid": "cf01c450-854e-3e2b-acaa-ce90cd360579",
  "title": "Service Manager",
  "url": "https://jobs.ams.at/public/emps/jobs/cf01c450-854e-3e2b-acaa-ce90cd360579",
  "company_name": "ELIN Motoren GmbH",
  "company_street": "Elin-Motoren-Strasse 1",
  "company_city": "Weiz",
  "company_state": "Steiermark",
  "company_zip": "8160",
  "employment_relationship": "Arbeiter/Angestellte",
  "working_time": "Vollzeit",
  "salary_info": "EUR 3350",
  "experience_required": "Matura",
  "description": "Ihr Verantwortungsbereich: Mitarbeit und Ausbau des Bereiches Service...",
  "available_from": "2026-06-15T00:00:00Z",
  "is_green_job": false,
  "scraped_at": "2026-06-21T10:00:00.000Z"
}
````

### Data table

| Field | Type | Description |
| --- | --- | --- |
| `uuid` | string | Unique job listing ID assigned by AMS Austria. |
| `title` | string | Official job title. |
| `url` | string | Canonical job posting details URL on jobs.ams.at. |
| `company_name` | string | Registered name of the hiring employer. |
| `company_street` | string | Street address of the employer. |
| `company_city` | string | Town or city where the company is located. |
| `company_state` | string | Austrian federal state (such as Wien, Tirol, Steiermark). |
| `company_zip` | string | Area postal code. |
| `employment_relationship` | string | Employment category (such as Arbeiter/Angestellte, Lehrstelle). |
| `working_time` | string | Working time arrangements (such as Vollzeit, Teilzeit). |
| `salary_info` | string | Salary information when disclosed in the posting (best-effort extraction). |
| `experience_required` | string | Educational background or experience credentials requested. |
| `description` | string | Description or responsibilities summary text. |
| `available_from` | string | ISO 8601 date when the vacancy was published or updated. |
| `is_green_job` | boolean | True if the job is officially flagged as environmentally friendly. |
| `scraped_at` | string | ISO 8601 extraction timestamp. |

### Pricing

The Actor costs **$1.49 per 1,000 results**. A typical run extracting 500 job postings from a targeted category costs about $0.75. Standard Datacenter Proxies are highly cost-effective and fully supported, ensuring you only pay for the exact volume of data you collect.

### Tips or advanced options

- **Automated session management.** The jobs.ams.at platform has strict verification procedures on standard page requests. The scraper handles all verification checks in the background automatically, preventing access errors or missed listings.
- **Track Green Jobs.** Enable the `greenJobsOnly` filter to isolate environmentally conscious positions and clean technology careers in Austria automatically.
- **Default proxies are optimal.** Standard datacenter proxies reach the AMS Austria endpoints with 100% success. No premium residential proxy configuration is needed, saving you bandwidth fees.

### FAQ, disclaimers, and support

##### Is the AMS Austria Jobs scraper legal?

Yes. The AMS Austria Jobs scraper accesses public job details that are publicly visible to any logged-out human in a browser. It does not require login, bypass paywalls, or private user accounts. You are responsible for compliance with AMS Austria terms of service and local laws.

##### Does this scraper require proxies?

Yes. AMS Austria uses basic firewall settings that block raw connection attempts. The Actor is pre-configured to use standard Apify Datacenter Proxies automatically, resolving connection requests flawlessly.

##### Why is the salary sometimes empty or not fully structured?

Austrian postings do not always state a salary; when present it is extracted from the raw posting text on a best-effort basis using our fallback regex scanners.

**Disclaimer:** This Actor accesses public web listing data only. It does not bypass authentication, paywalls, or anti-bot systems on the live site. AMS Austria is the registered trademark of the Arbeitsmarktservice Oesterreich. This Actor is affiliation-free, and not endorsed or sponsored by the Arbeitsmarktservice Oesterreich.

# Actor input Schema

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

The job title, business keyword, or skill to search for in Austria (for example, sales, engineer, or nurse).

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

City, town, or federal state in Austria where the jobs are located (for example, Wien, Klagenfurt, or Kärnten).

## `sortBy` (type: `string`):

Order the listings by best keyword relevance or by most recently posted.

## `greenJobsOnly` (type: `boolean`):

If enabled, returns only environmentally friendly Green Jobs as flagged by AMS Austria.

## `jobSource` (type: `string`):

Restrict to a single source of listings, or include all sources.

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

The maximum number of job postings to extract and save.

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

Standard datacenter proxies are sufficient and highly cost-effective for AMS Austria.

## Actor input object example

```json
{
  "sortBy": "_SCORE",
  "greenJobsOnly": false,
  "jobSource": "ALL",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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 = {
    "sortBy": "_SCORE",
    "greenJobsOnly": false,
    "jobSource": "ALL",
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("getascraper/jobs-ams-at-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 = {
    "sortBy": "_SCORE",
    "greenJobsOnly": False,
    "jobSource": "ALL",
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("getascraper/jobs-ams-at-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 '{
  "sortBy": "_SCORE",
  "greenJobsOnly": false,
  "jobSource": "ALL",
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call getascraper/jobs-ams-at-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "AMS Austria Jobs Scraper: Bulk Austrian Job Leads",
        "description": "Scrape job listings from AMS Austria's public employment service portal (jobs.ams.at). Extracts job titles, hiring company details, working hours, education requirements, and salary ranges. Runs fast and reliably without needing any user login. $1.49/1k.",
        "version": "0.1",
        "x-build-id": "CrfpxqVt04IAXO9jh"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/getascraper~jobs-ams-at-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-getascraper-jobs-ams-at-scraper",
                "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/getascraper~jobs-ams-at-scraper/runs": {
            "post": {
                "operationId": "runs-sync-getascraper-jobs-ams-at-scraper",
                "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/getascraper~jobs-ams-at-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-getascraper-jobs-ams-at-scraper",
                "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",
                "properties": {
                    "query": {
                        "title": "Job title or skills keyword",
                        "type": "string",
                        "description": "The job title, business keyword, or skill to search for in Austria (for example, sales, engineer, or nurse)."
                    },
                    "location": {
                        "title": "Austrian city or federal state",
                        "type": "string",
                        "description": "City, town, or federal state in Austria where the jobs are located (for example, Wien, Klagenfurt, or Kärnten)."
                    },
                    "sortBy": {
                        "title": "Sort results by",
                        "enum": [
                            "_SCORE",
                            "PERIOD"
                        ],
                        "type": "string",
                        "description": "Order the listings by best keyword relevance or by most recently posted.",
                        "default": "_SCORE"
                    },
                    "greenJobsOnly": {
                        "title": "Only green jobs",
                        "type": "boolean",
                        "description": "If enabled, returns only environmentally friendly Green Jobs as flagged by AMS Austria.",
                        "default": false
                    },
                    "jobSource": {
                        "title": "Job source",
                        "enum": [
                            "ALL",
                            "SB_WKO",
                            "IJ",
                            "BA"
                        ],
                        "type": "string",
                        "description": "Restrict to a single source of listings, or include all sources.",
                        "default": "ALL"
                    },
                    "maxItems": {
                        "title": "Maximum job listings to save",
                        "minimum": 1,
                        "maximum": 50000,
                        "type": "integer",
                        "description": "The maximum number of job postings to extract and save.",
                        "default": 100
                    },
                    "proxyConfiguration": {
                        "title": "Network connection settings",
                        "type": "object",
                        "description": "Standard datacenter proxies are sufficient and highly cost-effective for AMS Austria.",
                        "default": {
                            "useApifyProxy": true
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
