Polish Open Data (unofficial)

PolishOpenData

.NET libraries and an MCP server for Polish public registers — company lookup in KRS, the VAT whitelist (Biała Lista) with bank-account checks (online, or offline against the Ministry of Finance flat file), a client for the GUS REGON register (library only), cadastral parcel lookup (ULDK), address geocoding (UUG) and real estate transaction prices (RCN) from GUGiK, and offline validation of NIP, REGON, KRS, NRB and land-registry (KW) numbers.

[CI] [NuGet] [License: MIT]

🇵🇱 Polska wersja

Unofficial project. Not affiliated with the Ministry of Justice, the Ministry of Finance or any other public body. Results are informational, not legal or tax advice; the registers are the authoritative source.

Packages

Offline validation

No network, no DI:

dotnet add package PolishOpenData.Core

using PolishOpenData;
Console.WriteLine(Nip.TryParse("774-000-14-54", out var nip) ? $"Valid NIP {nip}" : "Invalid NIP"); // Valid NIP 7740001454Console.WriteLine(KwNumber.TryParse("WA1M/00012345/1", out var kw) ? kw.Court?.Name : "Invalid KW number"); // Sąd Rejonowy dla Warszawy-Mokotowa …Console.WriteLine(string.Join(", ", KwNumber.SuggestCorrections("WAIM/00012345/1"))); // WA1M/00012345/1

Quick start: check a counterparty

dotnet add package PolishOpenData.BialaListadotnet add package PolishOpenData.Krsdotnet add package Microsoft.Extensions.Http.Resilience

using Microsoft.Extensions.DependencyInjection;using PolishOpenData;using PolishOpenData.BialaLista;using PolishOpenData.Krs;using System.Threading.Tasks;
var services = new ServiceCollection();services.AddBialaListaClient(o => o.TrackQuota = true)    .AddStandardResilienceHandler(o => o.Retry.ShouldHandle = _ => new ValueTask<bool>(false));services.AddKrsClient().AddStandardResilienceHandler();using var provider = services.BuildServiceProvider();
var vat = provider.GetRequiredService<IBialaListaClient>();var nip = Nip.Parse("774-000-14-54");
var result = await vat.FindByNipAsync(nip);Console.WriteLine($"{result.Value?.Name}: {result.Value?.VatStatus} (request {result.RequestId})");
var check = await vat.CheckBankAccountAsync(nip, Nrb.Parse("06 1600 1127 1843 9838 2000 0034"));Console.WriteLine(check.Value ? "Account is on the whitelist" : "Account is NOT on the whitelist");
var krs = provider.GetRequiredService<IKrsClient>();var extract = await krs.GetCurrentExtractAsync(result.Value!.Krs!.Value);Console.WriteLine(extract.Extract?.ToSummary().ShareCapital);

Retries are off for Biała Lista: every retry the resilience handler would make is another upstream request that the quota guard above cannot count, and once the daily limit is reached Biała Lista blocks the whole IP address — not just this process — until midnight. Register AddBialaListaClient once per process and reuse the resulting client (or pass one shared BialaListaQuotaTracker explicitly); a client created without DI and without a shared tracker gets its own private tracker that does not see requests made by other instances.

A runnable version is in samples/CheckCounterparty.

Keep RequestId. Every BialaListaResult carries the request identifier and time returned by Biała Lista (RequestId, RequestDateTime); keep them with your payment records to document when you checked the whitelist and what it answered.

Source-generated JSON. The KRS models use public converters from PolishOpenData.Krs.Serialization (KrsDateJsonConverter, KrsTimestampJsonConverter), so on .NET 8 or later you can add KrsCurrentExtract or KrsFullExtract to your own JsonSerializerContext (for example to cache extracts) without registering any converter. If you parse raw KRS API responses yourself instead of calling IKrsClient, note two things: the extract is wrapped in an odpis object, so deserialize that inner object; and the registry's field names (such as dataRejestracjiWKRS) match the properties only case-insensitively, so use JsonSerializerDefaults.Web — [JsonSourceGenerationOptions(JsonSerializerDefaults.Web)] on your context, or new JsonSerializerOptions(JsonSerializerDefaults.Web) with the reflection-based serializer on .NET Framework. Otherwise the properties stay null without an error.

