# Latvia CSB Statistics Scraper (`parseforge/latvia-csb-statistics-scraper`) Actor

Reach into the Central Statistical Bureau of Latvia and pull table rows by tablePath. Each record carries the indicator name, contents code, time period, category, unit, and numeric value. Useful for demographic, economic, and population analysis on Latvian official statistics.

- **URL**: https://apify.com/parseforge/latvia-csb-statistics-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Automation, Integrations, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $7.50 / 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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇱🇻 Latvia CSB Public Statistics Scraper

> 🚀 **Export Latvia Central Statistical Bureau (CSB) public statistics in seconds. Population, prices, labour, trade, and more straight from the official data.stat.gov.lv endpoint into a clean dataset.**

> 🕒 **Last updated:** 2026-06-05 · **📊 8 fields** per record · 2,000+ official tables · Population, economy, prices, labour, trade

The 🇱🇻 Latvia CSB Public Statistics Scraper turns Latvia Central Statistical Bureau (CSB)'s official statistics service into a structured dataset. It calls the public REST endpoint with the table path you choose, parses the response, and flattens it into one row per data point.

You can target any of the 2,000+ public tables hosted by Latvia Central Statistical Bureau (CSB). The scraper auto-discovers each table's variables and pulls the full multi-dimensional matrix.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| 📊 Economists | Pull macro indicators for cross-country comparisons |
| 🏢 Market researchers | Demographic and consumer baselines |
| 🏛️ Public policy teams | Track official indicators over time |
| 🎓 Researchers | Build reproducible national datasets |
| 📰 Journalists | Verify population, price, and trade statistics |
| 👩‍💻 Developers | Mirror official tables into your own database |

### 📋 What this scraper does

- Calls the official data.stat.gov.lv REST endpoint with the table path you provide.
- Auto-discovers each table's variables (region, time, category) via the metadata endpoint.
- Parses the response and flattens every cell into one row.
- Resolves variable codes to human-readable labels.
- Surfaces upstream errors as a single diagnostic record instead of crashing.
- Exports as a clean tabular dataset ready for download in your preferred format.

> 💡 **Why it matters:** Official statistics agencies ship data as multi-dimensional matrices. Most analysts spend hours wrangling that shape into long-form rows. This actor does the flattening for you so the data drops straight into pandas, BigQuery, or a spreadsheet.

### 🎬 Full Demo

_🚧 Coming soon._

### ⚙️ Input

<table>
<tr><th>Field</th><th>Type</th><th>Required</th><th>Description</th></tr>
<tr><td><code>tablePath</code></td><td>string</td><td>Yes</td><td>Latvia Central Statistical Bureau (CSB) table path.</td></tr>
<tr><td><code>maxItems</code></td><td>integer</td><td>No</td><td>Free users 10. Paid users up to 1,000,000. Prefill 10.</td></tr>
<tr><td><code>lang</code></td><td>enum</td><td>No</td><td>Response language.</td></tr>
<tr><td><code>query</code> or <code>variableSelection</code></td><td>string</td><td>No</td><td>Optional. JSON array of variable selections forwarded to the API.</td></tr>
</table>

**Example 1:**
````

{
"tablePath": "OSP\_PUB/START/POP/IR/IRS/IRS010",
"maxItems": 100,
"lang": "en"
}

```

**Example 2:**
```

{
"tablePath": "OSP\_PUB/START/ECN/CPI/PCI/PCI010",
"maxItems": 200,
"lang": "en"
}

````

> ⚠️ **Good to Know:** Every table has its own variable structure. If you leave the variable selection empty, the actor auto-discovers the variables and requests all values. For very large tables, set `maxItems` to bound the dataset.

### 📊 Output

Each record is a flat object. The `error` field is always last.

| Field | Type | Description |
|---|---|---|
| 🗂️ `tablePath` | string | Latvia Central Statistical Bureau (CSB) table path. |
| 📘 `title` | string | Human-readable title of the table. |
| 📅 `period` | string | Time period label. |
| 🏷️ `category` | string | Primary category label. |
| 📏 `unit` | string | Unit of measurement when reported by the source. |
| 🔢 `value` | number | Numeric value of the cell. |
| 🕒 `scrapedAt` | string | ISO timestamp when the row was fetched. |
| ❌ `error` | string | Set if the upstream response was an error. |

### ✨ Why choose this Actor

| 🆓 | Works with the free public REST endpoint. No authentication needed. |
| 🧹 | Resolves variable codes to readable labels. |
| 🔢 | Auto-casts numeric cells to real numbers. |
| 🛟 | Surfaces upstream errors as a clean diagnostic record. |
| 🔌 | Targets any of the 2,000+ official tables by identifier. |
| 💾 | Push to dataset for instant export. |

### 📈 How it compares to alternatives

| Approach | Setup time | Variable resolution | Flat rows | Error handling |
|---|---|---|---|---|
| Roll your own fetch | 30 min plus | Manual | Manual | None |
| Python client library | 1 hour install | Partial | Manual | Partial |
| **This Actor** | 5 seconds, no install | Automatic | Automatic | Built in |

### 🚀 How to use

1. Click **Try for free**.
2. Pick a table path. Defaults are provided.
3. (Optional) Pass a variable selection to narrow the slice.
4. Click **Start**. Within seconds your dataset is ready.

### 💼 Business use cases

**📊 Macro research.** Pull GDP, prices, and labour indicators into a single dataset.

**🏢 Market sizing.** Use demographic tables to baseline market opportunity by region.

**🏛️ Policy monitoring.** Track official indicators over time without a custom scraper.

