# Robota.ua Scraper (`solidcode/robota-ua-scraper`) Actor
\[💰 $1.8 / 1K] Extract job listings from robota.ua, Ukraine's largest job board. Search by keyword and location, filter by experience, work schedule, salary, and remote work, and get structured jobs with titles, companies, salaries, descriptions, contacts, and apply links.
- **URL**: https://apify.com/solidcode/robota-ua-scraper.md
- **Developed by:** [SolidCode](https://apify.com/solidcode) (community)
- **Categories:** Jobs, Automation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet
## Pricing
from $1.80 / 1,000 results
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 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
## Robota.ua Scraper
Pull job listings from robota.ua — Ukraine's largest job board — at scale: titles, employers, salary ranges in UAH, work schedules, full descriptions, required skills, recruiter contacts, and map coordinates for every vacancy. Search by keyword and city, narrow with filters, or paste robota.ua URLs directly and let the data come to you as clean, structured rows. Built for Ukrainian recruiters, HR-tech platforms, and labor-market analysts who need fresh robota.ua vacancy data without copy-pasting listings one page at a time.
### Why This Scraper?
- **37 structured fields per vacancy** — every job is flattened into one tidy row: title, company, salary, schedule, location, geo, description, skills, contacts, apply link, and posting date.
- **9 work-schedule filters** — full-time, part-time, remote, internship, project-based, seasonal/temporary, shift work, hybrid, and on-site, each selectable by name (no numeric IDs to look up).
- **Salary ranges in UAH with min/max** — parsed `salaryMin` and `salaryMax` in Ukrainian hryvnia, plus a `salaryHidden` flag so you can separate disclosed pay from "salary on request".
- **Map coordinates on every located job** — latitude and longitude, plus city, district, and nearest metro station, ready to plot or geo-filter.
- **Full descriptions in text and HTML** — both a clean plain-text version and the original formatted HTML, alongside listed skills and listing badges.
- **Recruiter contacts extracted for you** — contact person, phone, and email, plus any emails, phones, and social profiles (LinkedIn, Telegram, Viber, Facebook) pulled straight from the listing.
- **Keyword + city search in any language** — search "developer", "менеджер", or "бухгалтер" and filter by Ukrainian city names like Kyiv, Lviv, or Odesa; each keyword runs its own search.
- **Paste robota.ua URLs directly** — drop in any search-result or individual vacancy URL and the filters baked into that link are respected exactly.
- **Deduplicated by vacancy ID** — each job is returned once even when it appears across multiple pages or overlapping keyword searches.
### Use Cases
**Recruitment & Sourcing**
- Build candidate-facing job feeds for a niche, city, or industry
- Pull recruiter contact details to reach hiring managers directly
- Track which employers are actively hiring for a given role
- Mirror a dialed-in robota.ua search and refresh it on a schedule
**Labor-Market Research**
- Map vacancy volume by city, district, and work schedule
- Measure remote vs. on-site vs. hybrid demand across Ukraine
- Track entry-level hiring with the no-experience filter
- Spot which skills employers ask for most in a profession
**Salary Benchmarking**
- Compile UAH salary ranges by role and region
- Compare disclosed vs. undisclosed pay across employers
- Benchmark min/max offers for a job title over time
- Feed compensation models with structured salary data
**Job-Board Aggregation**
- Power a vertical job aggregator or meta-search with fresh listings
- Sync new vacancies into your own database or ATS
- Keep a curated board updated with deduplicated postings
**Lead Generation for HR-Tech**
- Identify companies posting many roles as outreach targets
- Capture verified-employer signals for account scoring
- Build prospect lists of actively hiring organizations
### Getting Started
#### Search by Keyword
The simplest run — one keyword across all of Ukraine:
```json
{
"keywords": ["developer"],
"maxResults": 100
}
````
#### Keyword + City with Filters
Remote developer roles in Kyiv paying at least 50,000 UAH:
```json
{
"keywords": ["developer", "data analyst"],
"location": "Kyiv",
"employmentType": ["remote"],
"minSalary": 50000,
"maxResults": 200
}
```
#### Paste robota.ua URLs
Already have a search tuned on the website? Paste the link — search and vacancy URLs both work:
```json
{
"startUrls": [
"https://robota.ua/zapros/developer/ukraine",
"https://robota.ua/company123456/vacancy7654321"
],
"includeDescription": true,
"maxResults": 300
}
```
### Input Reference
#### Search
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `keywords` | array | `["developer"]` | Job titles, roles, or keywords to search for (e.g. "developer", "менеджер", "accountant"). Each keyword runs its own search. Up to 50 per run. |
| `location` | string | `""` | City or region to search in (e.g. "Kyiv", "Lviv", "Odesa"). Leave empty to search all of Ukraine. |
| `startUrls` | array | `[]` | Paste full robota.ua search-result or individual vacancy URLs to collect them directly. Any filters baked into the URL are respected. Up to 50 per run. |
#### Filters & Limits
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `noExperienceOnly` | boolean | `false` | When on, only show jobs open to candidates with no prior experience (entry-level roles). |
| `employmentType` | array | `[]` | Only return jobs with these work schedules: Full-time, Part-time, Remote, Internship, Project-based, Seasonal / Temporary, Shift work, Hybrid, On-site. Leave empty for all. |
| `remoteOnly` | boolean | `false` | Only show jobs that can be done remotely. |
| `minSalary` | integer | `null` | Only show jobs offering at least this monthly salary in UAH. Jobs without a disclosed salary are excluded when this is set. |
| `maxResults` | integer | `100` | Maximum listings to collect per keyword (or per start URL). Set to 0 to collect all available results. |
| `onlyUniqueJobs` | boolean | `true` | Return each job once even if it appears across several pages or searches. Deduplicates by vacancy ID. |
#### Output
| Parameter | Type | Default | Description |
|-----------|------|---------|-------------|
| `includeDescription` | boolean | `true` | Include the full job description (text and HTML), plus contact info, skills, industry, geo, and company verification from each vacancy page. Turn off for lighter, faster records — note the description-only fields (including `industry`, `companyUrl`, `companyVerified`, contacts and geo) are empty when off. |
### Output
Each job is one flat row. Example (trimmed for readability):
```json
{
"jobId": "7654321",
"title": "Python Developer",
"company": "Tech Solutions LLC",
"companyId": "123456",
"companyUrl": "https://robota.ua/company123456",
"companyVerified": true,
"industry": "IT, computers, internet",
"location": "Kyiv",
"city": "Kyiv",
"district": "Pecherskyi",
"metro": "Pecherska",
"address": "vul. Khreshchatyk, 1",
"latitude": 50.4501,
"longitude": 30.5234,
"salary": "60000-90000 UAH",
"salaryMin": 60000,
"salaryMax": 90000,
"salaryCurrency": "UAH",
"salaryHidden": false,
"employmentType": "Full-time, Remote",
"experienceLevel": null,
"isRemote": true,
"isHot": true,
"description": "We are looking for an experienced Python developer...",
"descriptionHtml": "We are looking for an experienced Python developer...
",
"skills": ["Python", "Django", "PostgreSQL"],
"badges": ["Verified employer"],
"contactPerson": "Olena Koval",
"contactPhone": "+380 67 123 4567",
"contactEmail": "hr@techsolutions.ua",
"extractedEmails": ["hr@techsolutions.ua"],
"extractedPhones": ["+380 67 123 4567"],
"socialProfiles": { "telegram": "https://t.me/techsolutions_hr" },
"applyUrl": "https://robota.ua/company123456/vacancy7654321",
"jobUrl": "https://robota.ua/company123456/vacancy7654321",
"postedDate": "2026-06-10T09:30:00Z",
"searchQuery": "developer",
"scrapedAt": "2026-06-13T12:00:00Z"
}
```
#### Core Fields
| Field | Type | Description |
|-------|------|-------------|
| `jobId` | string | robota.ua vacancy ID (the deduplication key). |
| `title` | string | Vacancy title. |
| `employmentType` | string | Work schedule(s), e.g. "Full-time, Remote". |
| `experienceLevel` | string | Required experience band (not published by robota.ua; always empty). |
| `isRemote` | boolean | True when the job can be done remotely. |
| `isHot` | boolean | True for "hot" / featured listings. |
| `postedDate` | string | Publication date (ISO timestamp when available). |
| `searchQuery` | string | The keyword or URL that produced this row. |
| `scrapedAt` | string | ISO timestamp of when the row was collected. |
#### Company
| Field | Type | Description |
|-------|------|-------------|
| `company` | string | Employer / company name. |
| `companyId` | string | Company ID on robota.ua. |
| `companyUrl` | string | Company profile URL. |
| `companyVerified` | boolean | Whether the employer is verified. |
| `industry` | string | Employer's industry / job category (e.g. "IT, computers, internet"). Populated when full descriptions are fetched. |
#### Salary
| Field | Type | Description |
|-------|------|-------------|
| `salary` | string | Human-readable salary label (e.g. "60000-90000 UAH"). |
| `salaryMin` | number | Parsed minimum salary. |
| `salaryMax` | number | Parsed maximum salary. |
| `salaryCurrency` | string | Currency (UAH when an amount is disclosed). |
| `salaryHidden` | boolean | True when the salary is not disclosed. |
#### Location & Geo
| Field | Type | Description |
|-------|------|-------------|
| `location` | string | Free-text location label for the job. |
| `city` | string | City name. |
| `district` | string | District (raion) when present. |
| `metro` | string | Nearest metro station when present. |
| `address` | string | Street address when present. |
| `latitude` | number | Latitude when present. |
| `longitude` | number | Longitude when present. |
#### Description & Skills
| Field | Type | Description |
|-------|------|-------------|
| `description` | string | Full job description in plain text. |
| `descriptionHtml` | string | Full job description in original HTML. |
| `skills` | array | Listed skills and tags. |
| `badges` | array | Listing badges (e.g. verified employer). |
#### Contacts & Links
| Field | Type | Description |
|-------|------|-------------|
| `contactPerson` | string | Recruiter / contact name when present. |
| `contactPhone` | string | Contact phone when present. |
| `contactEmail` | string | Contact email when present. |
| `extractedEmails` | array | Emails found in the listing. |
| `extractedPhones` | array | Phone numbers found in the listing. |
| `socialProfiles` | object | Detected social links (LinkedIn, Telegram, Viber, Facebook, etc.). |
| `applyUrl` | string | Apply / "respond" URL. |
| `jobUrl` | string | Canonical vacancy URL. |
### Tips for Best Results
- **Spell Ukrainian city names the way robota.ua shows them.** Both "Kyiv" and the Cyrillic "Київ" resolve, as do "Lviv"/"Львів" and "Odesa"/"Одеса" — but a misspelled city quietly falls back to all of Ukraine.
- **Mirror a tuned website search with `startUrls`.** Set your filters on robota.ua, copy the address-bar URL, and paste it in — schedule and experience filters baked into the link are honored exactly.
- **Setting `minSalary` hides "salary on request" jobs.** A salary floor excludes every listing that doesn't disclose pay, so leave it empty if you want undisclosed-salary postings too.
- **Turn off `includeDescription` for fast, lightweight runs.** When you only need titles, companies, locations, salaries, and apply links, skipping the full description makes each run faster and leaner.
- **Use multiple keywords to cover synonyms.** "developer", "розробник", and "програміст" surface different listings; add them all and `onlyUniqueJobs` keeps the merged result clean.
- **Set `maxResults` to 0 to sweep an entire search.** Useful for full market snapshots; the run stops once a search is exhausted.
- **Filter for entry-level talent with `noExperienceOnly`.** robota.ua offers a single no-experience flag rather than graduated bands, so this is the way to isolate junior and internship-friendly roles.
### Pricing
**From $1.80 per 1,000 results** — flat, pay-only-for-what-you-collect pricing that undercuts comparable robota.ua data tools. Bronze, Silver, and Gold subscribers pay progressively less; the table below shows total cost at each discount tier.
| Results | No discount | Bronze | Silver | Gold |
|---------|-------------|--------|--------|------|
| 100 | $0.22 | $0.20 | $0.19 | $0.18 |
| 1,000 | $2.15 | $2.00 | $1.90 | $1.80 |
| 10,000 | $21.50 | $20.00 | $19.00 | $18.00 |
| 100,000 | $215.00 | $200.00 | $190.00 | $180.00 |
A "result" is one job row pushed to your dataset. No compute or time-based charges — you pay per result, plus a small fixed per-run start fee.
### Integrations
Export data in JSON, CSV, Excel, XML, or RSS. Connect to 1,500+ apps via:
- **Zapier** / **Make** / **n8n** — Workflow automation
- **Google Sheets** — Direct spreadsheet export
- **Slack** / **Email** — Notifications on new results
- **Webhooks** — Trigger custom workflows on run completion
- **Apify API** — Full programmatic access
### Legal & Ethical Use
This scraper collects publicly available job-listing data for legitimate business purposes such as recruitment, market research, and analytics. You are responsible for using the collected data in compliance with robota.ua's terms of service, applicable data-protection laws (including the GDPR where it applies), and any restrictions on processing personal data such as recruiter contact details. Use the data responsibly, respect individuals' privacy, and do not use it for spam or unsolicited outreach that violates local regulations.
# Actor input Schema
## `keywords` (type: `array`):
Job titles, roles, or keywords to search for, such as 'developer', 'менеджер', or 'accountant'. Each keyword runs its own search. Leave empty to collect the broadest result set for the chosen location and filters. Up to 50 keywords per run.
## `location` (type: `string`):
City or region to search in, such as 'Kyiv', 'Lviv', or 'Odesa'. Matches what you would type into robota.ua's location box. Leave empty to search all of Ukraine.
## `startUrls` (type: `array`):
Paste full robota.ua search-result or individual vacancy URLs (e.g. https://robota.ua/zapros/developer/ukraine) to scrape them directly. Useful when you already have a search dialed in on the website — any filters baked into the URL are respected. Up to 50 URLs per run.
## `noExperienceOnly` (type: `boolean`):
When on, only show jobs open to candidates with no prior experience (entry-level roles). robota.ua does not offer graduated experience bands, so this is an on/off entry-level filter. Leave off to include jobs at every experience level.
## `employmentType` (type: `array`):
Only return jobs with these work schedules. Leave empty to include all types.
## `remoteOnly` (type: `boolean`):
Only show jobs that can be done remotely.
## `minSalary` (type: `integer`):
Only show jobs offering at least this monthly salary, in Ukrainian hryvnia (UAH). Leave empty for no salary floor. Jobs that do not disclose a salary are excluded when this is set.
## `maxResults` (type: `integer`):
Maximum number of job listings to collect per keyword (or per start URL). Set to 0 to collect all available results across pagination. Results are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return up to a full page more than you asked for. Listings repeated across pages are deduplicated, so the final count can also run slightly below your cap.
## `onlyUniqueJobs` (type: `boolean`):
When on, each job is returned once even if robota.ua lists it across several pages or searches. Deduplicates by the vacancy ID. Turn off to keep every copy.
## `includeDescription` (type: `boolean`):
Include the full job description text and HTML for each listing, plus contact info, skills, industry, geo, and company verification from the vacancy page. Leave on for the most complete data. Turn off for lighter, faster records when you only need titles, companies, locations, salaries, and apply links from the results list. Note: the description-only fields (description, descriptionHtml, skills, contacts, industry, district/metro/address, latitude/longitude, companyUrl and companyVerified) are empty when this is off — companyVerified reads false then because the verification flag isn't fetched, not because the employer is unverified.
## Actor input object example
```json
{
"keywords": [
"developer"
],
"startUrls": [],
"noExperienceOnly": false,
"employmentType": [],
"remoteOnly": false,
"maxResults": 100,
"onlyUniqueJobs": true,
"includeDescription": true
}
```
# Actor output Schema
## `overview` (type: `string`):
Table of scraped job listings with key fields like title, company, location, salary, and posting date.
## `detail` (type: `string`):
Complete job data including full descriptions, parsed salary fields, company block, geo, skills, contacts, and metadata.
# 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 '' with your token
const client = new ApifyClient({
token: '',
});
// Prepare Actor input
const input = {
"keywords": [
"developer"
],
"location": "",
"startUrls": [],
"noExperienceOnly": false,
"employmentType": [],
"remoteOnly": false,
"maxResults": 100,
"onlyUniqueJobs": true,
"includeDescription": true
};
// Run the Actor and wait for it to finish
const run = await client.actor("solidcode/robota-ua-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 '' with your token.
client = ApifyClient("")
# Prepare the Actor input
run_input = {
"keywords": ["developer"],
"location": "",
"startUrls": [],
"noExperienceOnly": False,
"employmentType": [],
"remoteOnly": False,
"maxResults": 100,
"onlyUniqueJobs": True,
"includeDescription": True,
}
# Run the Actor and wait for it to finish
run = client.actor("solidcode/robota-ua-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 '{
"keywords": [
"developer"
],
"location": "",
"startUrls": [],
"noExperienceOnly": false,
"employmentType": [],
"remoteOnly": false,
"maxResults": 100,
"onlyUniqueJobs": true,
"includeDescription": true
}' |
apify call solidcode/robota-ua-scraper --silent --output-dataset
```
## MCP server setup
```json
{
"mcpServers": {
"apify": {
"command": "npx",
"args": [
"mcp-remote",
"https://mcp.apify.com/?tools=solidcode/robota-ua-scraper",
"--header",
"Authorization: Bearer "
]
}
}
}
```
## OpenAPI specification
```json
{
"openapi": "3.0.1",
"info": {
"title": "Robota.ua Scraper",
"description": "[💰 $1.8 / 1K] Extract job listings from robota.ua, Ukraine's largest job board. Search by keyword and location, filter by experience, work schedule, salary, and remote work, and get structured jobs with titles, companies, salaries, descriptions, contacts, and apply links.",
"version": "1.0",
"x-build-id": "RyYux2Z6PBJDIhU0n"
},
"servers": [
{
"url": "https://api.apify.com/v2"
}
],
"paths": {
"/acts/solidcode~robota-ua-scraper/run-sync-get-dataset-items": {
"post": {
"operationId": "run-sync-get-dataset-items-solidcode-robota-ua-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/solidcode~robota-ua-scraper/runs": {
"post": {
"operationId": "runs-sync-solidcode-robota-ua-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/solidcode~robota-ua-scraper/run-sync": {
"post": {
"operationId": "run-sync-solidcode-robota-ua-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": {
"keywords": {
"title": "Search Keywords",
"maxItems": 50,
"type": "array",
"description": "Job titles, roles, or keywords to search for, such as 'developer', 'менеджер', or 'accountant'. Each keyword runs its own search. Leave empty to collect the broadest result set for the chosen location and filters. Up to 50 keywords per run.",
"items": {
"type": "string"
}
},
"location": {
"title": "Location",
"type": "string",
"description": "City or region to search in, such as 'Kyiv', 'Lviv', or 'Odesa'. Matches what you would type into robota.ua's location box. Leave empty to search all of Ukraine."
},
"startUrls": {
"title": "Direct robota.ua URLs",
"maxItems": 50,
"type": "array",
"description": "Paste full robota.ua search-result or individual vacancy URLs (e.g. https://robota.ua/zapros/developer/ukraine) to scrape them directly. Useful when you already have a search dialed in on the website — any filters baked into the URL are respected. Up to 50 URLs per run.",
"items": {
"type": "string"
}
},
"noExperienceOnly": {
"title": "Only entry-level / no-experience jobs",
"type": "boolean",
"description": "When on, only show jobs open to candidates with no prior experience (entry-level roles). robota.ua does not offer graduated experience bands, so this is an on/off entry-level filter. Leave off to include jobs at every experience level.",
"default": false
},
"employmentType": {
"title": "Work Schedule",
"uniqueItems": true,
"type": "array",
"description": "Only return jobs with these work schedules. Leave empty to include all types.",
"items": {
"type": "string",
"enum": [
"full_time",
"part_time",
"remote",
"internship",
"project",
"seasonal",
"shift_work",
"hybrid",
"on_site"
],
"enumTitles": [
"Full-time",
"Part-time",
"Remote",
"Internship",
"Project-based",
"Seasonal / Temporary",
"Shift work",
"Hybrid",
"On-site"
]
},
"default": []
},
"remoteOnly": {
"title": "Remote Jobs Only",
"type": "boolean",
"description": "Only show jobs that can be done remotely.",
"default": false
},
"minSalary": {
"title": "Minimum Salary (UAH)",
"minimum": 0,
"type": "integer",
"description": "Only show jobs offering at least this monthly salary, in Ukrainian hryvnia (UAH). Leave empty for no salary floor. Jobs that do not disclose a salary are excluded when this is set."
},
"maxResults": {
"title": "Max Results per Search",
"minimum": 0,
"type": "integer",
"description": "Maximum number of job listings to collect per keyword (or per start URL). Set to 0 to collect all available results across pagination. Results are fetched in pages: the actor stops once your cap is reached but always keeps the whole final page, so a small cap can return up to a full page more than you asked for. Listings repeated across pages are deduplicated, so the final count can also run slightly below your cap.",
"default": 100
},
"onlyUniqueJobs": {
"title": "Only Unique Jobs",
"type": "boolean",
"description": "When on, each job is returned once even if robota.ua lists it across several pages or searches. Deduplicates by the vacancy ID. Turn off to keep every copy.",
"default": true
},
"includeDescription": {
"title": "Fetch Full Job Descriptions",
"type": "boolean",
"description": "Include the full job description text and HTML for each listing, plus contact info, skills, industry, geo, and company verification from the vacancy page. Leave on for the most complete data. Turn off for lighter, faster records when you only need titles, companies, locations, salaries, and apply links from the results list. Note: the description-only fields (description, descriptionHtml, skills, contacts, industry, district/metro/address, latitude/longitude, companyUrl and companyVerified) are empty when this is off — companyVerified reads false then because the verification flag isn't fetched, not because the employer is unverified.",
"default": 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
}
}
}
}
}
}
}
}
}
}
```