Quick start: look up an entity in the GUS REGON register

PolishOpenData.Regon is a client for GUS's BIR1.2 web service: search by NIP, REGON or KRS number, batches of up to 20 identifiers, and the full reports of legal persons, sole traders and local units. It needs a key of your own (free: write to [email protected]); GUS's public test environment works without a key but serves an old, anonymised copy of the register.

dotnet add package PolishOpenData.Regon

using Microsoft.Extensions.DependencyInjection;using PolishOpenData;using PolishOpenData.Bir;using System.Linq;
var services = new ServiceCollection();services.AddRegonClient(o => o.UserKey = Environment.GetEnvironmentVariable("MY_APP_REGON_KEY")); // your key, from your own configuration// GUS's public test environment needs no key: services.AddRegonClient(o => o.Environment = RegonEnvironment.Test);using var provider = services.BuildServiceProvider();var regon = provider.GetRequiredService<IRegonClient>();
var found = await regon.FindByNipAsync(Nip.Parse("526-104-08-28"));var entity = found.Value[0];Console.WriteLine($"{entity.Name}, {entity.Address.City} (REGON {entity.Regon})");
var details = (await regon.GetDetailsAsync(entity, RegonInclude.Pkd)).Value[0];Console.WriteLine($"{details.LegalFormName}; main PKD {details.Pkd!.First(p => p.IsPrimary).Code}");Console.WriteLine($"Source: GUS REGON ({found.Environment}), retrieved {found.RetrievedAt:u}");
await regon.LogoutAsync();

The client limits itself to GUS's strictest window by default (3 calls per second, 120 per minute, 6,000 per hour; a batch of up to 20 identifiers is one call for the per-second limit, while the per-minute and per-hour limits count requests and identifiers: each identifier of a search counts one, and so does every other request — login, report, GetDataDateAsync, logout) and keeps one login session. A batch method checks its whole batch before the first request and throws QuotaExceededException without sending anything when it does not fit into what is left of the minute or hour window: under the default window one call carries at most 119 distinct identifiers (120 when the session is already logged in, fewer when other calls used the last minute). Whether GUS also counts every identifier of a batch toward its own per-second limit is not confirmed; if you send many batches, use smaller ones or space them out. Register AddRegonClient once per process and reuse the client: GUS counts requests per application instance, and a session works only from the IP address that created it. Call LogoutAsync when your process stops; the client never does it by itself. A client created without DI gets a private session and limiter.

Retries stay off for REGON, as for Biała Lista: a retry made by a resilience handler is another GUS request that the request limiter cannot count, and a SOAP fault, which means your request was wrong, arrives as HTTP 500 and would be retried. If you add AddStandardResilienceHandler, switch its retries off as in the Biała Lista example above.

Keys and the test environment. The library is bring-your-own-key: it ships no production key, never reads environment variables and never logs or prints your key. GUS's technical manual (section 3.6.3) calls it unacceptable for software to make every end user apply for their own key, but GUS told the maintainer on 2026-10-15 that for this project each end user may apply for and use their own key; that answer covers this project, so check GUS's rules before you distribute your own application built on the library. RegonEnvironment.Test selects GUS's public test service and its published test key (a UserKey that you configure is ignored there and never sent to the test service, so you can keep your own key configured and switch the environment); every result says which environment it came from (RegonResult.Environment), so anonymised test data (mostly from 2014) cannot pass for current data.

Cost. Details cost requests: a legal person takes a login, a search and one report (3 requests), each optional list (RegonInclude.Pkd, LocalUnits, Partners) one more, and a sole trader the general report plus one report per activity type. RegonResult.DataAsOf is filled once GetDataDateAsync has been called (one request).

Sole traders: the CEIDG register

