# Estonia Company Registry Lookup (`thesjostrandproject/ee-company-lookup`) Actor

Search Estonian companies by name, registry code, city or legal form and get one record per company from the daily open register data. Fields: registry code, name, legal form, status, VAT number, first entry date, postcode, city. No contacts, street addresses or sole traders. Pay per record.

- **URL**: https://apify.com/thesjostrandproject/ee-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

## Estonia Company Registry Lookup

### What this Actor returns

Search Estonian companies by name, registry code, city or legal form, and get one clean, typed record per company. Every record has the same 10 fields, and a value the register does not have is `null`, never a missing key.

- `registry_code`, `legal_entity_title`: the 8-digit registry code and the registered name
- `legal_form`, `legal_subtype`, `status`: the legal form, a finer subtype where there is one, and whether the company is entered, in liquidation or in bankruptcy
- `vat_number`, `first_entry_date`: the VAT number and the date of first entry in the register
- `postcode`, `city`, `source_updated_at`: where it is registered, and the date of the register file the record was read from

The Actor reads the Estonian business register's published open-data file and nothing else. It does not scrape any website, it does not use the register's paid query service, and there is no login.

### Who it helps

- **Analysts and sales teams** who want a tidy list of Estonian companies of one legal form or in one city, ready for a spreadsheet or a database.
- **Developers** who want to check or enrich an Estonian registry code inside their own workflow, through the Apify API, without handling the register's bulk file themselves.

### Quick start

1. Open the Input tab and leave the defaults as they are. They look up one company by its registry code, 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, city or legal form.

### Input

| Field | What it does | Default |
|---|---|---|
| Company name contains | Only companies whose registered name contains this text, ignoring upper and lower case. | empty |
| Registry code | The 8-digit registry code of one company. A code is unique, so the search ends at its match. | `10421629` |
| City or settlement contains | Only companies registered in a town, city or village whose name contains this text. | empty |
| Legal form contains | Only companies whose legal form contains this text, in the register's Estonian words: `Osaühing`, `Aktsiaselts`, `Mittetulundusühing`, `Sihtasutus` and so on. | empty |
| Maximum records | How many records to return at most, from 1 to 1000. | 10 |

Give at least one of the four filters. When you give several, a company must match all of them.

### Output

One record per company. The record below is what the default input returned on 13 October 2026, unchanged.

```json
{
  "registry_code": "10421629",
  "legal_entity_title": "Eesti Energia AS",
  "legal_form": "Aktsiaselts",
  "legal_subtype": null,
  "vat_number": "EE100366327",
  "status": "Registrisse kantud",
  "first_entry_date": "1998-03-31",
  "postcode": "11318",
  "city": "Tallinn",
  "source_updated_at": "2026-10-12"
}
```

`status` is the register's own word: `Registrisse kantud` (entered in the register), `Likvideerimisel` (in liquidation) or `Pankrotis` (in bankruptcy). `city` is the town, city or village of the registered address; for Tallinn it is `Tallinn`, not the district, and for other towns it is the register's own wording, like `Tartu linn`.

### 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 GB of run memory; this Actor runs in at most 1 GB, so it is at most $0.00005 per start. It is the platform's own event, not ours. Records the Actor leaves out (see below) are never charged.

The default run returns one record, so it costs $0.003 plus at most $0.00005 for the start, at most $0.00305 in all. A search that returns 200 companies costs $0.60 plus the start event. If your Apify plan includes monthly credit, a small run draws on that credit.

If the source cannot be reached, the run stops with a clear status message, and only the records already returned are charged. When the source is busy it waits as asked, up to about a minute per request, and then stops with a clear message.

### Limits and honest notes

