# Finnish Company Lookup - Official Registry Data (PRH) (`fabriken2026/finnish-company-lookup`) Actor

Look up Finnish companies by Business ID (Y-tunnus): status incl. bankruptcy, legal form, TOL industry code. Official PRH registry data - never scraped.

- **URL**: https://apify.com/fabriken2026/finnish-company-lookup.md
- **Developed by:** [David](https://apify.com/fabriken2026) (community)
- **Categories:** AI, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$6.00 / 1,000 successful company lookups

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.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/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

## Finnish Company Lookup - Official Registry Data (PRH)

**Verified official source - never hallucinated.** This Actor answers
Finnish company questions with registry data fetched from the **Finnish
Patent and Registration Office (PRH)** at lookup time - not with an AI
model's guess and not with a scraped snapshot of somebody's website.

### Why this Actor?

LLMs and AI agents hallucinate Finnish company facts just as happily as
any others: made-up Business IDs, wrong legal status, and no knowledge
of last month's bankruptcies or liquidations. Generic AI web search is
not much better - it summarises whatever page ranks first, which may be
stale, unofficial or plain wrong. This Actor gives your agent (or
workflow) a deterministic, verifiable lookup against the official
Finnish company register (the Finnish Business Information System, YTJ)
via PRH's open data API.

- **No AI in the loop.** Pure, predictable data lookup. Same input,
  same output, every time.
- **No scraping.** Official open API only - stable fields, no broken
  selectors, no terms-of-service grey zones.
- **Fresh at the source.** Registry data at lookup time, not
  training-data time. The source is updated daily.
- **Live from day one.** The Finnish open data API requires no API key
  at all.
- **GDPR-safe by design** (see below).

### Features

- **Look up any Finnish limited company by Business ID** (Y-tunnus),
  with or without hyphen, up to 50 per run. The VAT format
  `FI01120389` is also accepted.
- **Check if a Finnish company is active** - current registry status
  including bankruptcy (konkurssi), liquidation (selvitystila),
  company reorganisation (saneeraus) and dissolution.
- **Get the TOL 2008 industry code of a Finnish company** together
  with its plain-text industry description.
- **Verify a Finnish Business ID** - the official modulus-11 checksum
  is validated before any lookup, so typos never reach the API and are
  never charged.
- **Find the registration date, address municipality and website** of
  any Finnish limited company (osakeyhtiö).
- **Get financial key figures** - optionally extract revenue, operating
  profit, net income, equity, total assets, cash and liabilities from
  the latest digitally filed annual report (Finnish SBR/XBRL taxonomy),
  plus the full list of filed fiscal periods.

### Use cases

- **KYB / know-your-business checks:** verify that a Finnish
  counterparty exists, is active and is what it claims to be, before
  onboarding.
- **AI agents that must not hallucinate:** give Claude, ChatGPT or any
  MCP/tool-calling agent a grounded source for Finnish company facts.
- **Nordic supply-chain vetting:** Nordic groups usually have entities
  in several countries - combine this Actor with its Swedish and
  Norwegian siblings to screen the whole chain in one workflow.
- **CRM enrichment and data cleaning:** batch-verify Business IDs and
  refresh status, industry and municipality for existing records.
- **Compliance workflows:** document that a fact came from the official
  register, with source and retrieval date on every row.

### Input

```json
{
    "businessIds": ["0112038-9", "1927400-1"],
    "includeFinancialsStatus": true
}
````

Up to 50 Business IDs per run, with or without hyphen. Numbers are
validated with the official modulus-11 check before any lookup.

### Output (dataset items)

```json
{
    "input": "0112038-9",
    "ok": true,
    "businessId": "0112038-9",
    "name": "Nokia Oyj",
    "status": "Aktivt",
    "legalForm": "Publikt aktiebolag",
    "legalFormCode": "OYJ",
    "tolCode": "70100",
    "tolText": "Verksamheter som utövas av huvudkontor",
    "addressMunicipality": "ESBO",
    "registrationDate": "1896-12-19",
    "website": "www.nokia.com",
    "digitalFinancials": { "available": false },
    "source": "PRH, Patent- och registerstyrelsen / YTJ öppna data (avoindata.prh.fi), CC BY 4.0",
    "sourceDate": "2026-07-11"
}
```

Status values include active, bankruptcy, liquidation, company
reorganisation and dissolved states, always with the registry's
registration date when available. Invalid numbers, GDPR-rejected
entities and companies that are not found come back as items with
`ok: false` and an explanation - and are **never charged**. The run
itself still succeeds, so your pipeline never breaks on a bad input row.

### Pricing (pay-per-event)

| Event | Price | When |
|---|---|---|
| `company-lookup` | $0.006 | Per successful lookup only (financial statements with key figures included) |

That is ~$6 per 1,000 companies. Failed validations, GDPR-rejected
entities and not-found results are free. No subscription, no minimum,
no rental fee.

### FAQ

**Is there a free API for Finnish company data?**
PRH's open data API is free at the source, but you still need input
validation, checksum logic, status-code decoding (three separate status
fields plus situation codes), GDPR filtering and rate-limit discipline.
This Actor packages all of that into one call at $0.006 per company -
you pay for the plumbing, not the data.

**How do I check if a Finnish company is bankrupt?**
Run its Business ID through this Actor and read the `status` field,
which reflects the register at lookup time - including bankruptcy,
liquidation and company reorganisation, each with its registration date.

**Does it work with sole traders (toiminimi)?**
No - and they are not even present in the source. PRH's open data
excludes private traders for privacy reasons, and this Actor
additionally rejects any entity whose legal form cannot be verified
as a limited company (OY/OYJ).

**What financial data do I get?**
Which fiscal periods have a digitally filed annual report, plus
`keyFigures` extracted from the latest one: revenue, operating profit,
net income, equity, total assets, cash and total liabilities, decoded
from the official Finnish SBR/XBRL taxonomy. Anything not
deterministically interpretable is reported as missing - never
guessed. Note that listed companies file via ESEF and are usually
absent from this open dataset.

**Can my AI agent use this?**
Yes - that is the primary design goal. Call it from any agent framework
via the Apify API or via MCP. The output is small, flat JSON that fits
comfortably in an agent's context window.

**How fresh is the data?**
Every lookup goes to the registry API at run time, and PRH updates the
open data daily. You get what the register shows now, not what a model
memorised during training.

**Why should I trust these results over an AI web search?**
Because nothing here is generated. Every field is copied from the
official register and every row carries `source` and `sourceDate`, so
the answer is auditable.

### GDPR & privacy by design

This Actor handles **legal entities only**:

- Only limited companies (OY/OYJ) are supported in v1. Entities whose
  legal form cannot be determined are always rejected, and nothing
  from the source response is returned for them.
- Board members, managing directors and any other natural persons are
  **never** returned. The output is a strict allowlist of
  company-level fields.
- The source itself excludes private traders (toiminimi) and contains
  no e-mail addresses or phone numbers - this Actor's gate sits on top
  of that protection.

### Permissions & security

This Actor runs with Apify's **limited permissions** model: it reads
its own input, writes to its own default dataset and calls the official
registry API over HTTPS - nothing else. It requests no access to your
other Actors, storages or account data. No API key or login is needed
anywhere in the chain.

### Data source & license

Data comes from the **Finnish Patent and Registration Office (PRH)**
open data service: the Finnish Business Information System (YTJ) and
the open XBRL financial statements API. Data: Finnish Patent and
Registration Office (PRH), avoindata.prh.fi, licensed under
[CC BY 4.0](https://creativecommons.org/licenses/by/4.0/). **The data
has been reformatted and filtered for this service.** This Actor is
independent and not affiliated with or endorsed by PRH. Registry
data may contain errors or lag; always verify critical facts directly
at ytj.fi or prh.fi before acting on them.

### Terms of use

- **Business use only.** This Actor is intended exclusively for use in
  the course of business (B2B). By using it you confirm you are acting
  as a business, not a consumer.
- **As is.** The service and all data are provided "as is", without
  warranties of any kind - no guarantee of accuracy, completeness,
  timeliness or availability.
- **Liability cap.** Total aggregate liability for all claims in any
  12-month period is limited to the amount you paid for the service in
  that period. No liability for indirect or consequential damages, lost
  profits or lost data. Nothing in these terms limits liability that
  cannot lawfully be limited.
- **Fair use.** No bulk re-selling of raw data, no circumventing rate
  limits, no use that violates the CC BY 4.0 license (including
  presenting the data in a misleading way or implying PRH endorsement).

### Versioning & support

Versions are locked - the Actor never silently changes behaviour under
you. Changes are released as new versions with a changelog entry.

Part of the **Nordic Data Tools** family: Swedish company lookup,
company financials, new company registrations, procurement search,
official statistics, Norwegian company lookup and EU contract award
lookup - all built on official Nordic and EU data sources.

#### Changelog

- **0.2** - financial statements upgraded: `keyFigures` (revenue,
  operating profit, net income, equity, total assets, cash,
  liabilities) extracted from the latest XBRL filing - never guessed.
- **0.1** - initial release: status (incl. bankruptcy, liquidation,
  reorganisation), legal form, TOL 2008 industry code, address
  municipality, registration date and website for Finnish limited
  companies (OY/OYJ), plus optional digital financial statement
  status. Pay-per-event pricing.

# Actor input Schema

## `businessIds` (type: `array`):

Finnish Business IDs (Y-tunnus), 7 digits + check digit, with or without hyphen, e.g. <code>0112038-9</code>. The VAT format <code>FI01120389</code> is also accepted. Max 50 per run. Only limited companies (OY/OYJ) are returned; entities whose legal form cannot be determined are always rejected for GDPR reasons.

## `includeFinancialsStatus` (type: `boolean`):

Also check the registry's open XBRL data: which fiscal periods have a digitally filed annual report, plus key figures extracted from the LATEST period (revenue, operating profit, net income, equity, total assets, cash, liabilities - Finnish SBR taxonomy). Included in the same per-lookup price. Figures are never guessed: anything not deterministically interpretable is reported as missing.

## Actor input object example

```json
{
  "businessIds": [
    "0112038-9",
    "1927400-1"
  ],
  "includeFinancialsStatus": false
}
```

# 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 = {
    "businessIds": [
        "0112038-9",
        "1927400-1"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("fabriken2026/finnish-company-lookup").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 = { "businessIds": [
        "0112038-9",
        "1927400-1",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("fabriken2026/finnish-company-lookup").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 '{
  "businessIds": [
    "0112038-9",
    "1927400-1"
  ]
}' |
apify call fabriken2026/finnish-company-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=fabriken2026/finnish-company-lookup",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Finnish Company Lookup - Official Registry Data (PRH)",
        "description": "Look up Finnish companies by Business ID (Y-tunnus): status incl. bankruptcy, legal form, TOL industry code. Official PRH registry data - never scraped.",
        "version": "0.1",
        "x-build-id": "EvPqmw6HMGo0rHOUf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/fabriken2026~finnish-company-lookup/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-fabriken2026-finnish-company-lookup",
                "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/fabriken2026~finnish-company-lookup/runs": {
            "post": {
                "operationId": "runs-sync-fabriken2026-finnish-company-lookup",
                "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/fabriken2026~finnish-company-lookup/run-sync": {
            "post": {
                "operationId": "run-sync-fabriken2026-finnish-company-lookup",
                "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": [
                    "businessIds"
                ],
                "properties": {
                    "businessIds": {
                        "title": "Business IDs (Y-tunnus)",
                        "type": "array",
                        "description": "Finnish Business IDs (Y-tunnus), 7 digits + check digit, with or without hyphen, e.g. <code>0112038-9</code>. The VAT format <code>FI01120389</code> is also accepted. Max 50 per run. Only limited companies (OY/OYJ) are returned; entities whose legal form cannot be determined are always rejected for GDPR reasons.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "includeFinancialsStatus": {
                        "title": "Include digital financial statements (periods + key figures)",
                        "type": "boolean",
                        "description": "Also check the registry's open XBRL data: which fiscal periods have a digitally filed annual report, plus key figures extracted from the LATEST period (revenue, operating profit, net income, equity, total assets, cash, liabilities - Finnish SBR taxonomy). Included in the same per-lookup price. Figures are never guessed: anything not deterministically interpretable is reported as missing.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
