# Finland Company Register - PRH YTJ Y-tunnus Business Search (`publicdata/finland-prh-ytj-company-register`) Actor

Search and export Finnish companies from the official PRH / YTJ Business Information System. Filter by name, Business ID, town, postal code, legal form, line of business and registration date. Returns 26 fields per company and, by default, only companies still on the register.

- **URL**: https://apify.com/publicdata/finland-prh-ytj-company-register.md
- **Developed by:** [PublicData](https://apify.com/publicdata) (community)
- **Categories:** Lead generation, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.25 / 1,000 companies

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

**Export the Finnish company register as a spreadsheet: every company in the PRH / YTJ Business Information System, filtered by name, Business ID, town, postal code, legal form, line of business or registration date — and, by default, only the ones still trading.**

This Actor calls the open-data API of the Finnish Patent and Registration Office (`avoindata.prh.fi`) directly. No API key, no login, no scraped HTML: what you export is the register, licensed CC BY 4.0.

The register has 824,112 entries. **About half of them are companies that have ceased**, and PRH offers no way to exclude them. The Finland Company Register Actor filters them out before anything is exported, so you are not charged for defunct companies — and can flip the switch if the dead ones are exactly what you want.

### What you get

Every row is one company, with 26 fields:

- **Business ID** (Y-tunnus) and the current registered **name**, plus the **previous names** — a name search matches those too, so a row that looks unrelated is explained by its own `previousNames` cell
- **Status**: still on the register, ceased, start-up not registered, or unregistered — with the registration date, and the end date where there is one
- **Legal form** in English with the letter code the register accepts: OY limited company, OYJ public limited, KY limited partnership, AY partnership, OK co-operative, AOY housing company, SL branch of a foreign trader, SÄÄ foundation, and 19 more
- **Line of business** — code plus the description in **English and Finnish**. PRH publishes every description in three languages; this Actor keeps the English one so the export is usable outside Finland
- **Both addresses** in their own columns: the visiting address and the postal address, each with street, postal code and town
- **VAT registration**, read from the VAT register specifically, with what the company is VAT-liable for in the register's own wording
- A link to the official YTJ page, and the source attribution the licence requires

### Who uses this

- A **sales team** pulls every limited company in Helsinki registered under a given line of business, and gets a list where every row is a company that still exists.
- A **recruiter or founder** watches companies registered in the last 30 days in a town, and reaches them first.
- A **compliance analyst** resolves a Y-tunnus to legal form, status, addresses and VAT standing for a KYB file.
- A **market analyst** counts companies per town and industry straight from the register instead of estimating.
- A **developer or AI agent** keeps a Finland table fresh on a schedule, or calls the Actor as an MCP tool to answer company questions on demand.

### Example output

One real record, exported by this Actor on 2026-08-28 from Helsinki, line of business `62100`, legal form `OY`:

```json
{
  "businessId": "0248523-2",
  "name": "Blue Yonder Finland Oy",
  "previousNames": "JDA Technologies Oy",
  "legalForm": "Limited company",
  "legalFormCode": "OY",
  "legalFormType": "16",
  "status": "Registered",
  "statusCode": "1",
  "registrationDate": "1978-09-29",
  "endDate": null,
  "businessIdRegistrationDate": "1979-01-04",
  "businessLineCode": "62100",
  "businessLine": "Computer programming activities",
  "businessLineFi": "Ohjelmistojen suunnittelu ja valmistus",
  "streetAddress": "Kansakoulukuja 1",
  "streetPostCode": "00100",
  "streetCity": "HELSINKI",
  "postalAddress": null,
  "postalCode": null,
  "postalCity": null,
  "vatRegistered": true,
  "vatDetail": "VAT-liable for business activity",
  "inTradeRegister": true,
  "sourceUrl": "https://tietopalvelu.ytj.fi/yritys/0248523-2",
  "sourceApi": "avoindata.prh.fi/opendata-ytj-api/v3",
  "source": "Finnish Patent and Registration Office (PRH) / YTJ, CC BY 4.0"
}
```

### Input

| Field | What it does |
|---|---|
| `query` | Name match — current, previous, parallel and auxiliary names. |
| `businessId` | A single Y-tunnus, with the check digit, e.g. `0205709-4`. |
| `location` | Registered town, e.g. `HELSINKI`. |
| `postCode` | Five-digit postal code, matched against either address. |
| `companyForms` | Letter codes, e.g. `OY`. See the warning below. |
| `businessLine` | Industry code or free text. See the classification note below. |
| `registeredAfter` / `registeredBefore` | Registration-date window, `YYYY-MM-DD`. |
| `status` | `active` (default), `ceased`, or `any`. |
| `maxItems` | Stop after this many exported rows. `0` means no limit. |
| `includeRaw` | Attach the untouched PRH JSON to each row. |

### The industry code changed on 1 January 2026

This is the mistake that costs the most, and the register's own documentation walks you into it.

Finland re-registered every company's line of business under a new classification on **2026-01-01**. Codes were renumbered. PRH's API documentation still points at the older TOL 2008 codes — which now match only records frozen before the migration, and those are overwhelmingly companies that have ceased.

Measured on 2026-08-28, searching Helsinki for computer programming companies:

| Code | Classification | Matches | Still trading |
|---|---|---|---|
| `62010` | TOL 2008, the documented one | 44 | **0%** |
| `62100` | current | 3,583 | **99%** |

Same activity, different number, 81× the results and all of them alive. This Actor checks the first page of every industry search and **writes a warning into the run log** naming the retired classification when your code looks like an old one, so you find out during the run instead of after the export.

### Legal form: letter codes only

The register accepts `OY`, and silently ignores `16` — the numeric type that appears inside the data for exactly the same thing. "Silently" means HTTP 200 and **all 824,112 companies**, as though no filter had been sent. Under pay-per-result billing that is an invoice for the whole country.

This Actor refuses a code that is not on the register's list rather than run that query, and the error names the letter code you probably meant.

### Half the register has ceased

824,112 entries, of which roughly half are no longer trading. PRH has no status parameter, so `status` is applied by this Actor as rows arrive — and **a row dropped by it is never charged**, because the charge follows the row into the dataset.

Results come back ordered by Business ID, which is roughly oldest first, so a broad search with `status: active` reads through older ceased companies before it reaches newer live ones. That is the register's ordering, not a delay in the Actor.

### Pricing

Pay per result: charged once per company row actually exported. A search that matches nothing costs nothing beyond the platform's start event.

### Where the data comes from

The Finnish Patent and Registration Office publishes the Business Information System (YTJ) as open data under **CC BY 4.0**, declared in the API's own OpenAPI document. The licence requires attribution, which is why every row carries a `source` field naming PRH and the licence — keep it in whatever you build. PRH also asks that services built on the data do not use the PRH or YTJ logo or otherwise resemble PRH's own services.

### Frequently asked questions

**Can I use this commercially?**
Yes — CC BY 4.0 permits it, provided you attribute the Finnish Patent and Registration Office. The `source` column carries the attribution string for you.

**How current is the data?**
The Actor queries the live API at run time. A company registered yesterday is available today; there is no cached copy in between.

**Why does my industry search return old, dead companies?**
Because the code is from the classification retired on 2026-01-01. See the table above — `62010` and `62100` are the same activity in the two schemes. The run log names the problem when it detects it.

**Why did my legal-form filter return the whole register?**
It did not, in this Actor — it refuses to run. The underlying API ignores an unrecognised code and returns everything, which is why the check exists. Use `OY`, not `16`.

**Can I export all 824,112 companies in one run?**
Yes in principle: the API pages 100 at a time with no offset ceiling, so nothing is unreachable. Expect a long run, and set `maxItems` deliberately, since every exported row is billed.

**Do I get directors, owners or financial statements?**
No. Those live in separate PRH services with their own terms. This Actor stays within the open Business Information System.

**Does it work as an MCP tool?**
Yes. Like every Apify Actor it exposes an MCP endpoint, so an AI agent can call the Finland Company Register Actor and get structured rows back.

### Related Actors

- **Norway Company Register Search** — the same job for the Norwegian Brreg register
- **France Company Register Scraper** — France, with named directors
- **Brazil CNPJ Lookup** — resolve Brazilian company identifiers
- **GLEIF LEI Scraper** — Legal Entity Identifiers, for joining registers across countries

# Actor input Schema

## `query` (type: `string`):

Matches current, previous, parallel and auxiliary company names. A row matched through an old name carries it in previousNames. Example: Nokia

## `businessId` (type: `string`):

Finnish Business ID (Y-tunnus), including the check digit. Example: 0205709-4

## `location` (type: `string`):

Registered town or city, as held by the register. Example: HELSINKI

## `postCode` (type: `string`):

Five-digit Finnish postal code, matched against the street or the postal address. Example: 00100

## `companyForms` (type: `array`):

Letter codes only. OY limited company, OYJ public limited, KY limited partnership, AY partnership, OK co-operative, AOY housing company, SL branch of a foreign trader, SÄÄ foundation. Full list: AOY, ASH, ASY, AY, AYH, ETS, ETY, HY, KOY, KVJ, KVY, KY, OK, OP, OY, OYJ, SCE, SCP, SE, SL, SP, SÄÄ, TYH, VALTLL, VOJ, VOY, VY. The numeric type stored inside the data (16 for a limited company) is NOT accepted by the register, which silently returns every company instead - this Actor refuses unknown codes rather than run up that bill.

## `businessLine` (type: `string`):

Statistics Finland industry code, or free text. IMPORTANT: Finland re-registered every company under a new classification on 2026-01-01 and the numbers changed - computer programming is 62100 now and was 62010 before. An old code mostly returns companies that have already ceased, so this Actor warns in the log when your code looks retired.

## `registeredAfter` (type: `string`):

Only companies entered in the register on or after this date (YYYY-MM-DD). Leave empty for no lower bound.

## `registeredBefore` (type: `string`):

Only companies entered in the register on or before this date (YYYY-MM-DD). Leave empty for no upper bound.

## `status` (type: `string`):

About half of the register is companies that have ceased. The register has no status filter of its own, so this is applied here - rows dropped by it are never charged.

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

Stop after this many exported companies. 0 means no limit. Results are ordered by Business ID, which is roughly oldest first.

## `includeRaw` (type: `boolean`):

Add the untouched PRH JSON for each company in a raw field.

## Actor input object example

```json
{
  "status": "active",
  "maxItems": 100,
  "includeRaw": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

One row per company from the PRH/YTJ register, with legal form, status, line of business and addresses. Every exported row is one dataset item.

# 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 = {
    "registeredAfter": "",
    "registeredBefore": "",
    "maxItems": 100
};

// Run the Actor and wait for it to finish
const run = await client.actor("publicdata/finland-prh-ytj-company-register").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 = {
    "registeredAfter": "",
    "registeredBefore": "",
    "maxItems": 100,
}

# Run the Actor and wait for it to finish
run = client.actor("publicdata/finland-prh-ytj-company-register").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 '{
  "registeredAfter": "",
  "registeredBefore": "",
  "maxItems": 100
}' |
apify call publicdata/finland-prh-ytj-company-register --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,publicdata/finland-prh-ytj-company-register"
        }
    }
}

```

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/ay7XDwooaziGXcJCd/builds/8WFgY9z9zeUkyVUxs/openapi.json