# CVVP Latvia Scraper - NVA Employment Service Vacancies (`studio-amba/cvvp-nva-scraper`) Actor

Scrape job vacancies from CVVP (cvvp.nva.gov.lv), Latvia's national public employment service run by NVA (Nodarbinatibas valsts agentura). Search by keyword. Extract titles, employers, salary, location, employment type, and full job descriptions. No login required.

- **URL**: https://apify.com/studio-amba/cvvp-nva-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/platform/actors/running/actors-in-store#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 CVVP Latvia Scraper do?

**CVVP Latvia Scraper** extracts job vacancies from [CVVP](https://cvvp.nva.gov.lv) (CV un Vakanču Portāls), the official job vacancy portal run by NVA (Nodarbinātības valsts aģentūra) — Latvia's national public employment service (PES). This actor collects job titles, employers, salary ranges, workplace addresses, and — optionally — the full job description text, salary type (hourly vs monthly), employment regime, workload, field of work, and the hiring contact's name, email, and phone, directly from the site's own JSON REST API. No login or cookies required.

Use it on the Apify platform to get structured Latvian labour-market data via API, schedule recurring scrapes, and integrate with tools like Zapier, Make, Google Sheets, and Slack.

### How to scrape Latvia job vacancy data

1. Go to the CVVP Latvia Scraper on the Apify Store.
2. Click **Try for free** to open the actor in the Apify Console.
3. Enter a Latvian-language job keyword (e.g. "pārdevējs", "vadītājs", "grāmatvedis") or leave it empty to browse all current active vacancies nationwide, newest first.
4. Set the maximum number of results you want.
5. Optionally toggle off "Fetch Full Description" if you only need the search-result summary (faster, fewer requests).
6. Click **Start** and wait for the run to finish.
7. Download your data as JSON, CSV, Excel, or HTML from the Output tab.

### Why use CVVP Latvia Scraper?

- **Recruitment and hiring** — Monitor vacancies registered with Latvia's public employment service to understand hiring trends by region, occupation, and salary.
- **Labor market analysis** — Track which occupations and regions have the most open positions, which employers are hiring most actively, and how gross salary ranges compare across sectors.
- **Lead generation** — Every vacancy includes the employer name and, when enabled, a direct hiring-contact email and phone — a clean data source for B2B/recruitment outreach.
- **Salary transparency data** — CVVP publishes an explicit gross salary range (or single figure) for nearly every posting, parsed here into numeric `salaryFrom`/`salaryTo` fields — useful for compensation benchmarking research that most EU job boards don't expose.
- **Academic and public-policy research** — Gather structured Latvian labour-market data straight from the official employment service registry, including employment regime, workload, and field of work.

### Input

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| `searchQuery` | String | No | Latvian-language job keyword (e.g. "pārdevējs", "vadītājs", "grāmatvedis"). Full-text matched against the vacancy title. Leave empty to browse all current active vacancies nationwide, newest first. |
| `maxResults` | Integer | No | Maximum number of job vacancies to scrape (default: 100, max: 15000). |
| `fetchFullDescription` | Boolean | No | Fetch the full job description text, salary type, employment regime, workload, field of work, language requirements, and hiring contact name/email/phone per vacancy (default: `true`, 1 extra request per job). Disable for faster, lighter runs — this only changes how *complete* each record is, not how many records you get. |
| `proxyConfiguration` | Object | No | Proxy settings. CVVP's job API has no anti-bot protection and isn't geo-locked, so Apify's automatic/free proxy pool is used by default — no residential proxy needed. |

### Output

Each result contains structured data about a single job vacancy. You can download the dataset in various formats such as JSON, HTML, CSV, or Excel.

#### Example output

```json
{
    "vacancyId": "460684789",
    "jobTitle": "MAZUMTIRDZNIECĪBAS VEIKALA PĀRDEVĒJS",
    "vacancyNumber": "260812-66",
    "company": "Sabiedrība ar ierobežotu atbildību \"LĀČI\"",
    "address": "LATVIJA, Mazā Rencēnu iela 1, Rīga",
    "salaryFrom": 6,
    "salaryTo": 6.5,
    "salaryType": "Stundas tarifa likme",
    "currency": "EUR",
    "positionsAvailable": 2,
    "employmentRegime": "Summētais darba laiks",
    "workload": "Viena vesela slodze",
    "fieldOfWork": "Ēdināšana / Pārtikas rūpniecība",
    "languageRequirements": "Latviešu- vidējais līmenis B",
    "jobDescription": "SIA Lāči (40101006613) veikals TC \"Ozols\" ...",
    "additionalRequirements": null,
    "contactName": "Andra Lielkalne",
    "contactPhone": "25749641",
    "contactEmail": "andra.lielkalne@laci.lv",
    "startDate": "2026-08-12",
    "postedDate": "2026-08-12",
    "expiresDate": "2026-09-30",
    "remoteWork": null,
    "partiallyRemoteWork": null,
    "seasonalWork": null,
    "url": "https://cvvp.nva.gov.lv/#/pub/vakances/460684789",
    "scrapedAt": "2026-08-12T09:57:14.319Z"
}
```

### Data fields

| Field | Type | Description |
|-------|------|-------------|
| `vacancyId` | String | CVVP internal vacancy identifier |
| `jobTitle` | String | Job title / profession as registered by the employer |
| `vacancyNumber` | String | CVVP's own vacancy reference number, e.g. "260812-66" |
| `company` | String | Employer name |
| `address` | String | Workplace address |
| `salaryFrom` | Number | Lower bound of the gross salary range |
| `salaryTo` | Number | Upper bound of the gross salary range (equal to `salaryFrom` for a single fixed figure) |
| `salaryType` | String | How the salary is measured, e.g. "Stundas tarifa likme" (hourly rate). `null` usually means monthly gross (only with `fetchFullDescription`) |
| `currency` | String | Always "EUR" — Latvia is in the Eurozone |
| `positionsAvailable` | Integer | Number of open positions for this vacancy (only with `fetchFullDescription`) |
| `employmentRegime` | String | Working time regime, e.g. "Summētais darba laiks" (aggregated work time) (only with `fetchFullDescription`) |
| `workload` | String | Workload / employment share, e.g. "Viena vesela slodze" (full-time) (only with `fetchFullDescription`) |
| `fieldOfWork` | String | Industry/sector of the vacancy (only with `fetchFullDescription`) |
| `languageRequirements` | String | Language proficiency requirements as stated by the employer (only with `fetchFullDescription`) |
| `jobDescription` | String | Full job description text in Latvian, HTML tags stripped (only with `fetchFullDescription`) |
| `additionalRequirements` | String | Additional requirements text, when disclosed (only with `fetchFullDescription`) |
| `contactName` | String | Hiring contact's name, when disclosed (only with `fetchFullDescription`) |
| `contactPhone` | String | Hiring contact's phone, when disclosed (only with `fetchFullDescription`) |
| `contactEmail` | String | Hiring contact's email, when disclosed (only with `fetchFullDescription`) |
| `startDate` | String | Expected work start date, ISO 8601 (only with `fetchFullDescription`) |
| `postedDate` | String | Date the vacancy was published, ISO 8601 |
| `expiresDate` | String | Date the application period ends, ISO 8601, when set |
| `remoteWork` | Boolean | `true` when marked fully remote. `null` means not stated — never coerced to `false` (only with `fetchFullDescription`) |
| `partiallyRemoteWork` | Boolean | `true` when marked hybrid/partially remote. `null` means not stated (only with `fetchFullDescription`) |
| `seasonalWork` | Boolean | `true` when marked seasonal work. `null` means not stated (only with `fetchFullDescription`) |
| `url` | String | Direct URL to the vacancy detail page on CVVP |
| `scrapedAt` | String | ISO 8601 timestamp of when the data was collected |

### Cost estimate

This actor calls CVVP's own JSON REST API directly rather than rendering pages in a browser, so it runs fast and cheap — roughly **0.2–0.5 compute units per 1,000 results** with full description enabled (1 extra request per job), or about half that with `fetchFullDescription` off. At standard Apify pricing that's well under $0.30 per 1,000 job vacancies. As with any Apify actor, the run's usage cost only settles once the run reports SUCCEEDED — reading a mid-run/in-progress dataset understates the eventual cost.

### Tips

- Use specific job keywords to get more relevant results and reduce run time.
- Leave `searchQuery` empty to pull the newest vacancies across all of Latvia.
- Turn off `fetchFullDescription` if you only need title/company/address/salary — it roughly halves the number of requests.
- Schedule recurring runs to track new vacancies daily or weekly.
- Combine with other Baltic/Nordic PES scrapers for full regional coverage of public-sector job registries.

### Limitations

- The `searchQuery` filter matches only the vacancy title, not the full description — full-text search across the job description body is not available on this source.
- Location filtering by city/region is not exposed as an input — CVVP's own location filter resolves free text through an internal autocomplete/address-ID lookup rather than a plain query string; use the `address` output field to filter results client-side instead.
- Contact email/phone, salary type, and full description are only populated when `fetchFullDescription` is enabled, and even then some employers leave contact details or salary type blank.
- Data is scraped from the public CVVP website and may change without notice.

### Integrations

Connect CVVP Latvia Scraper with your existing tools and workflows:

- **Google Sheets** — Export vacancies directly to a spreadsheet for easy filtering and sharing.
- **Slack** — Get notified when new vacancies matching your criteria appear.
- **Zapier / Make** — Build workflows that react to new job postings in real time.
- **Custom API** — Access all results programmatically via the Apify API in JSON format.

### FAQ and support

**Is it legal to scrape CVVP?** Scraping publicly available data is generally permitted under EU law. This actor only accesses public job vacancies that require no login, via the same API the public search page uses.

**How often is the data updated?** The actor scrapes live data from CVVP each time it runs. Schedule it daily or weekly to track changes.

**Who runs CVVP?** CVVP (CV un Vakanču Portāls) is operated by NVA (Nodarbinātības valsts aģentūra), Latvia's state employment agency — the equivalent of Germany's Bundesagentur für Arbeit or France's Pôle emploi / France Travail.

**I found a bug or have a feature request.** Open an issue in the Issues tab on the actor page. You can also request a custom scraping solution.

### Need this data on a schedule, or a custom version?

We run this scraper as a managed service for businesses: scheduled runs,
deduplication, delta detection, and delivery to your inbox, Google Sheets,
or API — maintenance included. We can also build a custom version with your
exact fields and filters, or combine multiple sources into one feed.

See [studioamba.dev/services](https://studioamba.dev/services/) or email
<hello@studioamba.dev> for a free data sample.
We maintain 300+ European web scrapers and answer within one business day.

# Actor input Schema

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

Job/occupation keyword in Latvian (e.g. 'pārdevējs', 'vadītājs', 'grāmatvedis'). Matched as full-text search against the vacancy title. Leave empty to browse all current active vacancies nationwide, newest first.

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

Maximum number of job vacancies to scrape.

## `fetchFullDescription` (type: `boolean`):

Fetch the full job description text, salary type, employment regime, workload, field of work, language requirements, and hiring contact name/email/phone for each vacancy (1 extra request per job). Disable for faster runs when you only need the search-result summary fields (title, employer, address, salary range).

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

Proxy settings. CVVP's job API has no anti-bot protection and is not geo-locked, so Apify's automatic/free proxy pool works fine — no residential proxy needed. See docs/site-recon/cvvp-nva-lv.md.

## Actor input object example

```json
{
  "searchQuery": "pārdevējs",
  "maxResults": 20,
  "fetchFullDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}
```

# 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": "pārdevējs",
    "maxResults": 20,
    "fetchFullDescription": true,
    "proxyConfiguration": {
        "useApifyProxy": true,
        "apifyProxyGroups": [
            "RESIDENTIAL"
        ]
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("studio-amba/cvvp-nva-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": "pārdevējs",
    "maxResults": 20,
    "fetchFullDescription": True,
    "proxyConfiguration": {
        "useApifyProxy": True,
        "apifyProxyGroups": ["RESIDENTIAL"],
    },
}

# Run the Actor and wait for it to finish
run = client.actor("studio-amba/cvvp-nva-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": "pārdevējs",
  "maxResults": 20,
  "fetchFullDescription": true,
  "proxyConfiguration": {
    "useApifyProxy": true,
    "apifyProxyGroups": [
      "RESIDENTIAL"
    ]
  }
}' |
apify call studio-amba/cvvp-nva-scraper --silent --output-dataset

```

## MCP server setup

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