# Academics.de Scraper - German Science & Research Jobs (`studio-amba/academics-de-scraper`) Actor

Scrape academic, research and science job listings from Academics.de, Germany's leading careers portal for professorships, PhD, postdoc and research-associate positions. Extract job titles, institutions, locations, subject areas and application deadlines. No login required.

- **URL**: https://apify.com/studio-amba/academics-de-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

### What does Academics.de Scraper do?

**Academics.de Scraper** extracts academic, research and science job listings from [Academics.de](https://www.academics.de), Germany's leading careers portal for professorships, PhD positions, postdoc roles and research-associate positions (part of the ZEIT Verlagsgruppe / Forschung & Lehre publishing group). It collects job titles, hiring institutions, locations, subject areas, position types, contract terms and application deadlines, directly from the site's own listing and detail pages. No login or cookies required.

Use it on the Apify platform to get structured German academic job-market data via API, schedule recurring scrapes, and integrate with tools like Zapier, Make, Google Sheets, and Slack.

### How to scrape Academics.de data

1. Go to the Academics.de Scraper on the Apify Store.
2. Click **Try for free** to open the actor in the Apify Console.
3. Enter a German search keyword (e.g. "Professur", "Doktorand", "Postdoc") or leave it empty to use the default professorship search.
4. Set the maximum number of job listings you want.
5. Click **Start** and wait for the run to finish.
6. Download your data as JSON, CSV, Excel, or HTML from the Output tab.

### Why use Academics.de Scraper?

- **Academic recruitment** — Universities, research institutes and HR agencies can monitor open professorships and research positions across German higher education.
- **Labor market analysis** — Track which subject areas, institutions and federal states (Bundesländer) are hiring most actively in academia and research.
- **Career and relocation planning** — Researchers and academics can build a structured view of open positions by subject, location, and contract type instead of browsing listings by hand.
- **Deadline tracking** — Application deadlines are parsed from the visible page text (more reliable than the listing's internal metadata, see Limitations), so it's usable for time-sensitive alerts.
- **Academic and public-policy research** — Gather structured German academic-employment data straight from the leading sector-specific job board.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | German search keyword (e.g. "Professur" = professorship, "Doktorand" = PhD student, "wissenschaftlicher Mitarbeiter" = research associate, "Postdoc"). Leave empty to use the default "Professur" search. |
| `maxResults` | Integer | No | Maximum number of job listings to scrape (default: 50, max: 2000). |
| `proxyConfiguration` | Object | No | Proxy settings. Academics.de serves clean server-rendered HTML with no WAF challenge, so Apify's automatic/free proxy pool is used by default — no residential proxy needed. |

### Output

Each result contains structured data about a single job listing. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output

```json
{
    "jobTitle": "Professur „Intelligente Robotik“ (w/m/d)",
    "institution": "Technische Hochschule Mannheim",
    "location": "Mannheim",
    "region": "Baden-Württemberg",
    "postalCode": "68163",
    "subject": "Elektrotechnik, Elektronik",
    "positionType": "Professor, Professorin",
    "workArea": "Lehre & Forschung, Wissenschaft",
    "contractDuration": "Befristet",
    "workingHours": "Vollzeit",
    "description": "Zum Sommersemester 2027 oder später ist in der Fakultät für Elektrotechnik folgende Stelle zu besetzen: Professur „Intelligente Robotik“ (w/m/d) Bes. Gr. W2 (Stellen-Nr. 819)...",
    "postedDate": "2026-07-27T22:00:00Z",
    "applicationDeadline": "2026-08-31T00:00:00.000Z",
    "employerLogoUrl": "https://assets.academics.de/jobs/company_logo/7wka7t2hzy26swi2btohkqfl6hx5pghz6jurscdc6mddr4oh2cba.png",
    "jobId": "1109182",
    "url": "https://www.academics.de/jobs/professur-intelligente-robotik-w-m-d-technische-hochschule-mannheim-1109182",
    "scrapedAt": "2026-08-10T19:35:06.210Z"
}
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `jobTitle` | String | Job listing title (German) |
| `institution` | String | Hiring institution or employer name (university, research institute, company) |
| `location` | String | City where the position is based |
| `region` | String | German federal state (Bundesland) |
| `postalCode` | String | Postal code of the workplace |
| `subject` | String | Academic subject / field category (e.g. "Mathematik", "Biochemie") |
| `positionType` | String | Position category (e.g. "Professor, Professorin", "Wissenschaftlicher Mitarbeiter, wissenschaftliche Mitarbeiterin") |
| `workArea` | String | Broader work-area category (e.g. "Lehre & Forschung, Wissenschaft") |
| `contractDuration` | String | "Befristet" (fixed-term) or "Unbefristet" (permanent) |
| `workingHours` | String | "Vollzeit" (full-time) or "Teilzeit" (part-time) |
| `description` | String | Job description text (HTML stripped, truncated to 8000 characters) |
| `postedDate` | String | When the job was first published (ISO 8601) |
| `applicationDeadline` | String | Application deadline (ISO 8601), parsed from the visible "Bewerbungsfrist" text on the listing, `null` if not disclosed |
| `employerLogoUrl` | String | URL of the hiring institution's logo, if available |
| `jobId` | String | Academics.de internal job listing identifier |
| `url` | String | Direct URL to the job listing on Academics.de |
| `scrapedAt` | String | ISO 8601 timestamp of when the data was collected |

### Cost estimate

This actor fetches server-rendered HTML directly rather than rendering pages in a browser, so it runs fast and cheap — roughly **0.3–0.6 compute units per 1,000 results** (one listing-page fetch per 50 results, plus one detail-page fetch per result). At standard Apify pricing that's well under $0.50 per 1,000 job listings. As with any Apify actor, the run's usage cost only settles once the run reports SUCCEEDED — reading a mid-run/in-progress dataset understates the eventual cost.

### Tips

- Use specific German subject or role keywords ("Professur", "Doktorand", "Postdoc", "wissenschaftlicher Mitarbeiter") to narrow results to a field.
- Leave `searchQuery` empty to pull the default professorship search, one of the highest-volume categories on the site.
- `subject`, `positionType` and `workArea` are Academics.de's own taxonomy tags — use them together to filter results by field and role level.
- Schedule recurring runs to track newly posted positions daily or weekly.

### Limitations

- `applicationDeadline` is parsed from the visible "Bewerbungsfrist: DD.MM.YYYY" text on the detail page, not from the listing's JSON-LD `validThrough` field — the two dates diverge on this site (`validThrough` looks like an internal ad-expiry date, weeks earlier than the real deadline candidates see). `applicationDeadline` is `null` when no deadline text is shown on the page.
- `location`, `region` and `postalCode` are `null` for the small number of listings that don't publish a structured address (e.g. remote or multi-site postings).
- Description text is truncated to 8,000 characters.
- Data is scraped from the public Academics.de website and may change without notice.

### Integrations

Connect Academics.de Scraper with your existing tools and workflows:

- **Google Sheets** — Export listings directly to a spreadsheet for easy filtering and sharing.
- **Slack** — Get notified when new positions matching your criteria appear.
- **Zapier / Make** — Build workflows that react to new job postings in real time.
- **Custom API** — Access all results programmatically via the Apify API in JSON format.

### FAQ and support

**Is it legal to scrape Academics.de?** Scraping publicly available data is generally permitted under EU law. This actor only accesses public job listings that require no login, via the same pages the public site uses.

**How often is the data updated?** The actor scrapes live data from Academics.de each time it runs. Schedule it daily or weekly to track new postings.

**I found a bug or have a feature request.** Open an issue in the Issues tab on the actor page. You can also request a custom scraping solution.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

German search keyword (e.g. 'Professur' = professorship, 'Doktorand' = PhD student, 'wissenschaftlicher Mitarbeiter' = research associate, 'Postdoc'). Leave empty to use the default 'Professur' search.

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

Maximum number of job listings to scrape.

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

Proxy settings. Academics.de works reliably over Apify's automatic proxy -- no anti-bot protection was found on the site.

## Actor input object example

```json
{
  "searchQuery": "Professur",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# 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": "Professur",
    "maxResults": 20,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/academics-de-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": "Professur",
    "maxResults": 20,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/academics-de-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 '{
  "searchQuery": "Professur",
  "maxResults": 20,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call studio-amba/academics-de-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/academics-de-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/lRXAoSxNlCUgerl1E/builds/788qGllgNtM56u2mj/openapi.json