PolishOpenData.Ceidg reads CEIDG (the register of sole traders) through the Ministry's API v3: look up the entries of an owner by NIP or REGON, or one entry by id, with status, start/suspension/end dates, address and PKD codes. It is bring-your-own-token: apply for a free token at biznes.gov.pl (e-service 00_9999_00, which asks for a Profil Zaufany login). The token is personal, so keep it on a server and never in a browser (the API sends no CORS headers anyway).

dotnet add package PolishOpenData.Ceidg

services.AddCeidgClient(o => o.Token = Environment.GetEnvironmentVariable("MY_APP_CEIDG_TOKEN")); // your token, from your own configurationvar ceidg = provider.GetRequiredService<ICeidgClient>();foreach (var business in await ceidg.FindByNipAsync(Nip.Parse("5260250995")))   // empty list: not in CEIDG (companies are in KRS){    Console.WriteLine($"{business.Name}: {business.Status}, started {business.StartDate}");}

A person can have several entries (an ended one and a running one), so lookups return lists. CEIDG allows 1,000 requests per 60 minutes per token; the client neither limits itself nor retries (a retry is one more request against the limit). Sole traders' names are personal data: use them to identify a business, not to build lists.

Local statistics: GUS Bank Danych Lokalnych

PolishOpenData.Bdl reads GUS's local data bank (BDL): thousands of indicators (population, unemployment, housing, budgets...) for every voivodeship, powiat and gmina, by year. No key is needed; a free personal key from the BDL registration (sent as X-ClientId) raises the limits.

dotnet add package PolishOpenData.Bdl

services.AddBdlClient();   // optional: o => o.ClientId = "your-own-key"var bdl = provider.GetRequiredService<IBdlClient>();var gmina = (await bdl.SearchUnitsAsync("Kraków", BdlLevel.Gmina)).Items.Single();   // the same name also matches a powiat and a subregion: pick the levelvar data = await bdl.GetDataByUnitAsync(gmina.Id, [72305], [2025]);            // variable 72305: population, totalforeach (var value in data.Series[0].Values){    Console.WriteLine($"{value.Year}: {value.Value?.ToString() ?? "no data"}");}

Variable names mean little alone ("ogółem, ogółem"): GetSubjectAsync gives the topic that makes them readable. A cell can be a placeholder zero that GUS marks as confidential, not applicable or not yet published; the library turns those into Value == null and keeps GUS's flag in Flag. An id that does not exist is not an error: the data calls return an empty result. Anonymous limits are 5 requests per second, 100 per 15 minutes, 1,000 per 12 hours and 10,000 per week (a wrong ClientId is not rejected, you silently get the anonymous limits); the client neither limits itself nor retries, and GetDataByVariableAsync spends one request per 100 units (all gminas of Poland are about 25). The data is licensed CC BY 4.0: cite "Główny Urząd Statystyczny, Bank Danych Lokalnych". The TERYT code in BdlUnit.Teryt is derived from the unit id, which GUS does not document.

Legal acts: Sejm ELI

PolishOpenData.Eli reads the Sejm's ELI API (api.sejm.gov.pl/eli): find acts in Dziennik Ustaw and Monitor Polski, read an act's status, its consolidated texts (teksty jednolite) and its amendments, and read one article as plain text. No key is needed.

dotnet add package PolishOpenData.Eli

services.AddEliClient();var eli = provider.GetRequiredService<IEliClient>();var civilCode = EliActId.Parse("Dz.U. 1964 poz. 93");               // also DU/1964/93 or WDU19640160093var current = await eli.GetCurrentTextAsync(civilCode);              // newest consolidated text, newest one with HTML, what changed sincevar article = await eli.GetArticleAsync(current.NewestWithHtml!.Id, "415");Console.WriteLine($"{article?.Text}\n(from {current.NewestWithHtml.DisplayAddress}; current: {current.IsHtmlTextCurrent})");

