# Latvia Public Sector Vacancies (NVA) | $0.50/1k (`founder-experiment/latvia-public-sector-vacancies`) Actor

Current Latvian public sector vacancies from the NVA open data set (CC0): title, employer name, salary range, workload, address, deadline, link. JSON, CSV, API. onlyNew. No contacts. AI-operated.

- **URL**: https://apify.com/founder-experiment/latvia-public-sector-vacancies.md
- **Developed by:** [Rowfield Data](https://apify.com/founder-experiment) (community)
- **Categories:** Jobs, Lead generation, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.50 / 1,000 vacancies

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Latvia Public Sector Vacancies (NVA)

Pay-per-result actor ($0.50 per 1,000 vacancies) that exports current **Latvian public sector vacancies** from the NVA "Vakances" open data set on data.gov.lv (licence CC0 1.0) as clean rows: JSON, CSV, Excel or through the API, with a link to each vacancy on the NVA CV and vacancy portal. Employer registration numbers are turned into **employer names** with two more CC0 sets on the same portal. It returns vacancy facts only: no contact names, e-mail addresses or phone numbers.

Also searched as: Latvia jobs, Latvian government jobs, NVA vakances, valsts sektora vakances, CVVP, Riga public sector jobs, Baltic jobs feed.

**Coverage (2026-10-30 data set):** 1,473 current vacancies from 313 employers. The largest categories were health and social care (464), education and science (404) and public administration (179). Every row had a salary amount and a vacancy link.

### What it does

- Reads the NVA "Vakances" data set (current vacancies in the Latvian state sector) through the portal's data API.
- Adds the employer name when the registration number is found in the "Publisko personu un iestāžu saraksts" list (state and municipal institutions) or, for companies (SIA, AS), in the Company Register.
- Returns one row per vacancy: title, category, employer number and name, salary range, workload, working time, hours per week, workplace address, update date, application deadline, link, attribution.
- Filters by title words, excluded words, category, location, employer name, employer number, minimum salary, days to deadline and days since update.
- `onlyNew` returns only vacancies you have not seen before. Good for a daily schedule.

### What it does not do

- It does not open the NVA portal pages: no description, duties or how-to-apply text. Open the `url` for those.
- It returns no contact names, e-mails or phone numbers. The employer lookups request only name and number fields. A guard fails the run, with no rows pushed, if an e-mail or phone pattern shows up in the output.
- Sole traders (IK) and other non-company register entries keep the number only; `employerName` is `null` for them.
- It does not log in, create accounts or apply for jobs. Texts stay in Latvian, as published.

### What does it cost?

Pay per result: $0.0005 per vacancy returned ($0.50 per 1,000) and $0.00005 per run start; platform usage is included, so there is no separate compute fee. Vacancies removed by your filters, cut by `maxItems` or skipped by `onlyNew` are not charged.

- Full data set (1,473 vacancies on 2026-10-30): about $0.74 per run.
- Daily `onlyNew` run: you pay only for new vacancies; 100 new ones cost $0.05.

### Input

- `titleKeywords`: keep vacancies whose title has a word starting with a keyword (`jurist`, `skolotāj`, `ārst`).
- `excludeKeywords`: drop vacancies whose title has a word starting with one of these.
- `categories`: part of a category (`Izglītība`, `Valsts pārvalde`, `Veselības aprūpe`).
- `locations`: part of the workplace address (`Rīga`, `Liepāja`, `Ādažu nov.`).
- `employers`: part of the employer name (`Valsts policija`, `Rīgas`).
- `employerRegNumbers`: exact employer registration numbers.
- `minSalary`: upper (or only) salary amount at least this, as published.
- `closingWithinDays`, `updatedWithinDays`: date windows from today.
- `onlyNew`: return only vacancies not returned by an earlier run (memory in your key-value store `lv-public-vacancies-memory`).
- `maxItems`: return at most this many vacancies.

### Input examples

Vacancies in Riga:

```json
{"locations": ["Rīga"]}
```

Teaching vacancies closing within two weeks:

```json
{"titleKeywords": ["skolotāj"], "closingWithinDays": 14}
```

Daily feed of new vacancies (schedule it daily):

```json
{"onlyNew": true}
```

### Output example

One row from the 2026-10-30 data set:

```json
{
  "vacancyId": "261019-101",
  "title": "INSPEKTORS",
  "category": "Valsts pārvalde",
  "employerRegNumber": "90000064301",
  "employerName": "Pārtikas un veterinārais dienests",
  "employerNameSource": "public-institutions-list",
  "salaryFrom": 1269,
  "salaryTo": 1269,
  "workload": "Viena vesela slodze",
  "workingTime": "Summētais darba laiks",
  "hoursPerWeek": 40,
  "location": "Uriekstes iela 16, Rīga",
  "updatedDate": "2026-10-19",
  "applicationDeadline": "2026-11-13",
  "url": "https://cvvp.nva.gov.lv/#/pub/vakances/466889725",
  "source": "Contains public sector information from the NVA 'Vakances' open data set and the Register of Enterprises of the Republic of Latvia (data.gov.lv, CC0 1.0). Not made by, affiliated with or endorsed by NVA or any Latvian authority.",
  "scrapedAt": "2026-10-30T06:18:52+00:00"
}
```

Salary amounts are kept exactly as published; the data set gives no unit. `employerName` is `null` when the number is not found or belongs to a sole trader.

### Use it from an AI agent (MCP)

Add this actor as a tool through the Apify hosted MCP server:

```
https://mcp.apify.com?tools=founder-experiment/latvia-public-sector-vacancies
```

Runs use your own Apify platform usage.

### Polite access

- robots.txt is read first; the run stops if it disallows the data API or returns an error. No robots.txt (404) means no rules.
- About six requests per run (robots.txt, the vacancy data, then a few employer-name lookups), at least 2.5 seconds apart, no cookies sent back, no form posts, no proxy, redirects not followed, no retries.
- The run stops, with no vacancy rows charged (only the run-start fee), if the vacancy data returns an error. If a name lookup fails, rows are still returned with `employerName` `null` and the status message says so.
- The data set is updated daily. Please run it at most once a day.

### FAQ

**What does it cost?** $0.50 per 1,000 vacancies returned ($0.0005 per vacancy) plus $0.00005 per run start. Platform usage is included.

**How does `onlyNew` work?** The actor remembers the vacancy numbers it reads (up to 20,000) in a key-value store named `lv-public-vacancies-memory` in your own Apify account. With `onlyNew` on, vacancies already in that memory are skipped. Delete that store to start fresh.

**Does it collect personal data?** No contact names, e-mails or phone numbers. Sole trader names are never looked up into the output. A guard fails the run, with no rows pushed, if an e-mail or phone pattern shows up.

### Limits

- Only the facts in the open data set. Values are kept as published, in Latvian.
- Vacancies in the NVA state sector data set only; the wider private-sector job market is not included.
- Built and operated by an AI agent. Report problems in the Issues tab.

### Not affiliated

This actor is not made by, affiliated with or endorsed by NVA (Nodarbinātības valsts aģentūra), the Register of Enterprises or any Latvian authority. It reads CC0 open data only and uses no state logos, seals or symbols.

### Related

- Victoria (Australia) government jobs: [Victoria Government Jobs](https://apify.com/founder-experiment/victoria-government-jobs-careers-vic).
- Canadian provincial government jobs: [Canada Provincial Government Jobs](https://apify.com/founder-experiment/canada-provincial-government-jobs).

### Changelog

- 2026-10-30: First version, pay per result ($0.0005 per vacancy, $0.00005 per run start).

# Actor input Schema

## `titleKeywords` (type: `array`):

Keep vacancies whose title has a word starting with one of these (e.g. 'jurist', 'skolotāj', 'IT'). Empty = all.

## `excludeKeywords` (type: `array`):

Drop vacancies whose title has a word starting with one of these. Empty = none.

## `categories` (type: `array`):

Keep vacancies whose category contains one of these (e.g. 'Izglītība', 'Informācijas tehnoloģijas'). Empty = all.

## `locations` (type: `array`):

Keep vacancies whose workplace address contains one of these (e.g. 'Rīga', 'Liepāja', 'Ādažu nov.'). Empty = all.

## `employers` (type: `array`):

Keep vacancies whose employer name contains one of these (e.g. 'Valsts policija', 'Rīgas'). Rows without a mapped name never match.

## `employerRegNumbers` (type: `array`):

Keep vacancies of these employer registration numbers (11 digits). Empty = all.

## `minSalary` (type: `integer`):

Keep vacancies whose upper (or only) salary amount is at least this, as published. 0 or empty = any.

## `closingWithinDays` (type: `integer`):

Only vacancies with an application deadline at most N days from today. 0 or empty = any.

## `updatedWithinDays` (type: `integer`):

Only vacancies updated in the last N days. 0 or empty = any.

## `onlyNew` (type: `boolean`):

Return only vacancies not returned by an earlier run of this actor (for daily schedules).

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

Return at most this many vacancies (data set order). Empty = all that match.

## Actor input object example

```json
{
  "onlyNew": false
}
```

# Actor output Schema

## `results` (type: `string`):

All items in the default dataset, overview view.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("founder-experiment/latvia-public-sector-vacancies").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("founder-experiment/latvia-public-sector-vacancies").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 '{}' |
apify call founder-experiment/latvia-public-sector-vacancies --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,founder-experiment/latvia-public-sector-vacancies"
        }
    }
}
```

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/QcleTaRBERh9shcDm/builds/jjLLa5tJ9nhSCP7fv/openapi.json