# Get-in-IT Jobs & Employer Directory Scraper (`crawlyth-forge/get-in-it-jobs-and-employer-directory-scraper`) Actor

Pull German IT job listings from get-in-it.de by career field, degree, state or keyword, fetch full job postings with salary and requirements, or browse the employer directory with full company profiles.

- **URL**: https://apify.com/crawlyth-forge/get-in-it-jobs-and-employer-directory-scraper.md
- **Developed by:** [crawlyth forge](https://apify.com/crawlyth-forge) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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?

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

## Get-in-IT Jobs & Employer Directory Scraper

[get-in-it.de](https://www.get-in-it.de) is a German job board focused specifically on IT and computer-science roles for students, graduates and career starters. This actor browses and filters its live job listings, fetches a full posting by job ID, or walks the employer directory down to a single company's full profile — no login, API key, or proxy needed.

### What this actor does

- **Four modes:** `search` (browse/filter the job listings), `jobDetails` (fetch a full job posting by ID), `companies` (browse the employer directory), and `companyDetails` (fetch a full company profile by ID/slug/URL)
- **Job filters:** career field(s) (14 IT specializations, multi-select), study subject(s) (11 fields, multi-select), degree level(s) (4 levels, multi-select), German federal state(s) (16 Bundesländer, multi-select), home-office/remote only, employer(s) (by company ID, multi-select), free-text keyword — select several values in any multi-select filter to match ANY of them
- **Company filters:** industry/branch (15 categories, multi-select), German federal state(s) (multi-select), free-text company-name keyword
- **Rich job detail records:** full job description, itemized responsibilities/requirements/benefits, required skills, education requirements, employment type, posting date, salary (when the employer discloses it), and company info
- **Rich company profile records** (mode=`companyDetails`): company description, legal name, postal address, phone number, email, website, careers-page URL, social media links, quick facts (employee count, founding year, locations, when disclosed), awards, employee testimonials, upcoming recruiting events, and industries — in addition to the logo, header image, and "top company" status also available in mode=`companies`
- **Empty fields are omitted** — every record only contains fields that were actually found

### Output per job

- `jobId`, `title`, `jobUrl`
- `companyId`, `companyName`, `companyUrl`, `companyLogoUrl`, `companyWebsite`, `companyIsTopCompany`, `companyTotalJobs`
- `careerFields[]` — IT specialization(s), e.g. `Webentwicklung`, `IT-Security`
- `locations[]`, `primaryLocation`, `city`, `state`, `country`
- `homeOffice` — true if the role offers remote/hybrid work
- `isSponsoredListing` — true if the listing is a paid/promoted placement
- `skills[]` — technologies and skills mentioned in the posting
- `studySubjects[]`, `degrees[]`, `educationRequirements[]`
- `employmentType`, `datePosted`, `applicationDeadline`, `jobImmediateStart`, `directApply`
- `description` — full plain-text job description (mode=`jobDetails`)
- `responsibilities[]`, `requirements[]`, `benefits[]` — itemized bullet points parsed from the posting's tasks/requirements/benefits sections, when the employer structured them that way (mode=`jobDetails`)
- `salaryMin`, `salaryMax`, `salaryCurrency`, `salaryUnit` — when the employer discloses a salary range
- `applyUrl`, `pdfUrl`
- `recordType: "job"`, `scrapedAt`

### Output per company (mode=`companies`)

- `companyId`, `companyName`, `companyUrl`
- `companyLogoUrl`, `companyBoxImageUrl`, `companyHeaderImageUrl`
- `companyIsTopCompany` — true if the employer is a featured/"Top" partner
- `companyTotalJobs` — number of currently published job postings
- `branches[]` — industry categories, e.g. `IT Branche`, `Beratung/Consulting`
- `locations[]` — cities where the company has open positions
- `recordType: "company"`, `scrapedAt`

### Output per company profile (mode=`companyDetails`)

- `companyId`, `companyName`, `companyLegalName`, `companyUrl`
- `companyLogoUrl`, `companyHeaderImageUrl`, `companyIsTopCompany`
- `companyDescription` — the employer's "About us" text from their get-in-it.de profile
- `companyAddress`, `companyPhone`, `companyEmail` — when the employer's profile discloses them
- `companyWebsite`, `companyCareerPageUrl` — the employer's own website and careers page (when linked from their profile)
- `companyFacebookUrl`, `companyTwitterUrl`, `companyInstagramUrl`, `companyYouTubeUrl` — social media links (when linked)
- `companyFacts` — free-text "quick facts" (employee count, founding year, locations, revenue, etc.), when the employer's profile includes them
- `companyAwards[]` — employer awards/certifications shown on the profile (e.g. "Top Employer (2026)"), when present
- `companyEmployeeInsights[]` — short employee testimonials from get-in-it.de's magazine (`authorName`, `profession`, `quote`, `url`, `imageUrl`), when the employer's profile features any
- `companyEvents[]` — upcoming recruiting events/career fairs the employer has listed (`title`, `date`, `location`), plus `companyEventsUrl` linking to the employer's full events page, when present
- `branches[]` — industry categories
- `companyBoxImageUrl`, `companyTotalJobs`, `locations[]` — included when the company was also resolvable via the employer directory (i.e. when looked up by numeric ID)
- `recordType: "company"`, `scrapedAt`

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `mode` | string | `search` | `search` / `jobDetails` / `companies` / `companyDetails` |
| `careerFields` | multi-select | – | Restrict to one or more of 14 IT career fields (mode=`search`, matches ANY selected) |
| `studySubjects` | multi-select | – | Restrict to one or more of 11 study subjects (mode=`search`, matches ANY selected) |
| `degrees` | multi-select | – | Restrict to one or more of 4 required degree levels (mode=`search`, matches ANY selected) |
| `states` | multi-select | – | Restrict to one or more of the 16 German federal states (Bundesländer) — mode=`search` (job location) or mode=`companies` (company location); matches ANY selected |
| `cities` | string list | – | mode=`search` / mode=`companies`: only results within `radiusKm` of these German cities (e.g. `Berlin`, `München`); matches ANY listed city. Leave empty for all of Germany |
| `radiusKm` | int | `25` | Radius around each selected city when `cities` is set (0–200 km) |
| `branches` | multi-select | – | Restrict to one or more of 15 employer industries (mode=`companies`, matches ANY selected) |
| `companySizes` | multi-select | – | Restrict to one or more of 3 employer size categories — Startup, Mittelstand, Großunternehmen (mode=`companies`, matches ANY selected) |
| `keyword` | string | – | mode=`search`: only keep jobs matching every word of this text (title, company, location, or career field — case-insensitive). mode=`companies`: only keep companies whose name contains this text |
| `homeOfficeOnly` | boolean | `false` | Only keep jobs offering home-office / remote work (mode=`search`) |
| `companyIds` | array | – | mode=`search`: restrict to one or more employers by their numeric company IDs (see the `companyId` output field) — matches ANY listed ID. mode=`companyDetails`: which company profiles to fetch — numeric company IDs, URL slugs (e.g. `adesso-se`), or full company URLs |
| `companyNames` | string list | – | Restrict by employer name — mode=`search` / mode=`companyDetails` (resolved to directory IDs) or mode=`companies` (name match); matches ANY listed name |
| `jobIds` | array | – | Job IDs / `p<id>` slugs / full URLs (mode=`jobDetails`) |
| `maxItems` | int | `50` | Hard cap on emitted records (1–5000) |

#### Example: browse embedded-systems or web development jobs with home office

```json
{
  "mode": "search",
  "careerFields": ["embedded-systems", "webentwicklung"],
  "homeOfficeOnly": true,
  "maxItems": 100
}
```

#### Example: jobs near Berlin or Munich within 25 km

```json
{
  "mode": "search",
  "cities": ["Berlin", "München"],
  "radiusKm": 25,
  "careerFields": ["it-security"],
  "maxItems": 200
}
```

#### Example: jobs from named employers

```json
{
  "mode": "search",
  "companyNames": ["SAP Fioneer", "adesso"],
  "maxItems": 100
}
```

#### Example: full details for specific jobs

```json
{
  "mode": "jobDetails",
  "jobIds": ["310856", "p310598", "https://www.get-in-it.de/jobsuche/p311024"]
}
```

#### Example: browse IT-industry employers in Bavaria

```json
{
  "mode": "companies",
  "branches": ["it-branche"],
  "states": ["bayern"],
  "companySizes": ["startup"],
  "maxItems": 100
}
```

#### Example: full profile for specific companies

```json
{
  "mode": "companyDetails",
  "companyIds": ["7897", "adesso-se", "https://www.get-in-it.de/unternehmen/deutsche-bahn-ag"]
}
```

### Use cases

- **Recruiting intelligence** — track new IT job postings across German employers
- **Salary benchmarking** — collect salary ranges where disclosed, by career field
- **Job aggregation** — feed a German-market IT job feed into your own board
- **Skill demand analysis** — analyze which technologies appear most often in postings
- **Market research** — compare home-office availability across companies and specializations

### FAQ

**What's get-in-it.de?** A German job board focused specifically on IT/computer-science roles for students, graduates, and professionals — run by Süddeutsche Verlag's Karriere.de group. See [get-in-it.de](https://www.get-in-it.de).

**Do I need a proxy or login?** No — the site's job listings are fully public and this actor works without any credentials, cookies, or paid proxy add-ons.

**What are "career fields"?** get-in-it.de tags each job with one or more of 14 IT specializations (e.g. Web Development, IT Security, UX/UI, System Engineering). Use the `careerFields` input to narrow results to one or several.

**Why aren't `responsibilities`, `requirements`, and `benefits` always populated?** Not every employer structures their posting with a dedicated bullet list for each of those sections — when a section is present, its items are captured; when it isn't, the field is simply omitted (the full text is still available in `description`).

**Why isn't salary always populated?** German job postings rarely disclose salary ranges publicly. When an employer does include one in their structured job data, the actor captures `salaryMin`/`salaryMax`/`salaryCurrency`.

**How current is the data?** Jobs are scraped live at run time directly from the site's own job search.

**Can I get every open job at one employer?** Yes — grab the `companyId` from any job record for that employer, from a mode=`companies` record, or from its get-in-it.de company page URL, and pass it in `companyIds` in mode=`search`; combine it with other filters (e.g. `careerFields`) to narrow further. Pass several company IDs to pull jobs from multiple employers in one run.

**Can I filter jobs by region?** Yes — the `states` input restricts results to one or more of the 16 German federal states (Bundesländer), e.g. `["berlin", "bayern"]`. For city-level searches use `cities` plus `radiusKm` (e.g. Berlin within 25 km); both filters also work when browsing the employer directory. Combine them with `careerFields`, `degrees`, or `homeOfficeOnly` to narrow further.

**Can I search by free text like Indeed?** The `keyword` input filters the fetched listings by matching every word you type against the job's title, company name, location, and career field (e.g. `Entwickler München` matches a "Java Entwickler" role located in München even though that exact phrase never appears verbatim). For broader browsing, combine it with `careerFields` and `homeOfficeOnly`.

**How do I find a company's ID without already having a job listing?** Use mode=`companies` to browse the full employer directory — optionally filtered by `branches` (industry), `states`, and/or `cities` — and read the `companyId` off any result. Feed that ID straight into `companyIds` in mode=`search` to pull all of that employer's open jobs, or pass the employer's name via `companyNames`.

**What industries can I browse companies by?** get-in-it.de groups employers into 15 industries (e.g. IT Branche, Beratung/Consulting, Bankwesen, Industrie) — see the `branches` input for the full list.

**Can I filter companies by size?** Yes — use `companySizes` (mode=`companies`) to restrict results to Startups, mid-size companies (Mittelstand), or large enterprises (Großunternehmen).

**How do I get a company's full profile (address, phone, description)?** Use mode=`companyDetails` with `companyIds` set to one or more numeric company IDs, URL slugs, or full company URLs. It returns the employer's "About us" description, legal name, postal address, and phone number when their get-in-it.de profile discloses them, in addition to the logo and industries also available in mode=`companies`.

**Does mode=`companyDetails` include employee testimonials or recruiting events?** When the employer's get-in-it.de profile features them, yes — `companyEmployeeInsights[]` returns short "Erfahrungsbericht" employee quotes and `companyEvents[]` returns upcoming career fairs/recruiting events the company has listed. Not every employer publishes these, so they're only present when found (typically for premium/"Top Company" profiles).

# Actor input Schema

## `mode` (type: `string`):

What to fetch.

## `careerFields` (type: `array`):

Filter jobs by one or more IT career fields (mode=search). Leave empty for all career fields; select several to match ANY of them.

## `studySubjects` (type: `array`):

Filter jobs by the study subject(s) they target (mode=search). Leave empty for all subjects; select several to match ANY of them.

## `degrees` (type: `array`):

Filter jobs by required degree level(s) (mode=search). Leave empty for all levels; select several to match ANY of them.

## `states` (type: `array`):

Filter jobs (mode=search) or companies (mode=companies) by one or more German federal states. Leave empty for all states; select several to match ANY of them.

## `cities` (type: `array`):

Only jobs (mode=search) or companies (mode=companies) within `radiusKm` of one or more German cities. Enter city names as shown on get-in-it.de, e.g. Berlin, München, Köln. Leave empty for all of Germany; select several cities to match ANY of them.

## `radiusKm` (type: `integer`):

Search radius around each selected city (mode=search or mode=companies; used only when `cities` is set).

## `branches` (type: `array`):

Filter companies by one or more industries (mode=companies). Leave empty for all industries; select several to match ANY of them.

## `companySizes` (type: `array`):

Filter companies by size category (mode=companies). Leave empty for all sizes; select several to match ANY of them.

## `keyword` (type: `string`):

mode=search: only keep jobs matching every word of this text against title, company name, location, or career field (case-insensitive). mode=companies: only keep companies whose name contains this text.

## `homeOfficeOnly` (type: `boolean`):

Only keep jobs that offer home-office / remote work (mode=search).

## `companyIds` (type: `array`):

mode=search: only keep jobs from these employers' numeric company IDs (matches ANY of the listed IDs). mode=companyDetails: which company profiles to fetch — accepts numeric company IDs, URL slugs (e.g. `adesso-se`), or full company URLs. Find a company's ID/slug in the `companyId`/`companyUrl` field of any job or company record.

## `companyNames` (type: `array`):

Restrict to one or more employers by name (mode=search and mode=companyDetails), or keep only matching companies (mode=companies). Names are resolved against get-in-it.de's employer directory and match ANY of them. Leave empty for all employers.

## `jobIds` (type: `array`):

Job IDs, `p<id>` slugs, or full job URLs (e.g. `310856`, `p310856`, `https://www.get-in-it.de/jobsuche/p310856`).

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

Hard cap on emitted records (1–5000); the source has ~3,500 open jobs and ~1,200 companies.

## Actor input object example

```json
{
  "mode": "search",
  "careerFields": [
    "anwendungsentwicklung"
  ],
  "studySubjects": [],
  "degrees": [],
  "states": [],
  "cities": [],
  "radiusKm": 25,
  "branches": [],
  "companySizes": [],
  "keyword": "",
  "homeOfficeOnly": false,
  "companyIds": [],
  "companyNames": [],
  "jobIds": [],
  "maxItems": 3
}
```

# Actor output Schema

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

Dataset containing all scraped get-in-it.de job listings and/or company directory records.

# 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 = {
    "mode": "search",
    "careerFields": [
        "anwendungsentwicklung"
    ],
    "studySubjects": [],
    "degrees": [],
    "states": [],
    "cities": [],
    "radiusKm": 25,
    "branches": [],
    "companySizes": [],
    "keyword": "",
    "homeOfficeOnly": false,
    "companyIds": [],
    "companyNames": [],
    "jobIds": [],
    "maxItems": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlyth-forge/get-in-it-jobs-and-employer-directory-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 = {
    "mode": "search",
    "careerFields": ["anwendungsentwicklung"],
    "studySubjects": [],
    "degrees": [],
    "states": [],
    "cities": [],
    "radiusKm": 25,
    "branches": [],
    "companySizes": [],
    "keyword": "",
    "homeOfficeOnly": False,
    "companyIds": [],
    "companyNames": [],
    "jobIds": [],
    "maxItems": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlyth-forge/get-in-it-jobs-and-employer-directory-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 '{
  "mode": "search",
  "careerFields": [
    "anwendungsentwicklung"
  ],
  "studySubjects": [],
  "degrees": [],
  "states": [],
  "cities": [],
  "radiusKm": 25,
  "branches": [],
  "companySizes": [],
  "keyword": "",
  "homeOfficeOnly": false,
  "companyIds": [],
  "companyNames": [],
  "jobIds": [],
  "maxItems": 3
}' |
apify call crawlyth-forge/get-in-it-jobs-and-employer-directory-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,crawlyth-forge/get-in-it-jobs-and-employer-directory-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/qWJmY56z1QsZ2zevR/builds/Sdu6IY3dCeQ1eg4kH/openapi.json