The text may be older than the law in force. The API serves HTML and a structure only for acts up to 2024: every act from 2025 on, consolidated texts included, is a PDF only (in November 2026 the newest consolidated Kodeks cywilny is Dz.U. 2026 poz. 795, PDF-only, while the newest one with text is from 2024). So GetArticleAsync reads exactly the act you give it and does not claim to be current: use GetCurrentTextAsync and read IsHtmlTextCurrent, NewestConsolidated and the amendments since before you rely on a quote. The base act's own HTML is its original text (for the civil code, 1964) and is offered only when the act has no consolidated text. An act without HTML gets metadata and a PDF link only; the library does not read PDFs. A repealed act, or a text that is no longer in force, is never reported as current (BaseActInForce, BaseActStatus). Regulations are read by paragraph: GetArticleAsync(id, "§ 2").

The API publishes no rate limit; the client does not retry. An article costs two requests (the structure, cached per client instance for its last 16 acts, and the text), the current-text check one plus up to five. Acts are public law (not protected by copyright); cite the source: Sejm RP, ELI API.

Offline VAT whitelist check

The Ministry of Finance publishes the VAT whitelist every day as a flat file (plik płaski) of hashed NIP and account pairs. PolishOpenData.BialaLista.Offline downloads the file for a date, builds a local index once, and then answers any number of checks from disk: no request limit, and nothing about the checked NIP/account pairs leaves your machine. Use it for large batches (a payment run, an ERP import); use PolishOpenData.BialaLista when you need a request ID as proof.

dotnet add package PolishOpenData.BialaLista.Offline

using Microsoft.Extensions.DependencyInjection;using PolishOpenData;using PolishOpenData.BialaLista.Offline;
var services = new ServiceCollection();services.AddVatWhitelistOffline(o => o.DatesToKeep = 3);using var provider = services.BuildServiceProvider();var offline = provider.GetRequiredService<IVatWhitelistOffline>();
await offline.PrepareAsync(); // optional: downloads and indexes today's file now instead of in the first checkvar checks = await offline.CheckManyAsync(new[]{    (Nip.Parse("774-000-14-54"), Nrb.Parse("06 1600 1127 1843 9838 2000 0034")),});foreach (var c in checks)    Console.WriteLine($"{c.Nip}: {c.Status} (file of {c.FileDate:yyyy-MM-dd}, generated {c.GeneratedOn:yyyy-MM-dd})");