- **Companies only, no sole proprietors.** Sole proprietors (`Füüsilisest isikust ettevõtja`) are left out, because their registered name is usually the owner's own name. A record whose legal form is missing is left out too, because nothing shows it is a company.
- **No contacts, street addresses, people or finances.** The Actor reads the register's basic data file only and copies only the 10 fields above. There is no email, phone or web address, no street or house number, no board members, shareholders or owners, and no annual-report figures. Activity area and share capital are not included.
- **Names can still be personal.** One limit no filter can fix: a company's registered name can itself contain a person's name.
- **Coverage and freshness** follow the register's file. RIK says the files are updated once a day and hold only companies currently in the register (entered, in liquidation or in bankruptcy). `source_updated_at` tells you the date of the file the record was read from.
- **How a search works.** The register offers no search service for open data, only the whole file, so each run reads the file from the start (about 19 MB, compressed) and stops as soon as it has your records. A search with few matches reads all of it; when we tested it that took about five seconds.

### 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 sole proprietors or lack a core field. You were not charged for those.

**What does the run say when something is wrong?**
It says what it found and what to try. "Invalid input: give at least one of name, registryCode, city or legalForm" means every filter was empty. "Could not be reached" or "kept answering HTTP ... (busy)" means the register's file server is down or busy; wait a few minutes and run again. "Ended early" means the download stopped half way; run again. "Its format may have changed" means the register changed its file; please report it on the Issues tab.

**Why are some postcodes and cities null?**
The register gives no Estonian address for some companies, for example ones registered abroad. Those fields are then `null`.

**Can I search for a company that is in liquidation or bankruptcy?**
Yes. Look at `status`.

**Does it return the people behind a company?**
No. 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: the Estonian e-Business Register's open-data "Basic data" file, published by RIK, the Centre of Registers and Information Systems. The e-Business Register open data is reused under the Creative Commons Attribution 4.0 International licence (CC BY 4.0, licence text at https://creativecommons.org/licenses/by/4.0/legalcode). Contains data from RIK. Each record's source_updated_at gives the date of the file it was read from. The Actor changes the data: it selects records (sole proprietors and records missing a core field are left out) and fields, takes the postcode and the city from the register's address text (the city is worked out from the register's location text), and puts dates in ISO form (YYYY-MM-DD) instead of the register's dd.mm.yyyy. It also trims spaces around values.

This tool is not affiliated with, endorsed by or sponsored by RIK or the Estonian state.

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`):

Only companies whose registered name contains this text, ignoring upper and lower case, like Tallinna Sadam. Leave empty for any name.

## `registryCode` (type: `string`):

The 8-digit registry code of one company. The default, 10421629, is an example company that returns one record; replace it with your own, or clear it to search by the other filters. A registry code is unique, so a search by code ends at its match.

## `city` (type: `string`):

Only companies registered in a town, city or village whose name contains this text, like Tartu. Tallinn companies show the city Tallinn, not the district. Leave empty for anywhere.

## `legalForm` (type: `string`):

Only companies whose legal form contains this text, in the register's Estonian words, like Osaühing (private limited company), Aktsiaselts (public limited company), Mittetulundusühing (non-profit) or Sihtasutus (foundation). Leave empty for any form.

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

How many company records to return at most (1 to 1000). You pay only for records returned, so a first run stays cheap.

## Actor input object example

```json
{
  "name": "Tallinna Sadam",
  "registryCode": "10137319",
  "city": "Tartu",
  "legalForm": "Aktsiaselts",
  "maxItems": 10
}
```

# Actor output Schema

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

The company records of this run, one per company, with the 10 fields described in the dataset schema (registry code, name, legal form, status, first entry date, postcode, city).

# 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": "",
    "registryCode": "10421629",
    "city": "",
    "legalForm": "",
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("thesjostrandproject/ee-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": "",
    "registryCode": "10421629",
    "city": "",
    "legalForm": "",
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("thesjostrandproject/ee-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": "",
  "registryCode": "10421629",
  "city": "",
  "legalForm": "",
  "maxItems": 10
}' |
apify call thesjostrandproject/ee-company-lookup --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,thesjostrandproject/ee-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/42EpOGuPEiQk92foI/builds/VI5u75M4j3lmo6BJe/openapi.json