**🤖 ML feature engineering.** Build clean training sets of macro indicators for forecasting models.

### 🔌 Automating this scraper

- **Make and Zapier** trigger this actor on a monthly cadence, push results to Airtable or Google Sheets.
- **Cron schedule** uses Apify's native scheduler.
- **Webhooks** notify your endpoint the moment a run finishes.
- **Pipe to BigQuery, Snowflake, or Postgres** with native Apify integrations.

### 🌟 Beyond business use cases

**🎓 Education.** Teach econometrics or social science with real official statistics.

**🧪 Personal research.** Pull niche tables on agriculture, energy, or migration for a side project.

**🤝 Non-profit and open data.** Build public dashboards of demographics and economy.

**🧰 Tinkering and prototyping.** Spin up a data feed in seconds for a chart library demo.

### 🤖 Ask an AI assistant about this scraper

Pop this README into Claude, ChatGPT, or any AI assistant and ask it to map your specific workflow to the actor's inputs. The schema, examples, and field list above contain everything an LLM needs to design a working pipeline.

### ❓ Frequently Asked Questions

**❓ Do I need an API key?** No. The endpoint is fully public.

**❓ How do I find the right identifier?** Browse the table catalogue on data.stat.gov.lv. Each table has a short code or path.

**❓ Can I narrow the slice?** Yes, pass a variable selection to filter dimensions.

**❓ Are values cast to numbers?** Yes. Numeric cells are returned as real numbers.

**❓ How do you handle errors?** Upstream errors are pushed as a single record with the `error` field populated instead of crashing.

**❓ Can I schedule runs?** Yes, use Apify's native scheduler or hook into Make or Zapier.

**❓ Is this scraping or an API?** API. The REST endpoint is the official public interface.

**❓ Will the schema change?** Core fields (identifier, period, value, error) are stable.

**❓ What format can I download?** Use any export format offered by the Apify dataset UI.

### 🔌 Integrate with any app

Apify ships native integrations with Make, Zapier, Slack, Discord, Google Drive, Google Sheets, Gmail, Airbyte, Keboola, Telegram, GitHub, and any REST API or webhook endpoint. Trigger runs from a calendar event, a form submission, or a cron job, or pipe results straight into BigQuery, Snowflake, or a Postgres warehouse.

### 🔗 Recommended Actors

| Actor | What it does |
|---|---|
| [ParseForge Denmark Statbank Scraper](https://apify.com/parseforge) | Denmark official statistics. |
| [ParseForge Norway SSB Scraper](https://apify.com/parseforge) | Norway official statistics. |
| [ParseForge OurAirports Scraper](https://apify.com/parseforge/ourairports-scraper) | Global airport database. |
| [ParseForge Alpha Vantage Scraper](https://apify.com/parseforge) | Market data and indicators. |

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge) for 900+ production-grade scrapers across business intelligence, real estate, e-commerce, sports, finance, and public records.

---

**Disclaimer:** This actor scrapes only publicly available data. ParseForge is not affiliated with, endorsed by, or sponsored by any of the third-party services referenced. Users are responsible for complying with the target site's terms of service and applicable law. [Create a free account w/ $5 credit](https://console.apify.com/sign-up?fpr=vmoqkp).

# Actor input Schema

## `tablePath` (type: `string`):

Latvia CSB PxWeb table path (for example OSP_PUB/START/POP/IR/IRS/IRS010).
## `maxItems` (type: `integer`):

Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000.
## `lang` (type: `string`):

Response language.
## `query` (type: `string`):

Optional. JSON array of PxWeb selection objects. Leave empty for an all-values request.

## Actor input object example

```json
{
  "tablePath": "OSP_PUB/START/POP/IR/IRS/IRS010",
  "maxItems": 10,
  "lang": "en"
}
````

# 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 = {
    "tablePath": "OSP_PUB/START/POP/IR/IRS/IRS010",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/latvia-csb-statistics-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 = {
    "tablePath": "OSP_PUB/START/POP/IR/IRS/IRS010",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/latvia-csb-statistics-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 '{
  "tablePath": "OSP_PUB/START/POP/IR/IRS/IRS010",
  "maxItems": 10
}' |
apify call parseforge/latvia-csb-statistics-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/latvia-csb-statistics-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Latvia CSB Statistics Scraper",
        "description": "Reach into the Central Statistical Bureau of Latvia and pull table rows by tablePath. Each record carries the indicator name, contents code, time period, category, unit, and numeric value. Useful for demographic, economic, and population analysis on Latvian official statistics.",
        "version": "0.1",
        "x-build-id": "fQQtKaag1hhYskThi"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~latvia-csb-statistics-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-latvia-csb-statistics-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/parseforge~latvia-csb-statistics-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-latvia-csb-statistics-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/parseforge~latvia-csb-statistics-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-latvia-csb-statistics-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",
                "required": [
                    "tablePath"
                ],
                "properties": {
                    "tablePath": {
                        "title": "Table path",
                        "type": "string",
                        "description": "Latvia CSB PxWeb table path (for example OSP_PUB/START/POP/IR/IRS/IRS010)."
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: Limited to 10 items (preview). Paid users: Optional, max 1,000,000."
                    },
                    "lang": {
                        "title": "Language",
                        "enum": [
                            "en",
                            "lv"
                        ],
                        "type": "string",
                        "description": "Response language.",
                        "default": "en"
                    },
                    "query": {
                        "title": "Query JSON",
                        "type": "string",
                        "description": "Optional. JSON array of PxWeb selection objects. Leave empty for an all-values request."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```