• Three answers. Active, Exempt or NotFound. NotFound means not found in the file (the plain hash and every virtual-account mask of the account's bank were tried), not proof that the account is absent from the whitelist; MatchedVirtualAccountMask tells you when a pair was found through a mask.
• First use of a date is slow. It downloads about 250 MB and builds an index. That took about 4 minutes on a fast connection (October 2026), but much longer when the Ministry's server is slow, which happens during the working day. The download is deleted once the index is built. Call PrepareAsync ahead of time to avoid the wait: the Ministry publishes the file for day D at about 23:00 on D−1, so the evening before is a good moment. PrepareAsync takes an IProgress<VatWhitelistPreparationProgress> and a CancellationToken. The HTTP client registered by AddVatWhitelistOffline has no timeout; cancel through the token.
• Data directory and disk use. Prepared indexes live in PolishOpenData/BialaListaOffline under the user's local application data folder; set VatWhitelistOfflineOptions.DataDirectory to use another folder. An index takes about 60 MB per date (3.7 million entries in October 2026). DatesToKeep (default 5) is the number of most recently used dates kept on disk.
• One machine only. Use a folder on a local disk; a network share is not supported. Processes on the same machine that share the folder share the prepared indexes; while one process prepares a date, another that needs the same date waits up to LockTimeout (15 minutes by default) and then throws TimeoutException.
• Dates. From 30 days back to tomorrow (Warsaw time), default today. A date is only ever answered with the file of that date. Outside the window, or when the file is not published yet, cannot be downloaded or fails verification, the call throws VatWhitelistDataUnavailableException (see Reason) instead of answering with another day's data.
• No request ID, no evidence. The flat file gives no request identifier. When you need proof for the tax office, check with the REST client (PolishOpenData.BialaLista) and keep its RequestId.
• Time of the check and time of the data. FileDate and GeneratedOn describe the data; record when you ran the check yourself.

Parcels and geocoding

PolishOpenData.Uldk finds cadastral parcels (działki ewidencyjne) with GUGiK's ULDK service and PolishOpenData.Uug turns an address into coordinates with GUGiK's geocoder; the clients share the coordinate types of PolishOpenData.Geo.Core. Both services are public and need no key.

dotnet add package PolishOpenData.Uldkdotnet add package PolishOpenData.Uug

using Microsoft.Extensions.DependencyInjection;using PolishOpenData.Geo;using PolishOpenData.Uldk;using PolishOpenData.Uug;
var services = new ServiceCollection();services.AddUldkClient();services.AddUugClient();using var provider = services.BuildServiceProvider();var uug = provider.GetRequiredService<IUugClient>();var uldk = provider.GetRequiredService<IUldkClient>();
// Address -> coordinates -> parcel. Only an Address match is a point; a partial address gives a Street or City match.var matches = await uug.GeocodeAsync("Warszawa, Krucza 50");if (matches is [{ Kind: UugMatchKind.Address } match]){    var parcel = await uldk.GetParcelAtAsync(match.Location, ParcelGeometryKind.Wgs84);    Console.WriteLine($"{parcel?.Id}, {parcel?.CommuneName}");   // null: no parcel at that point    Console.WriteLine(parcel?.Geometry?.Wkt);                    // POLYGON((longitude latitude, ...)), EPSG:4326}
// By identifier or by region name and number ("Krzewina 134" can match several parcels, so there is no geometry).var byId = await uldk.GetParcelByIdAsync(ParcelId.Parse("146510_8.0507.41/1"));var byName = await uldk.FindParcelsAsync("Krzewina 134");

• Axis order. No position is a bare pair of doubles: Wgs84Point(Latitude, Longitude) and Pl1992Point(Easting, Northing) name their axes, and there are no X/Y members. Latitude comes first in Wgs84Point (Warsaw is about 52.2, 21.0), whereas WKT, including the geometry the library returns, writes longitude first. A swapped WGS-84 pair is rejected with ArgumentOutOfRangeException before any request, because the ranges for Poland (latitude 48.9 to 55.0, longitude 14.0 to 24.2) do not overlap.
• Not found is not an error. A parcel that does not exist is null, a search without a match an empty list. An answer that is an HTML page (the GUGiK firewall) throws PolishOpenDataApiException with ErrorCode = "blocked".
• What a parcel has. ID, number, region, commune, county, voivodeship, the bounding box in PL-1992 (Extent) and, on request, the boundary as WKT in PL-1992 or in WGS-84 (ParcelGeometryKind; WGS-84 costs one extra request). ULDK reports no area.
• An address point is not a property. It marks a building entrance, so the parcel found at it is the one under that entrance, not necessarily the whole property.
• Geometry maths. PolishOpenData.Geo.Nts (optional, depends on NetTopologySuite, works under Native AOT) turns the boundary into a NetTopologySuite geometry: var area = parcel.Geometry!.ToNtsGeometry().Area; is square metres when you asked for ParcelGeometryKind.Pl1992, and square degrees (not useful) for WGS-84. Pl1992Point.ToNtsPoint() and Wgs84Point.ToNtsPoint() give points in the same frame.
• Retries and parallelism. The libraries never retry. Registered with AddUldkClient or AddUugClient, a client opens at most 4 connections per service. If you want retries, add .AddStandardResilienceHandler() (from the Microsoft.Extensions.Http.Resilience package) to the returned builder, and keep them few.

Property prices

PolishOpenData.Rcn reads real estate transactions from GUGiK's RCN register (Rejestr Cen Nieruchomości) through its public WFS service: premises (flats, garages, shops), parcels and buildings, with price, date and place. It uses the coordinate types of PolishOpenData.Geo.Core and needs no key.

dotnet add package PolishOpenData.Rcn

using Microsoft.Extensions.DependencyInjection;using PolishOpenData.Geo;using PolishOpenData.Rcn;
var services = new ServiceCollection();services.AddRcnClient();using var provider = services.BuildServiceProvider();var rcn = provider.GetRequiredService<IRcnClient>();
// Flats sold in 2025 in a 300 m square in central Warsaw (PL-1992: easting, northing).var transactions = await rcn.GetTransactionsAsync(new RcnQuery{    Area = new Pl1992Bbox(new Pl1992Point(637800, 486300), new Pl1992Point(638100, 486600)),    From = new DateOnly(2025, 1, 1),    To = new DateOnly(2025, 12, 31),    PremisesFunction = RcnPremisesFunction.Residential,});var summary = transactions.Summarize();   // throws InvalidOperationException when transactions.TruncatedConsole.WriteLine($"{summary.Count} sales, median {summary.Median:N0} PLN/m², newest {summary.Newest}");

• Bounded queries only. An RcnQuery needs an area (Area, at most 25 km²) or a four-digit powiat code (PowiatCode; 1465 is Warsaw). The service has no gmina filter: use an area for anything smaller than a powiat. MaxRecords defaults to 1,000 (1 to 5,000). When more rows exist, Truncated is true, nothing is dropped silently and Summarize() throws: narrow the area, the period or the filters. The client sends one count-bounded request per page of 500 rows.
• Price per m² comes from the premises row. RcnTransaction.PricePerSquareMetre is the price of the premises divided by its usable area. It is never derived from TotalPrice, the price of the whole deed, which repeats on every row of a deed that covers several premises, parcels or buildings. It is null when the price or the area is missing, not a number or not positive. Garages and shops share the premises layer with flats, so filter with PremisesFunction (the MCP tool defaults to residential).
• Summarize() takes a market-price sample. It uses premises sales that have a price per m², no partial share (1/1 or none), a free-market or unstated kind of sale and ownership of the premises with the associated right (or no right stated). It reports the median, the quartiles (linear interpolation) and how many rows each exclusion removed; fewer than 5 sales are flagged SmallSample.
• RcnPriceStatistics.Classify says why a sale is left out. For a premises row it returns an RcnExclusionReason (None when the row counts in the statistics); Summarize() applies the same rule.
• The data lag by months. On 15 October 2026 the newest transaction in powiat 1465 was dated 28 May 2026. Check Newest before you quote a figure as current.
• Position and fields. Location is a Pl1992Point, the centre of the feature's envelope (the library does not read polygon geometry). Typed properties cover what has a meaning for a layer (date, market, rooms, floor, usable area, parcel and building identifiers, address); Fields holds every published field as text, including the notary's name and the deed number. A price, area, floor or room count that is empty or not a number is null (TotalPrice included) and the published text stays in Fields; a row without a date, an identifier or an envelope is an error. The client never retries and, registered with AddRcnClient, opens at most 4 connections. The service reports errors as HTTP 400 with an OGC exception report, which the client throws as PolishOpenDataApiException.

Live demo

The live demo puts the PolishOpenData.Uldk, PolishOpenData.Uug and PolishOpenData.Rcn packages on a map: type an address or click a place to see its cadastral parcel and what flats nearby sold for. It runs entirely in your browser, calls the GUGiK services directly and stores nothing itself (GUGiK's services may set their own cookies); it is unofficial, RCN data lag by months, and the figures are informational, not a valuation. The source is in demo/PolishOpenData.Demo.

MCP server for AI assistants

Requires the .NET 10 SDK. No API keys needed; the optional REGON tool needs your own free GUS key (see below). The parcel, geocoding and property price tools send every request to GUGiK, and retry a transient failure once.

[Install in VS Code] [Install in VS Code Insiders]

Claude Code

claude mcp add --transport stdio --scope user polish-open-data -- dotnet dnx PolishOpenData.Mcp --yes

Claude Desktop / Cursor (claude_desktop_config.json or .cursor/mcp.json)

{  "mcpServers": {    "polish-open-data": { "command": "dotnet", "args": ["dnx", "PolishOpenData.Mcp", "--yes"] }  }}

VS Code (.vscode/mcp.json)

{  "servers": {    "polish-open-data": { "type": "stdio", "command": "dotnet", "args": ["dnx", "PolishOpenData.Mcp", "--yes"] }  }}

Optional: the REGON tool. lookup_regon appears only when the server finds your own free GUS key in the environment variable POLISHOPENDATA_REGON_KEY; without it the server has no REGON tool and sends nothing to GUS. Apply for the key at GUS ([email protected]); it stays on your machine and is sent only to GUS. Add it to the server's env block, for example in claude_desktop_config.json or .cursor/mcp.json:

{  "mcpServers": {    "polish-open-data": {      "command": "dotnet",      "args": ["dnx", "PolishOpenData.Mcp", "--yes"],      "env": { "POLISHOPENDATA_REGON_KEY": "your-own-gus-key" }    }  }}

Optional: the CEIDG tool. lookup_ceidg appears only when the server finds your own CEIDG API token in the environment variable POLISHOPENDATA_CEIDG_TOKEN; without it the server has no CEIDG tool and sends nothing to CEIDG. Apply for the token on biznes.gov.pl (e-service 00_9999_00, Profil Zaufany login); it is personal, stays on your machine and is sent only to CEIDG. Set it in the same env block as in the REGON example above.

Statistics tools (no key). find_statistical_unit, search_statistics and get_statistics read GUS Bank Danych Lokalnych. They work without a key under GUS's anonymous limits (5 per second, 100 per 15 minutes); a free personal key from the BDL registration, set in POLISHOPENDATA_BDL_CLIENT_ID, raises them (a wrong key is not rejected, you silently get the anonymous limits). The data is CC BY 4.0.

Legal-act tools (no key). search_legal_acts, get_legal_act and get_legal_article read the Sejm ELI API. Read isCurrent and warning on every article: the API serves the text of acts as HTML only up to 2024, so for the Kodeks cywilny the tool quotes the 2024 consolidated text and says that a newer one (PDF-only) exists and which amendments came after it. A repealed act is never reported as current. Acts are public law; cite "Sejm RP, ELI API".

Claude Code (claude mcp add --env) and VS Code (env in .vscode/mcp.json) take the same variable.

Land-registry (KW) numbers

KwNumber validates numbers such as WA1M/00012345/1 offline using the official court-code table (Dz.U. 2026 poz. 740, 342 current codes plus 7 historical ones) and suggests fixes for common typos (0S1U → OS1U). It is a .NET port of the validation logic of pyekw by mhajder (MIT). It does not query the eKW portal and deliberately offers no number generator: KW numbers are personal data (NSA, III OSK 6508/21), and enumerating them is out of scope.

Responsible use

• Data comes from official public registers; cite the source and the retrieval time. Every registry-backed MCP tool result (lookup_company, check_vat_bank_account, check_vat_bank_account_offline, get_krs_extract) and BialaListaResult carry both (for the offline tool Source.RetrievedAt is the time of the check, while fileDate and generatedOn are the time of the data); KrsResult does not add one itself — use ToSummary().ExtractedAt when present.
• Biała Lista allows about 100 searches and 5,000 checks per day per IP address; exceeding them blocks the IP until midnight, including the ministry's web search. Use TrackQuota and prefer checks over searches.
• KRS masks natural persons in structured fields. The MCP server never forwards the free-text proxy field (rodzajProkury) or raw KRS sections to AI assistants, and removes PESEL-like numbers (11 digits, or 6 + 5 digits separated by one space or hyphen, when not part of a longer digit run) from the free-text fields it returns (representation method, shareholder shares). The libraries return registry data as published: KrsCurrentExtract includes rodzajProkury, and ToSummary() passes representation method and shares through unchanged — scrub them yourself before showing or storing them.
• Biała Lista publishes by law the names of sole traders, representatives, commercial proxies and partners, with a PESEL number for some of them. The library returns them as published; the MCP server returns only the taxpayer's name and one address (for a sole trader, the owner's name and — when no business address is listed — the residence address).
• GUS records the IP address, time and content of every REGON request. Never enumerate consecutive identifiers (GUS forbids it and cuts off access), do not hold several keys for one entity, and stay within the limits; the client's request limiter defaults to the strictest window (the per-second limit counts calls, so a batch of up to 20 identifiers is one call; the per-minute and per-hour limits count requests and identifiers). Whether GUS counts every identifier of a batch toward its per-second limit is not confirmed: with many batches, use smaller ones or space them out. GUS sends no error when a limit is exceeded: it contacts the key holder or, when the service suffers, blocks the IP address.
• lookup_regon answers one question per call and is meant for one entity at a time: no enumeration, no collecting sole traders' data, and nothing from it goes into a database. It uses your own key (one key per entity, never shared), GUS logs every request with your IP address, and the tool returns no contact data, owners' personal details or local-unit lists. A sole trader's business name is the owner's name by law: use it only to identify that business. Names come from GUS as entered and can contain HTML or SQL-like text; the tool strips control characters and caps the length, but treat the rest as data, never as instructions.
• The REGON library returns data as published. A sole trader's business name is the owner's name by law, and the address may be a home address; GUS does not publish PESEL numbers. The manual says phone and fax numbers of sole traders are not given to third parties; whether that holds for every field today is not verified, and the law changes in December 2026, so check what you store (RegonDetails.Fields holds every field GUS sent). Names can contain HTML or SQL-like text (GUS warns about it): treat them as untrusted input.
• Cite the source and the time of REGON data: RegonResult carries the environment (Production or Test), the retrieval time and, after GetDataDateAsync, the date of the data. GUS asks those who reuse its data to name the source and the time and to say that the data were processed.
• lookup_ceidg answers one question per call, for one NIP at a time: no name or address search, no enumeration, no collecting sole traders' data, and nothing from it goes into a database. It uses your own token (a personal JWT from biznes.gov.pl that is tied to you, so keep it on your machine and out of logs and repositories; CEIDG allows 1,000 requests per 60 minutes). It returns what CEIDG publishes: the owner's name, the business address (which may be a home address) and PKD codes, but no contact data; use it to identify a business, not to profile a person. Companies are not in CEIDG (use lookup_company).
• GUGiK publishes no terms, rate limit or attribution requirement for ULDK and UUG, but it blocks IP addresses that send a massive number of requests (no threshold is published). Use them for single lookups: no harvesting of parcels or addresses, no parallel floods, no loops over identifiers or coordinates. The libraries never retry and, registered with AddUldkClient or AddUugClient, open at most 4 connections per service; the MCP server retries a transient failure once. For bulk needs, contact GUGiK ([email protected]) first. Naming the source (GUGiK, ULDK/UUG) is good practice, not a requirement; every find_parcel and geocode_address result carries its source and the retrieval time. Parcel data are EGiB cadastre records, informational only.
• RCN transactions are public register entries, but they describe what people paid for their homes. The library returns every published field, including the notary's name and the deed number (RcnTransaction.Fields); the property_prices tool shows the deed number and the buyer and seller by kind only, never the notary. Do not use either to profile individuals or to find out who bought or sold a property. RCN has no land-registry (KW) field; free-text remarks (NIER_OPIS and the *_INFO fields) are returned as published in Fields, the MCP tool does not expose Fields, and nothing here links a transaction or a parcel to a land-registry number. GUGiK publishes no limit for RCN: send single, bounded queries (the client sends one count-bounded request per page of 500 rows), with no harvesting of the register and no loops over areas or periods. The data lag by months, and the price per m² is derived from the premises row: informational, not a valuation. Every property_prices result carries its sources and the retrieval time.
• No scraping, no bulk harvesting, and never land-registry (KW) numbers: the parcel and property tools neither accept nor return them or owner data, and nothing in this project links a parcel to a land-registry number. Do not try to build such a link from parcel data.

Possible next steps

Ideas, not commitments: more property data (for example zoning plans). If it would help you, open an issue to show interest.

Contributing and license

See CONTRIBUTING.md. MIT licensed. Third-party components and their licences are listed in THIRD-PARTY-NOTICES.md.