# jobs.edu.ro Scraper — Romania University Job Postings (`studio-amba/jobs-edu-ro-scraper`) Actor

Scrape academic job postings from jobs.edu.ro, Romania's Ministry of Education official job board for universities. Extract position, institution, faculty, domain, salary and application deadline. No login or cookies required.

- **URL**: https://apify.com/studio-amba/jobs-edu-ro-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 $7.00 / 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/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

### What does jobs.edu.ro Scraper do?

**jobs.edu.ro Scraper** extracts academic job postings from [jobs.edu.ro](https://jobs.edu.ro), the official job board operated by Romania's Ministry of Education for university faculty and researcher openings ("posturi didactice și de cercetare"). Every public Romanian university and higher-education institution publishes its vacant lecturer, professor and researcher positions here, along with the position's minimum salary, the application window, and the exam calendar.

The scraper searches by keyword, institution or academic rank, then returns structured data: posting title, hiring institution, faculty, department, city, scientific domain, minimum salary, application deadline and full posting text. Run it on the Apify platform to get **API access, scheduling, proxy rotation, webhook integrations, and monitoring** out of the box. No login or cookies required -- all data is extracted from publicly available postings.

### Why use jobs.edu.ro Scraper?

- **Academic job market research**: Track every open lecturer, associate professor, professor and researcher position across Romania's ~110 public and private universities in one feed.
- **Salary benchmarking**: jobs.edu.ro publishes the legally mandated minimum salary for every posting, in RON -- useful for comparing pay across institutions and ranks.
- **Recruitment intelligence**: See which faculties and departments are actively hiring, and how competitive a given field or university is.
- **Deadline tracking**: The application window (perioadă înscriere) is parsed into a clean start/end date, so you can build alerts for closing deadlines.
- **Academic research**: Study hiring trends by scientific domain, region or institution type over time.
- **HR / relocation services**: Feed structured academic vacancy data into a job board, newsletter or relocation-advisory product targeting international academics considering Romania.

### How to scrape jobs.edu.ro data

1. Go to the jobs.edu.ro Scraper page on Apify Store.
2. Click **Try for free** to open the Actor in Apify Console.
3. Optionally enter a **Search Query** (matched against position, discipline or scientific domain -- e.g. "lector", "informatica", "drept"). Leave empty to list all current postings.
4. Optionally filter by **University / Institution** (e.g. "Cluj", "Babes-Bolyai", "Politehnica Bucuresti") or **Academic Position** (Lecturer, Professor, Associate Professor, etc.).
5. Choose the **Status**: open postings (default), finished postings, or the full historical archive.
6. Set the maximum number of results you want.
7. Click **Start** and wait for the run to finish.
8. Download your data as JSON, CSV, Excel, or connect it to your workflow via API.

That's it -- no coding required. The scraper handles pagination and data extraction automatically, and defaults to every currently open posting when no filters are set.

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | String | Keyword matched against position / discipline / scientific domain | *(none -- all postings)* |
| `university` | String | Institution name filter, partial match against the site's ~110 institutions (e.g. "Cluj", "Politehnica") | *(none -- all institutions)* |
| `position` | String | Academic rank filter (dropdown: Assistant Lecturer, Lecturer, Associate Professor, Professor, Researcher grades, etc.) | *(none -- all ranks)* |
| `scope` | String | `open` (in-progress selection), `finished` (concluded), or `all` (full archive) | `open` |
| `maxResults` | Integer | Maximum number of postings to scrape | `500` |
| `proxyConfiguration` | Object | Proxy settings | Apify Proxy (automatic) |

#### Example input

```json
{
    "searchQuery": "lector",
    "scope": "open",
    "maxResults": 50,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

### Output

The scraper outputs structured JSON data for each posting. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output

```json
{
    "postingId": "40011",
    "postingTitle": "Lector universitar, poziția 10, Departamentul de Psihologie și Asistență Socială, Facultatea de Științe ale Vieții și Dezvoltare Umană",
    "institution": "UNIVERSITATEA INTERNAȚIONALĂ \"DANUBIUS\" DIN GALAȚI",
    "faculty": "Facultatea de Științe ale Vieții și Dezvoltare Umană",
    "department": "Psihologie și Asistență Socială",
    "city": "Galați",
    "country": "Romania",
    "position": "Lector universitar",
    "domain": "Psihologie",
    "positionNumber": "10",
    "employmentType": "FULL_TIME",
    "minSalary": 4598,
    "salaryCurrency": "RON",
    "postedDate": "2026-04-23",
    "enrollmentStart": "2026-04-23",
    "deadline": "2026-07-25",
    "description": "Norma didactică, care cuprinde: a) Activități de predare; b) Activități de seminar, lucrări practice și de laborator...",
    "scope": "open",
    "url": "https://jobs.edu.ro/posturi/40011",
    "scrapedAt": "2026-09-03T14:25:43.201Z"
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `postingId` | jobs.edu.ro internal posting ID |
| `postingTitle` | Full title of the posting (position, position number, department) |
| `institution` | Hiring university or higher-education institution |
| `faculty` | Faculty within the institution |
| `department` | Department within the faculty |
| `city` | City of the hiring institution, derived from its official name |
| `country` | Always "Romania" |
| `position` | Academic function / rank (e.g. Lector universitar, Profesor universitar) |
| `domain` | Scientific field of the posting (e.g. Psihologie, Filologie) |
| `positionNumber` | Position number in the institution's staffing table (poziție stat funcții) |
| `employmentType` | Employment type as published (e.g. FULL\_TIME) |
| `minSalary` | Minimum monthly base salary in RON, when published |
| `salaryCurrency` | Currency of `minSalary`, always RON when present |
| `postedDate` | ISO 8601 date the posting was published in the Official Gazette (Monitorul Oficial) |
| `enrollmentStart` | ISO 8601 date the application period opens |
| `deadline` | ISO 8601 date the application period closes |
| `description` | Posting description / duties text |
| `scope` | Status this posting was scraped under: `open`, `finished`, or `all` |
| `url` | Direct link to the posting on jobs.edu.ro |
| `scrapedAt` | ISO 8601 timestamp of data collection |

### How much does it cost to scrape jobs.edu.ro?

jobs.edu.ro Scraper is a lightweight HTTP scraper (no headless browser required) -- the site renders postings server-side with no anti-bot protection, so plain HTTP requests are enough for reliable extraction. It's billed pay-per-result: about **$0.01 per run start plus $0.012 per result**. A 100-posting run costs roughly $1.21; a 500-posting run (the default, and enough to cover every currently open posting) costs roughly $6.01. It visits one listing-page request per 100 postings plus one detail-page request per posting, so cost scales with result count. A run's usage cost only settles in your Apify billing after the run reports **SUCCEEDED** -- reading the dataset mid-run will undercount what you're actually charged.

### Tips and advanced options

- **Leave all filters empty** to get every currently open posting across Romania in one run -- this is the default and typically returns 300+ postings.
- **Use `scope: "all"`** to pull the full historical archive, useful for studying hiring trends over time (1,000+ postings).
- **University matching is fuzzy and diacritics-insensitive** -- "cluj", "Cluj-Napoca" or "Babes Bolyai" all resolve to the correct institution. If no institution matches, the scraper logs a warning and returns results without that filter rather than failing the run.
- **Set `maxResults`** to control run length. Start small (10-50) to verify the output, then scale up.
- **Combine with other scrapers** to build a full picture of the Romanian job market -- check our Hipo.ro scraper for the general graduate/IT market alongside jobs.edu.ro's academic-only postings.

### FAQ and support

#### Is it legal to scrape jobs.edu.ro?

This scraper extracts only publicly available posting data that any visitor can see without logging in. It does not access private data, bypass authentication, or violate GDPR. Always review the website's Terms of Service before large-scale scraping and ensure your use case complies with applicable Romanian and EU laws.

#### The scraper returns 0 results

- Make sure your search query, university or position filter matches postings that are actually live under the selected `scope`.
- Try `scope: "all"` to search the full archive rather than just open postings.
- Broaden or remove the `university` / `position` filter.

#### Can I get custom modifications?

Yes. If you need additional fields, different output formats, or integration with your systems, open an issue in the **Issues** tab or contact us for a custom solution.

#### How often should I run this scraper?

jobs.edu.ro publishes new postings on a rolling basis as institutions open competitions. Running once daily or weekly is sufficient for most use cases. Use Apify's scheduler to automate recurring runs and catch new deadlines as they're published.

# Actor input Schema

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

Keyword to search for, matched against position / discipline / scientific domain (e.g. 'lector', 'informatica', 'drept'). Leave empty to list all current postings.

## `university` (type: `string`):

Filter by institution name (e.g. 'Cluj', 'Babes-Bolyai', 'Politehnica Bucuresti'). Matched against the official list of ~110 Romanian higher-education institutions on the site (partial match, case/diacritics-insensitive). Leave empty for all institutions.

## `position` (type: `string`):

Filter by academic function / rank.

## `scope` (type: `string`):

'Open' returns postings whose selection process is still in progress (default). 'Finished' returns concluded postings. 'All' returns the full historical archive.

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

Maximum number of job postings to scrape.

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

Proxy settings for scraping jobs.edu.ro. The site has no anti-bot protection, so Apify's automatic proxy is sufficient.

## Actor input object example

```json
{
  "position": "",
  "scope": "open",
  "maxResults": 5,
  "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 = {
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,studio-amba/jobs-edu-ro-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/3BAWVGw7ntgBD2uEZ/builds/tg7BK49cI7H6xryrx/openapi.json