# Finland Company Registry Lookup (`thesjostrandproject/fi-company-lookup`) Actor

Look up Finnish companies by name, Business ID, municipality or company form through the public open company-register API. Clean, typed records for legal entities only: no sole traders, no street addresses, no officers. No login, no scraping. Pay per record.

- **URL**: https://apify.com/thesjostrandproject/fi-company-lookup.md
- **Developed by:** [The Sjöstrand Project](https://apify.com/thesjostrandproject) (community)
- **Categories:** Business, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$3.00 / 1,000 company records

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Finland Company Registry Lookup

### What this Actor returns

Look up Finnish companies by name, Business ID (Y-tunnus), municipality or company form, and get one clean, typed record per company. Every record has the same 13 fields, and a value the source does not have is `null`, never a missing key.

- `business_id`, `company_title`, `company_form`: the Business ID, the current registered name and the current company form
- `registration_date`, `end_date`, `company_status`, `liquidation_status`: when it was registered and dissolved, its Trade Register status, and any liquidation, bankruptcy or re-organisation in force
- `main_industry_code`: the main line of business, as a TOL 2008 code
- `municipality`, `postcode`, `city`, `website`: the municipality code, postcode and city of its address, and its registered website
- `source_updated_at`: the date the source last modified the company's record

The Actor reads Finland's public open company-data API and nothing else. It does not scrape any website, and there is no login.

### Who it helps

- **Sales and research teams** who want a tidy list of Finnish limited companies in one town or of one company form, ready for a spreadsheet or a database.
- **Developers** who want to check or enrich a Business ID inside their own workflow, through the Apify API, without writing their own client for the source.

### Quick start

1. Open the Input tab and leave the defaults as they are. They look up one company by its Business ID, so a first run returns a single record.
2. Press Start. Try it on one record first; it costs a fraction of a cent.
3. Open the Output tab, check the record, then search by name, municipality or company form. Clear the Business ID first, or it stays in the search.

### Input

| Field | What it does | Default |
|---|---|---|
| Company name | Part of a company's name. The source also matches earlier, parallel and auxiliary names. | empty |
| Business ID | A Business ID: seven digits, a hyphen and a check digit, like `0112038-9`. | `0112038-9` |
| Municipality | A town or city name, like `Espoo`. | empty |
| Company form | The source's code for the company form, like `OY` (limited company) or `OYJ` (public limited company). The Input tab lists all 27 codes. | empty |
| Maximum records | How many records to return at most, from 1 to 1000. | 10 |

Give at least one of name, Business ID, municipality or company form.

### Output

One record per company. The record below is what the default input returned on 12 October 2026, unchanged except for the website.

```json
{
  "business_id": "0112038-9",
  "company_title": "Nokia Oyj",
  "company_form": "Public limited company",
  "registration_date": "1896-12-19",
  "end_date": null,
  "main_industry_code": "70100",
  "company_status": "Registered",
  "liquidation_status": null,
  "municipality": "049",
  "postcode": "02610",
  "city": "ESPOO",
  "website": "(the company's registered website)",
  "source_updated_at": "2026-08-19"
}
```

In a real record, `website` is the web address the company registered.

### What it costs

You pay for one event, **Company record**, at $0.003 per record returned. Apify also adds its standard run-start event, $0.00005 per start for an Actor run with up to 1 GB of memory; it is the platform's own event, not ours. The default run returns one record and costs $0.00305. Records the Actor leaves out (see below) are never charged.

For example, a search that returns 200 companies costs $0.60. If your Apify plan includes monthly credit, a small run draws on that credit.

If the source cannot be reached or keeps answering with errors, the run stops with a clear status message, and only the records already returned are charged.

### Limits and honest notes

- **Legal entities only.** Sole traders are natural persons whose company name is their own name, so they are left out. A company whose current form is not one of the 27 forms the source lists is left out too, and so is one whose form is unknown.
- **No street addresses, officers or contact details.** The Actor copies only the 13 fields above. The postcode and city come from the street address, or from the postal address when there is no street address, which can be a PO box. A website that is not a plain address, such as an email address, is shown as `null`.
- **Names can still be personal.** A partnership, a limited partnership or a branch of a foreign trader can carry a person's name in its registered name. One limit no filter can fix. What you do with such records is your responsibility under the data-protection rules that apply to you.
- **Municipality.** The search takes a town or city name. The `municipality` field of a record is the source's municipality code, such as `049`, and `city` holds the name.
- **Status.** `company_status` is the company's status on the Finnish Trade Register. `liquidation_status` is `null` when the source lists no liquidation, bankruptcy or re-organisation without an end date.
- **Up to 1000 records per run.** For more, split the search by municipality or company form.
- **Pace.** The source states no rate limit. The Actor sends at most one request per second and when the source is busy it waits as asked, up to about a minute per request, and then stops with a clear message, so a large search can take a while; the source sometimes needs several seconds to answer one page.
- **Freshness** follows the source. `source_updated_at` tells you when the source last modified each record.

### Questions

**Why did my run return fewer records than I asked for?**
Either fewer companies matched, or some matches were left out because they are not legal entities or lacked a name, a form or a status. You were not charged for those.

**What does the run say when something is wrong?**
It says what it found and what to try. "Give at least one of: a name, a Business ID, a municipality or a company form" means the input was empty: add one. A message about the Business ID or the company form names the field to fix and shows the right shape. "Could not be reached" or "kept answering" means the source is busy; wait a few minutes and run again.

**Can I search for a company that has ceased?**
Yes. Look at `company_status` and `end_date`.

**How do I list the companies of one form?**
Clear the Business ID, pick the form code, for example `OYJ`, and set Maximum records.

**Does it return the people behind a company?**
No. Officers and other people are not in the output.

**Can I run it on a schedule?**
Yes, with the Apify scheduler or the API. Each run is independent and charged per record returned.

### Data source and AI note

Data source: Finnish Patent and Registration Office (PRH), CC BY 4.0. The records come from the open data API of the Business Information System (YTJ), reused under the Creative Commons Attribution 4.0 International licence. `source_updated_at` gives the date the source last modified each record.

This tool is not affiliated with, endorsed by or sponsored by the Finnish Patent and Registration Office or the Business Information System, and it does not use their logos.

This tool was built with the help of AI coding assistants.

### Help

Questions, a record that looks wrong, or an idea for a field: please open an issue on the Issues tab. Thank you for the report; every one is read.

# Actor input Schema

## `name` (type: `string`):

Part of a company's name. The source also matches earlier names, parallel names and auxiliary names. Leave empty to search by the other fields.

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

A Finnish Business ID (Y-tunnus): seven digits, a hyphen and a check digit, like 0112038-9. Leave empty to search by the other fields.

## `municipality` (type: `string`):

A town or city, like Espoo or Oulu. Leave empty for any.

## `companyForm` (type: `string`):

Only companies of this form, by the source's code, like OY. The codes: OY (limited company), OYJ (public limited company), KY (limited partnership), AY (partnership), OK (co-operative), OP (co-operative bank), SÄÄ (foundation), AYH (non-profit association), AOY (housing company), ASY (right-of-occupancy association), ASH (resident-administered area), KOY (limited liability joint-stock property company), TYH (association for carrying on economic activity), SP (savings bank), HY (mortgage society), KVJ (public mutual insurance company), KVY (mutual insurance company), VOJ (public limited insurance company), VOY (limited insurance company), VY (insurance association), VALTLL (state-owned company), SL (branch of a foreign trader), SE (European company), SCE (European co-operative society), SCP (European co-operative bank), ETY (European economic interest grouping), ETS (Finnish branch of a European economic interest grouping). Leave empty for any.

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

How many records to return at most, from 1 to 1000. You pay only for records returned.

## Actor input object example

```json
{
  "name": "",
  "businessId": "0112038-9",
  "municipality": "",
  "companyForm": "",
  "maxItems": 10
}
```

# Actor output Schema

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

The companies of this run, one per company, with the 13 fields described in the dataset schema (Business ID, name, form, dates, status, address, website).

# 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 = {
    "name": "",
    "businessId": "0112038-9",
    "municipality": "",
    "companyForm": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("thesjostrandproject/fi-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 = {
    "name": "",
    "businessId": "0112038-9",
    "municipality": "",
    "companyForm": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("thesjostrandproject/fi-company-lookup").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 '{
  "name": "",
  "businessId": "0112038-9",
  "municipality": "",
  "companyForm": "",
  "maxItems": 10
}' |
apify call thesjostrandproject/fi-company-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thesjostrandproject/fi-company-lookup"
        }
    }
}
```

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/ElGQvKR46107SITYK/builds/6wJP840wrXseg2zkJ/openapi.json