# dane.gov.pl Scraper - Poland Open Data Portal API (`parseforge/poland-open-data-scraper`) Actor

Scrape dane.gov.pl, Poland's national open data portal: 26,922 datasets, 1.6M resources, 7,471 institutions, showcases, change history and table rows over the public JSON:API.

- **URL**: https://apify.com/parseforge/poland-open-data-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Business, News
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $6.23 / 1,000 datasets

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

[![ParseForge](https://raw.githubusercontent.com/ParseForge/apify-assets/main/banner.jpg)](https://apify.com/parseforge?fpr=vmoqkp)

### dane.gov.pl Scraper - Poland Open Data Portal API

**Pull all 26,989 datasets, 1.6 million resources and 7,476 publishing institutions out of dane.gov.pl, Poland's national open data portal, in one run.** Every dataset row carries 49 fields: Polish title and description, publisher with its REGON and address, EU DCAT themes, licence and every reuse condition, update frequency, openness score, file formats, view and download counts and four timestamps. No login, no API key, no rate limit. Exports to CSV, JSON, Excel and XML.

The portal has a public JSON:API, and that sounds like it settles the matter until you try to use it. The listing endpoint ignores a filter name it does not know and hands back the entire catalogue with HTTP 200, so a typo looks like a successful unfiltered query. `sort` behaves the same way. The `tag` filter is in the official spec and returns HTTP 400. Licence and update frequency filter on the search index and nowhere else. The resource index stops paging at exactly 40,000 rows with `all shards failed`, the audit log at 10,000. Single requests hang for a full minute at random. This scraper knows all of that, measures every filter against the unfiltered total before it sends it, paginates around the walls, and gives you a flat table instead of nested JSON:API envelopes.

| Who uses it | What they scrape dane.gov.pl for |
|---|---|
| Data engineers | Building an open data catalog mirror with formats, licences and refresh cadence per dataset |
| Property analysts | The 6,635 developers legally obliged to publish flat price lists, and their daily updates |
| Compliance teams | High value datasets under the Polish open data act and the EU HVD list |
| Civic tech and journalists | Which public bodies publish what, how often, and which of their links are already dead |
| AI and RAG builders | Polish public sector text and real table rows as grounded training and retrieval material |

### What it does

- 📚 **Ten collections in one Actor** - datasets, resources, institutions, showcases, change history, the broken links report, news, knowledge base, cross-model search, and the actual rows inside a table.
- 🇵🇱 **49 fields on every dataset** - title and description in plain text and HTML, publisher with type, city and website, DCAT themes with EU codes, keywords, regions, formats, delivery types, licence, reuse conditions, openness score, update frequency, views, downloads, harvest source and four timestamps.
- 📊 **Real table rows, with real headers** - the data API returns `col1`, `col2`, `col3`; this Actor restores the publisher's own column names, so you get `Nazwisko aktualne` and `Liczba`, not numbered placeholders.
- 🔗 **Live link checking** - one HEAD request per resource records the HTTP status, content type and byte size of the file itself, which finds dead downloads the portal has not flagged yet.
- 🏛️ **Full publisher profiles** - REGON, postal address, email, telephone, fax, ePUAP inbox, electronic delivery address, website and the external catalogues the body is harvested from.
- 🧮 **Catalogue breakdowns** - one row per format, theme, category, delivery type, openness score and publisher, with counts and share of whatever slice you filtered to.
- 🇬🇧 **English or Polish** - English translates the controlled vocabularies and links to the English portal. Titles and descriptions are written in Polish by the publishers, so they stay Polish either way.
- ⏱️ **Paging that respects the walls** - the resource index dies past 40,000 rows, the audit log and any single table past 10,000; the run stops cleanly at each ceiling and logs exactly how many rows are out of reach instead of failing. A page that times out is retried, never dropped in silence.

### What you can do with dane.gov.pl data

**Mirror Poland's open data catalog.** Pull all 26,989 datasets with their formats, licences, openness scores and update frequencies, then re-run weekly with a `Modified from` date to catch only what changed. The 49-field row is flat, so it lands in a warehouse table without any JSON flattening step.

**Track the property market at source.** Polish developers must publish their flat price lists as open data under the 2021 developer act, which is why 6,635 of the 7,476 registered institutions are developers and why 21,858 of the datasets sit under Economy and finance. Filter to `Property developer`, turn on the file check and the table preview, and you get the price lists with their live download URLs.

**Audit a public body's transparency.** Point it at one institution ID, turn on the change history block, and you get every dataset that body publishes, when each was last refreshed against its promised cadence, and the full audit trail of who edited what.

**Feed a RAG index with Polish public sector text.** Datasets, news and knowledge base articles all carry full descriptions, and the table rows collection gives you the underlying data itself. It is public domain or CC BY in almost every case, so the licence question is already answered in the row.

### Why choose this scraper

| | What you get |
|---|---|
| Every filter measured | Each filter was sent against the unfiltered total before it shipped. The ones this API accepts and then silently ignores are applied after the fetch instead, on the full row, before anything is billed |
| Nothing always empty | The five sparse licence-condition columns are folded into one readable list, and no field ever comes back as a literal null |
| The walls documented | 40,000 rows on resources, 10,000 on the audit log, 10,000 per table on the data API, 26,989 datasets fully reachable, each one bisected and logged at run time |
| Ten record types | Not just the catalogue: the files, the publishers, the reuse showcases, the audit log, the dead-link report, the editorial content and the table contents |
| Pay for what returned | An enrichment block that came back empty is not charged, and the run asks the charging manager before it writes a batch rather than after |
| No proxy, no key | The API is open. There is no proxy cost in your bill and no credential to manage |

### How it compares

There is one other dane.gov.pl Actor in the Apify Store, `benthepythondev/poland-dane-gov-scraper`, at $2.50 per 1,000 rows against our $7.00. It is cheaper and it has two billing events against our nineteen, which is the honest summary of the difference: it charges for a start and a row, and that is what it does. Ours costs 2.8x more per dataset row and in exchange covers ten record types instead of one, carries 49 fields on the primary row, restores real column headers on table data, checks whether files still download, and knows where each index stops paging. If you want one flat pass over the dataset list and nothing else, the cheaper one is the right call.

| | This Actor | benthepythondev/poland-dane-gov-scraper | The portal's own API |
|---|---|---|---|
| Price per 1,000 datasets | $7.00 | $2.50 | Free |
| Billing events | 19 | 2 | n/a |
| Record types | 10 | 1 | 20 endpoints, JSON:API envelopes |
| Fields on a dataset row | 49 | not published | 37 raw attributes, nested |
| Table rows with real headers | Yes | No | `col1`, `col2`, `col3` |
| Live file checking | Yes | No | No |
| Paging walls handled | Yes | Not published | Fails with `all shards failed` |
| Users in the last 30 days | new | 0 | n/a |

### What a dane.gov.pl dataset looks like

One unedited row from the verified platform run [fW4CEt1RpHtSsx2t1](https://console.apify.com/actors/Emy31Y0dszCLXycar/runs/fW4CEt1RpHtSsx2t1):

```json
{
  "datasetId": "1",
  "slug": "dane-liczbowe-dot-kontroli-prowadzonych-przez-wiih-w-2014-r",
  "title": "Dane liczbowe dot. kontroli prowadzonych przez WIIH w 2014 r.",
  "description": "Dane liczbowe dot. kontroli prowadzonych przez wojewódzkich inspektorów Inspekcji Handlowej (IH) w 2014 r.",
  "descriptionHtml": "<p>Dane liczbowe dot. kontroli prowadzonych przez wojewódzkich inspektorów Inspekcji Handlowej (IH) w 2014 r.</p>",
  "url": "https://dane.gov.pl/pl/dataset/1,dane-liczbowe-dot-kontroli-prowadzonych-przez-wiih-w-2014-r",
  "apiUrl": "https://api.dane.gov.pl/1.4/datasets/1,dane-liczbowe-dot-kontroli-prowadzonych-przez-wiih-w-2014-r",
  "externalUrl": "Not Disclosed",
  "institutionId": "26",
  "institutionName": "Urząd Ochrony Konkurencji i Konsumentów",
  "institutionType": "Administracja rządowa",
  "institutionCity": "Warszawa",
  "institutionWebsite": "https://uokik.gov.pl/index.php",
  "dcatThemes": [{ "id": "148", "code": "GOVE", "title": "Rząd i sektor publiczny" }],
  "dcatThemeCodes": [
    "GOVE"
  ],
  "legacyCategory": "Administracja Publiczna",
  "keywords": [
    "uokik",
    "inspekcja handlowa"
  ],
  "regions": [
    "Polska"
  ],
  "formats": [
    "xlsx"
  ],
  "resourceTypes": [
    "file"
  ],
  "visualizationTypes": [],
  "resourceCount": 1,
  "showcaseCount": 0,
  "licenseName": "CC0 1.0",
  "licenseCode": "N/A",
  "licenseDescription": "Other (Public Domain)",
  "licenseConditions": [],
  "updateFrequency": "Rocznie",
  "opennessScore": 2,
  "opennessScores": [
    2
  ],
  "hasHighValueData": "No",
  "hasEuHighValueData": "Not Disclosed",
  "hasDynamicData": "No",
  "hasResearchData": "No",
  "isPromoted": "No",
  "viewsCount": 673,
  "downloadsCount": 138,
  "harvestedFromTitle": "Not Disclosed",
  "harvestedFromUrl": "Not Disclosed",
  "harvestedFromType": "Not Disclosed",
  "harvestedLastImport": "Not Disclosed",
  "supplements": [],
  "imageUrl": "Not Disclosed",
  "imageAlt": "Not Disclosed",
  "createdAt": "2016-04-19T07:39:49Z",
  "modifiedAt": "2024-03-19T19:14:09Z",
  "verifiedAt": "2016-04-19T09:41:11Z",
  "resourceModifiedAt": "2022-12-05T11:40:46Z",
  "scrapedAt": "2026-08-27T20:21:21.768Z"
}
```

### Configure the run

Pick one or more collections, set how many rows you want, and add filters. **Max Items** caps the whole run, and with several collections selected each gets an even share of it, with anything one collection does not use rolling forward to the next. Everything else has a working default. The catalogue filters run inside the portal index; the post-fetch refinements are the fields the index accepts and then ignores, so they cost more upstream reads and are labelled as such in the schema.

Fresh CSV datasets from central government, newest first:

```json
{
  "collections": ["datasets"],
  "formats": ["csv"],
  "minOpennessScore": "3",
  "createdFrom": "2026-01-01",
  "sortBy": "-created",
  "maxItems": 5000
}
```

Every file a single publisher offers, with a live download check and the table schema:

```json
{
  "collections": ["resources"],
  "institutionIds": ["26"],
  "includeTabularPreview": true,
  "includeFileProbe": true,
  "maxRowsPerResource": 5,
  "maxItems": 2000
}
```

The most common Polish surnames, straight out of the PESEL register table:

```json
{
  "collections": ["tabular-rows"],
  "resourceIds": ["28052"],
  "maxRowsPerResource": 1000,
  "maxItems": 1000
}
```

That table holds 298,692 rows and the data API pages 10,000 of them, so ask for more than that and the run stops at the ceiling and says so.

### Pricing

Pay per event. You are charged for the rows you receive, plus a small fee per catalogue page paged through, plus one Actor start.

| Event | Price | When |
|---|---|---|
| Actor start | $0.020 | Once per run |
| Catalogue page scanned | $0.004 | Per page of up to 50 records |
| Dataset | $0.007 | Per dataset row |
| Resource | $0.003 | Per file or API row |
| Institution | $0.008 | Per publisher row |
| Showcase | $0.006 | Per app or service row |
| Change history entry | $0.003 | Per audit log row |
| Broken link | $0.004 | Per dead-link row |
| News item | $0.004 | Per news row |
| Knowledge base article | $0.004 | Per article row |
| Search result | $0.003 | Per cross-model hit |
| Table row | $0.002 | Per row of real data |
| Catalogue breakdown | $0.002 | Per facet bucket |
| Files of a dataset | $0.004 | Opt in, only when files came back |
| Apps reusing a dataset | $0.004 | Opt in, only when a showcase exists |
| Change history of a dataset | $0.004 | Opt in, only when the log had entries |
| Full publisher profile | $0.005 | Opt in, only when the profile returned |
| Table preview | $0.004 | Opt in, only for tabulated resources |
| Live file check | $0.003 | Opt in, only when the check completed |

What a plain dataset run actually costs:

| Datasets | Start | Pages | Rows | Total |
|---|---|---|---|---|
| 100 | $0.02 | $0.008 | $0.70 | **$0.73** |
| 1,000 | $0.02 | $0.080 | $7.00 | **$7.10** |
| 10,000 | $0.02 | $0.800 | $70.00 | **$70.82** |

Bronze, Silver and Gold plans get 3.8%, 7.4% and 11% off every event.

### Free users

Free Apify accounts get 10 rows per run as a preview, enough to check the field set and the filters before committing. Paid plans lift the cap to 1,000,000 rows. [Upgrade here](https://apify.com/pricing?fpr=vmoqkp).

### Run it

1. Create a [free Apify account](https://apify.com/?fpr=vmoqkp). It comes with $5 of platform credit, no card needed.
2. Open the Actor and pick your collections. Leave everything else alone for a first run.
3. Set **Max Items** and press **Start**.
4. Export from the **Storage** tab as CSV, JSON, Excel or XML, or pull it over the API.

### Use with AI agents (MCP)

```
claude mcp add apify --transport sse https://mcp.apify.com/sse --header "Authorization: Bearer YOUR_APIFY_TOKEN"
```

Then ask in plain language:

- "Get me every CSV dataset published on dane.gov.pl since January, with its publisher and licence."
- "Which Polish public institutions have broken download links on the open data portal right now?"
- "Pull the 500 most common Polish surnames out of the PESEL register dataset."

### Troubleshooting

**No results at all.** The most likely cause is a format filter in the wrong case. This index stores formats lower case and `CSV` returns zero while `csv` returns 10,698. Narrow date ranges do the same thing quietly.

**Fewer rows than I asked for.** Three ceilings are real and all three are logged: the resource index stops at 40,000 rows, the audit log at 10,000, and a single table on the data API at 10,000, after which the portal answers `all shards failed`. Flip `Sort by` to reach the other end of an index, add a filter to cut the result set below the wall, or use `Table row search` to reach deeper rows of one table.

**A field I expected is empty.** Almost every field on this portal is optional. `harvestedFrom*` is filled on 39% of datasets, `externalUrl` on 31%, the legacy category on 17%. Empty means the publisher left it blank, and the row says `Not Disclosed` rather than hiding it.

**My licence or update frequency filter did nothing.** Those two only filter on the cross-model search index. In the dataset collection they are applied after the fetch, under **Post-fetch refinements**, which is slower but correct. Use the **Search** collection with **Search: licence** for the server-side version.

**The run is slower than I expected.** Single requests to this API hang for up to a minute at random, roughly one in five. The Actor times each attempt out at 25 seconds and retries against the clock, and runs six pages in parallel, which is why a 5,000 dataset run measured 63 rows per second even though one request averages three seconds. Turning on the opt-in blocks costs one extra call per row and drops that to around 8 rows per second.

### FAQ

| Question | Answer |
|---|---|
| Do I need an API key for dane.gov.pl? | No. The portal's JSON:API is fully anonymous and this Actor uses no proxy and no credentials. |
| How many datasets are there? | 26,989 datasets, 1,613,952 resources, 7,476 institutions, 119 showcases and 269,811 audit log entries when this was measured. The catalogue grows daily, so treat these as a floor. |
| Can I download the actual CSV files? | The row gives you the direct `downloadUrl` for each resource, and the table rows collection returns the parsed contents of tabulated resources without you downloading anything. |
| Why do so many publishers look like property companies? | Polish developers are legally required to publish flat price lists as open data, so 6,635 of the 7,476 institutions are developers. Filter `Institution type` to `Central government` for the ministries. |
| Is the data in English? | The controlled vocabularies are, when you set Language to English. Titles and descriptions are written in Polish by the publishers and are never translated by the portal. |
| Can I get only what changed since last week? | Yes. Use `Modified from` in the dataset collection, or the **Change history** collection with a `Changed from` date for the audit trail itself. |
| What licence is the data under? | 24,098 datasets are CC0 1.0 and 2,825 are CC BY 4.0, with 66 across the NonCommercial and ShareAlike variants. Each row carries the licence name and its reuse conditions. |
| How fast is it? | 63 rows per second, measured on a 5,000 dataset run on the Apify platform that finished in 79 seconds. At that rate the whole catalogue takes about seven minutes. The opt-in blocks are one HTTP call each and cut it to roughly 8 rows per second. |
| What is the openness score? | The portal's 1 to 5 star rating on Tim Berners-Lee's scale. 3 means a non-proprietary format like CSV, 4 adds URIs, 5 adds links out to other data. 13,990 datasets are 3 stars or better. |
| Does it work on the English portal? | Yes. Setting Language to English switches the vocabularies and points every `url` at `dane.gov.pl/en/...`. |

### Related actors

- [GovData Germany Scraper](https://apify.com/parseforge/govdata-germany-scraper?fpr=vmoqkp) - the same job on Germany's national CKAN portal.
- [Italy Open Data Scraper](https://apify.com/parseforge/dati-gov-it-italy-open-data-scraper?fpr=vmoqkp) - 65,960 datasets from dati.gov.it with DCAT-AP\_IT metadata.
- [EU Open Data Portal Scraper](https://apify.com/parseforge/euopendata-datasets-scraper?fpr=vmoqkp) - the European Commission's own catalogue.
- [KRS Poland Business Registry Scraper](https://apify.com/parseforge/krs-poland-scraper?fpr=vmoqkp) - Polish company records, to join publishers to legal entities.
- [NBP Poland Exchange Rates Scraper](https://apify.com/parseforge/nbp-poland-rates-scraper?fpr=vmoqkp) - National Bank of Poland reference rates.

Browse the full [ParseForge collection](https://apify.com/parseforge?fpr=vmoqkp) for more scrapers.

Need help? Email parseforge@protonmail.com with your run ID, your input, and what you expected.

Disclaimer: this is an unofficial scraper, not affiliated with or endorsed by the Ministry of Digital Affairs, dane.gov.pl or the Polish government. It reads only data the portal publishes anonymously to anyone. Institution records contain business contact details of public bodies, published by those bodies as open data; handle any personal data you extract in line with GDPR, CCPA and PIPL, and keep the licence terms carried in every row.

# Actor input Schema

## `collections` (type: `array`):

Which dane.gov.pl records to collect. Datasets is the catalogue itself (26,989 records). Resources are the downloadable files and APIs inside them (1.6M). Institutions are the 7,476 publishing bodies. Showcases are the 119 apps built on the data. Change history is the portal audit log. Broken links is the portal's own dead-link report. News and Knowledge base are the editorial content. Search runs one cross-model query. Table rows pulls the actual rows out of a tabulated resource.

## `searchTerm` (type: `string`):

Free text query applied to whichever collections are selected. On the dataset, resource and institution indexes diacritics are folded, so 'budzet' works. The cross-model search does NOT fold them: use 'budżet' there.

## `datasetIds` (type: `array`):

Numeric dane.gov.pl dataset IDs, for example 1681. Given here, only these datasets are fetched, and the Resources collection is limited to their files.

## `resourceIds` (type: `array`):

Numeric resource IDs. Required target for the Table rows collection; leave empty there and the ten most viewed tabulated resources are used instead.

## `institutionIds` (type: `array`):

Numeric institution IDs, for example 26 for UOKiK. Filters datasets to those publishers, and the Institutions collection to those bodies.

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

Free users: limited to 10 items (preview). Paid users: up to 1,000,000. This is the cap for the whole run: with several collections selected each gets an even share and whatever one does not use rolls forward to the next.

## `formats` (type: `array`):

Keep only records offering at least one of these formats. The index is case sensitive and stores formats in lower case.

## `dcatThemes` (type: `array`):

The 14 EU data themes the portal tags datasets with. Multiple values are OR'd.

## `legacyCategories` (type: `array`):

The 13 original dane.gov.pl categories. Only about 1,156 datasets still carry one, so this is a narrow filter by design.

## `datasetTypes` (type: `array`):

How the data is delivered: a downloadable file, a live API, or a link to an external website.

## `visualizationTypes` (type: `array`):

Keep only records the portal can render. Table means the rows are queryable through the data API, which is what the Table rows collection needs.

## `keywords` (type: `array`):

Keyword tags exactly as the portal stores them, for example 'uokik'. Multiple values are OR'd. Note the API's own 'tag' filter is documented but returns HTTP 400, so keywords are the working vocabulary.

## `titleContains` (type: `string`):

Full text match against the title only, instead of the whole record.

## `notesContains` (type: `string`):

Full text match against the description only.

## `minOpennessScore` (type: `string`):

The portal's 1 to 5 star openness rating, using Tim Berners-Lee's scale. 3 means a non-proprietary format such as CSV, 4 adds URIs, 5 adds links to other data.

## `createdFrom` (type: `string`):

Only records first published on or after this date, as YYYY-MM-DD.

## `createdTo` (type: `string`):

Only records first published on or before this date, as YYYY-MM-DD.

## `onlyHighValueData` (type: `boolean`):

Only datasets flagged as high value data under the Polish open data act (17,536 datasets).

## `onlyEuHighValueData` (type: `boolean`):

Only datasets on the European Commission's high value datasets list (118 datasets).

## `onlyDynamicData` (type: `boolean`):

Only datasets the publisher marks as dynamic, meaning near real time (3,950 datasets).

## `onlyResearchData` (type: `boolean`):

Only datasets flagged as research data (1,413 datasets).

## `onlyPromoted` (type: `boolean`):

Only datasets the portal editors promote on the front page (5 datasets).

## `licenseNames` (type: `array`):

Keep only datasets under one of these licences.

## `updateFrequencies` (type: `array`):

Keep only datasets the publisher refreshes at this cadence. Values are the Polish labels the portal stores.

## `modifiedFrom` (type: `string`):

Only datasets last modified on or after this date, as YYYY-MM-DD.

## `modifiedTo` (type: `string`):

Only datasets last modified on or before this date, as YYYY-MM-DD.

## `minViews` (type: `integer`):

Only datasets viewed at least this many times on the portal.

## `minDownloads` (type: `integer`):

Only datasets downloaded at least this many times.

## `minResources` (type: `integer`):

Only datasets carrying at least this many resources.

## `searchModels` (type: `array`):

Which record types the cross-model search returns. Leave empty for all of them.

## `searchLicenseCodes` (type: `array`):

Licence filter, server side, available only on the cross-model search.

## `searchUpdateFrequencies` (type: `array`):

Update frequency filter, server side, available only on the cross-model search.

## `searchDateFrom` (type: `string`):

Cross-model search only. Records dated on or after this day, as YYYY-MM-DD.

## `searchDateTo` (type: `string`):

Cross-model search only. Records dated on or before this day, as YYYY-MM-DD.

## `institutionTypes` (type: `array`):

Which kind of publishing body to keep. Developer is by far the largest group because property developers are legally obliged to publish their price lists here.

## `institutionCity` (type: `string`):

Exact city name as the register stores it, for example Warszawa (1,324 institutions) or Kraków (465).

## `institutionRegon` (type: `string`):

Polish REGON statistical number, which resolves to exactly one institution.

## `historyAction` (type: `string`):

Which kind of audit log entry to keep. UPDATE covers 231,131 of the 269,810 entries.

## `historyChangedFrom` (type: `string`):

Only audit log entries recorded on or after this date, as YYYY-MM-DD.

## `historyChangedTo` (type: `string`):

Only audit log entries recorded on or before this date, as YYYY-MM-DD.

## `tabularQuery` (type: `string`):

Full text query inside a resource's own table, for the Table rows collection. Searching a name inside the PESEL register works this way.

## `maxRowsPerResource` (type: `integer`):

How many rows to pull out of each tabulated resource before moving to the next one. Also caps the table preview block.

## `language` (type: `string`):

English translates the controlled vocabularies (themes, update frequency) and links to the English portal. Titles and descriptions are only ever written in Polish by the publishers, so they stay in Polish either way.

## `sortBy` (type: `string`):

Order the records come back in. An unsupported value falls back to the collection's default with a warning, because this API silently ignores a sort field it does not know.

## `includeDatasetResources` (type: `boolean`):

Attach every resource of the dataset with its format, byte size, openness score, download URL and data date. One extra API call per dataset.

## `maxResourcesPerDataset` (type: `integer`):

How many resources to attach when the block above is on. The API caps a page at 100.

## `includeDatasetShowcases` (type: `boolean`):

Attach the showcases, meaning the public services and apps, that reuse this dataset. Only fetched when the dataset declares at least one.

## `includeDatasetHistory` (type: `boolean`):

Attach the portal audit log for the dataset: every update with its timestamp, the editor account and which fields changed.

## `includeInstitutionProfile` (type: `boolean`):

Attach the publishing body's full record: REGON, postal address, email, phone, fax, ePUAP inbox, website and its harvest sources.

## `includeTabularPreview` (type: `boolean`):

For resources, attach the column schema with real header names and the first rows of the table. Only tabulated resources have any; the rest return nothing and are not billed.

## `includeFileProbe` (type: `boolean`):

Send one HEAD request per resource to record the HTTP status, content type and byte size of the actual file, which is how you find dead links the portal has not noticed.

## `includeFacets` (type: `boolean`):

After the records, emit one row per facet bucket: every format, theme, category, delivery type, openness score and top publisher with its dataset count and share of the filtered catalogue.

## Actor input object example

```json
{
  "collections": [
    "datasets"
  ],
  "searchTerm": "budżet",
  "datasetIds": [
    "1681",
    "2598"
  ],
  "resourceIds": [
    "21455"
  ],
  "institutionIds": [
    "26"
  ],
  "maxItems": 10,
  "keywords": [
    "uokik"
  ],
  "titleContains": "budzet",
  "createdFrom": "2025-01-01",
  "createdTo": "2026-08-01",
  "onlyHighValueData": false,
  "onlyEuHighValueData": false,
  "onlyDynamicData": false,
  "onlyResearchData": false,
  "onlyPromoted": false,
  "modifiedFrom": "2026-01-01",
  "searchDateFrom": "2026-01-01",
  "institutionCity": "Warszawa",
  "institutionRegon": "122462192",
  "historyChangedFrom": "2026-08-01",
  "tabularQuery": "ZUZANNA",
  "maxRowsPerResource": 100,
  "language": "pl",
  "includeDatasetResources": false,
  "maxResourcesPerDataset": 10,
  "includeDatasetShowcases": false,
  "includeDatasetHistory": false,
  "includeInstitutionProfile": false,
  "includeTabularPreview": false,
  "includeFileProbe": false,
  "includeFacets": false
}
```

# Actor output Schema

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

No description

## `csv` (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 = {
    "collections": [
        "datasets"
    ],
    "maxItems": 10,
    "maxRowsPerResource": 100,
    "maxResourcesPerDataset": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/poland-open-data-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 = {
    "collections": ["datasets"],
    "maxItems": 10,
    "maxRowsPerResource": 100,
    "maxResourcesPerDataset": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/poland-open-data-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 '{
  "collections": [
    "datasets"
  ],
  "maxItems": 10,
  "maxRowsPerResource": 100,
  "maxResourcesPerDataset": 10
}' |
apify call parseforge/poland-open-data-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,parseforge/poland-open-data-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/Emy31Y0dszCLXycar/builds/cPsm8Kzz9rbIjfvsZ/openapi.json
