# Hipo.ro Scraper - Romanian IT & Graduate Job Listings (`studio-amba/hipo-ro-scraper`) Actor

Scrape job listings from Hipo.ro, Romania's IT, engineering, finance and graduate careers board. Search by keyword or category and city. Extract job titles, companies, categories, cities, job type, level, remote status, and posting dates. No login or cookies required.

- **URL**: https://apify.com/studio-amba/hipo-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 $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/actors/running/actors-in-store.md#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 Hipo.ro Scraper do?

**Hipo.ro Scraper** extracts job listings from [Hipo.ro](https://www.hipo.ro), Romania's dedicated careers board for IT, engineering, finance and graduate roles. It's the go-to site for students, recent graduates and young professionals, and for employers running campus recruiting and entry-to-mid level hiring campaigns. The scraper searches by keyword or job domain (IT, Engineering, Finance, Marketing, and 15+ other categories) and city, then returns structured data: job titles, companies, cities, domains, job type, job level, remote status, and posting dates.

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 job listings.

### Why use Hipo.ro Scraper?

- **Graduate & early-career market research**: Hipo.ro skews younger than general job boards like BestJobs or eJobs -- ideal for tracking internship, trainee and entry-level demand in Romania.
- **Recruitment intelligence**: Monitor which companies are running graduate programs, internships and management trainee schemes.
- **IT talent market tracking**: Hipo.ro's IT-Software domain alone carries 500+ live listings at any time -- track demand for specific tech stacks and roles.
- **Salary & benefit benchmarking**: Where salary is disclosed, extract it alongside job level and remote-work status.
- **Job aggregation**: Feed Hipo.ro listings into your own job board, aggregator platform, or HR dashboard.
- **Lead generation**: Identify actively hiring Romanian companies for B2B outreach, recruitment services, or employer-branding pitches.
- **Academic research**: Study graduate employment trends and entry-level labor market dynamics in Romania.

### How to scrape hipo.ro data

1. Go to the Hipo.ro Scraper page on Apify Store.
2. Click **Try for free** to open the Actor in Apify Console.
3. Enter your search keyword (e.g. "programator", "contabil", "inginer", or any Romanian/English job title) -- the scraper maps it to the closest matching Hipo.ro job domain.
4. Or pick a **Domain / Category** directly (IT / Software, Engineering, Accounting / Finance, Marketing, Internship, and 15+ more) and optionally a **City**.
5. Set the maximum number of results you want.
6. Click **Start** and wait for the run to finish.
7. 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, proxy rotation, and data extraction automatically.

### Input

| Field | Type | Description | Default |
|-------|------|-------------|---------|
| `searchQuery` | String | Job search keyword (Romanian or English), mapped to the closest Hipo.ro domain | `programator` |
| `category` | String | Job domain filter (IT / Software, Engineering, Finance, Marketing, Internship, etc.) | All domains |
| `city` | String | City name (Bucuresti, Cluj-Napoca, Timisoara, Iasi, etc.) | All Romania |
| `maxResults` | Integer | Maximum number of listings to scrape (1-5,000) | `100` |
| `includeDetails` | Boolean | Visit detail pages for full descriptions, job level and remote status (slower) | `false` |
| `proxyConfiguration` | Object | Proxy settings | Apify Proxy (automatic) |

#### Example input

```json
{
    "searchQuery": "programator",
    "city": "Bucuresti",
    "maxResults": 50,
    "includeDetails": true,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
}
```

### Output

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

#### Example output

```json
{
    "jobTitle": "Reprezentant Vanzari Dispozitive Medicale Export",
    "company": "Vetro Design",
    "cities": "BUCURESTI",
    "domains": "Farmacie - Medicina, Import-Export, Vanzari",
    "jobType": "full-time",
    "jobLevel": "Student/Absolvent",
    "remoteWork": "On-site",
    "salary": "",
    "postedDate": "17-03-2026",
    "jobDescription": "Scurta descriere a companiei\nCompania noastra este un principal importator, distribuitor si exportator de dispozitive medicale...",
    "url": "https://www.hipo.ro/locuri-de-munca/locuri_de_munca/100809/Vetro-Design/Reprezentant-Vanzari-Dispozitive-Medicale-Export",
    "sourceId": "100809",
    "scrapedAt": "2026-09-02T12:00:00.000Z"
}
```

### Data fields

| Field | Description |
|-------|-------------|
| `jobTitle` | Job position title |
| `company` | Hiring company name |
| `cities` | City or cities where the job is located |
| `domains` | Job domain(s) / category (e.g. IT-Software, Inginerie) |
| `jobType` | Employment type (full-time, part-time, etc.) |
| `jobLevel` | Seniority / experience level -- only populated with `includeDetails` |
| `remoteWork` | On-site, Remote or Hybrid -- only populated with `includeDetails` |
| `salary` | Salary if disclosed in the listing (RON or EUR); most Romanian listings omit it |
| `postedDate` | Date the listing was last updated (DD-MM-YYYY) |
| `jobDescription` | Company description, requirements, responsibilities and benefits -- only populated with `includeDetails` |
| `url` | Direct link to the job listing on Hipo.ro |
| `sourceId` | Hipo.ro internal job ID |
| `scrapedAt` | ISO 8601 timestamp of data collection |

### How much does it cost to scrape Hipo.ro?

The Hipo.ro Scraper is a lightweight HTTP scraper (no headless browser required) -- Hipo.ro renders its job listings server-side, so plain HTTP requests are enough for reliable extraction. It's billed pay-per-result: $0.005 per run start plus $0.002 per result. A 100-listing run costs about $0.21; a 1,000-listing run about $2.01. Enabling `includeDetails` adds one extra request per job (for the full description), so cost scales with page count rather than just item 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

- **Use Romanian keywords** for broader results -- most listings are in Romanian only (e.g. "programator" instead of "programmer", "inginer" instead of "engineer", "contabil" instead of "accountant").
- **Enable `includeDetails`** only when you need full job descriptions, job level or remote-work status. It's slower because it visits each job page individually.
- **Set `maxResults`** to control costs. Start small (10-50) to verify the output, then scale up.
- **Domain filtering** covers 20 Hipo.ro categories: IT / Software, IT / Hardware, Engineering, Accounting / Finance, Marketing, Sales, Internship, Management Trainee, Customer Support, HR, Legal, Production, Procurement / Logistics, Pharma / Medical, Education, Construction, Banking, Internet / eCommerce, Media / Journalism, Hotels / Restaurants.
- **City filtering** supports all major Romanian cities: Bucuresti, Cluj-Napoca, Timisoara, Iasi, Constanta, Brasov, Craiova, Galati, Oradea, Ploiesti, Sibiu, Arad, Pitesti, Bacau and more.
- **Schedule runs** to track new graduate and IT job listings daily or weekly using Apify's built-in scheduler.
- **Combine with other scrapers** to build a comprehensive Romanian job market dataset -- check our eJobs.ro scraper for the broader general job market alongside Hipo.ro's graduate and IT focus.

### Supported cities

Bucuresti (Bucharest), Cluj-Napoca, Timisoara, Iasi, Constanta, Brasov, Craiova, Galati, Oradea, Ploiesti, Sibiu, Arad, Pitesti, Bacau, and all other Romanian cities (pass the city name directly).

### Supported domains

IT / Software, IT / Hardware, Engineering, Accounting / Finance, Marketing, Sales, Internship, Management Trainee, Customer Support, Human Resources, Legal, Production, Procurement / Logistics, Pharma / Medical, Education / Training, Construction, Banking, Internet / eCommerce, Media / Journalism, and Hotels / Restaurants.

### FAQ and support

#### Is it legal to scrape Hipo.ro?

This scraper extracts only publicly available job listing 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 or domain matches actual job listings currently live on Hipo.ro.
- Try a broader domain, or remove the city filter.
- Hipo.ro occasionally runs scheduled maintenance windows during which the whole site returns a "momentan indisponibil" (temporarily unavailable) notice with an HTTP 200 status -- this is a site outage, not a block. The scraper detects this page and fails clearly rather than silently returning empty data; simply retry once the site is back.

#### 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?

Hipo.ro updates listings continuously. For most use cases, running once daily or weekly is sufficient. Use Apify's scheduler to automate recurring runs.

# Actor input Schema

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

Job search keyword (e.g. 'programator', 'inginer', 'contabil', 'marketing'). Matched against job titles and companies. Defaults to 'programator' if empty.

## `category` (type: `string`):

Job domain filter (Hipo.ro calls this 'Domeniu'). Leave empty to search across all domains.

## `city` (type: `string`):

City name (e.g. 'Bucuresti', 'Cluj-Napoca', 'Timisoara', 'Iasi'). Leave empty for all Romania (Toate Orasele).

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

Maximum number of job listings to scrape.

## `includeDetails` (type: `boolean`):

Visit each job detail page to extract the full description (company info, requirements, responsibilities, benefits) and richer metadata (job level, remote status). Slower but provides much richer data.

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

Proxy settings for scraping Hipo.ro.

## Actor input object example

```json
{
  "searchQuery": "programator",
  "category": "",
  "maxResults": 5,
  "includeDetails": false,
  "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 = {
    "searchQuery": "programator",
    "maxResults": 5,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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