# Estonia Business Register Scraper (`parseforge/estonia-business-register-scraper`) Actor

Look up any company on the Estonian Business Register and capture its name, registry code, current status, status date, former names, and registered address. Whole result sets come back in one run. Great for lead generation, due diligence, and company research in Estonia.

- **URL**: https://apify.com/parseforge/estonia-business-register-scraper.md
- **Developed by:** [ParseForge](https://apify.com/parseforge) (community)
- **Categories:** Lead generation, Developer tools, Automation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.00 / 1,000 results

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

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

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

![ParseForge Banner](https://github.com/ParseForge/apify-assets/blob/ad35ccc13ddd068b9d6cba33f323962e39aed5b2/banner.jpg?raw=true)

## 🇪🇪 Estonia Business Register Scraper

> 🚀 **Search the Estonian company register in seconds.** Look up any business and get its registry code, status, former names, and address.

> 🕒 **Last updated:** 2026-06-02 · **📊 10 fields** per company · official e-Business Register · name or code search

Pull company records from the Estonian Business Register, the official register run by the Centre of Registers and Information Systems. Search by company name or registry code, and for every company get its name, registry code, status, status date, former names, and registered address.

**Coverage:** the full Estonian Business Register, including active and deleted entities, paged across whole result sets.

| 🎯 Target Audience | 💡 Primary Use Cases |
|---|---|
| Sales and lead gen teams | Build company prospect lists |
| Compliance and legal | Run due diligence checks |
| Researchers and journalists | Map company networks |
| Data teams | Build Baltic business datasets |

### 📋 What the Estonia Business Register Scraper does

- Searches the official register by company name or registry code.
- Pages through whole result sets.
- Returns 10 structured fields per company.
- Captures status, status date, and former names.
- Includes the registered address when shown.
- Exports to CSV, Excel, JSON, XML, or via API.

### 🎬 Full Demo (_🚧 Coming soon_)

### ⚙️ Input

| Field | Type | Description |
|---|---|---|
| `searchTerms` | array | Company names or registry codes to search. One result set per term. |
| `maxItems` | integer | Cap on companies returned. Free plan is limited to 10. |

**Example 1: a company name**
```json
{
  "searchTerms": ["tallink"],
  "maxItems": 100
}
````

**Example 2: several terms**

```json
{
  "searchTerms": ["bolt", "wise", "skype"],
  "maxItems": 300
}
```

> ⚠️ **Good to Know:** results include both active and deleted companies, so check the `status` field. A keyword can match many companies, so use `maxItems` to cap output. Former names appear only for companies that changed their name, and the address is shown for most but not all entities.

### 📊 Output

Each record contains the following fields:

| Field | Description |
|---|---|
| 🏢 `name` | Company name |
| 🔢 `registryCode` | Estonian registry code |
| ✅ `status` | Entered into the register, Deleted, and similar |
| 📅 `statusDate` | Date of the status |
| 📛 `formerNames` | Previous names |
| 📍 `address` | Registered address |
| 🔗 `companyUrl` | Register detail page |
| 🔎 `searchTerm` | Query that surfaced this company |
| 🕒 `scrapedAt` | Collection timestamp |
| ❌ `error` | Error message, null on success |

**Real sample records:**

```json
{
  "name": "aktsiaselts TALLINK",
  "registryCode": "10710010",
  "status": "Entered into the register",
  "statusDate": "14.11.2000",
  "formerNames": [],
  "address": "Harju maakond, Tallinn, Kesklinna linnaosa, Sadama tn 5, 10111",
  "companyUrl": "https://ariregister.rik.ee/eng/company/10710010",
  "error": null
}
```

```json
{
  "name": "Anjese Bolt OÜ",
  "registryCode": "14724782",
  "status": "Entered into the register",
  "statusDate": "16.05.2019",
  "formerNames": [],
  "address": "Harju maakond, Rae vald, Peetri alevik, Läike tee 1, 75312",
  "companyUrl": "https://ariregister.rik.ee/eng/company/14724782",
  "error": null
}
```

```json
{
  "name": "AS INF T",
  "registryCode": "11425524",
  "status": "Entered into the register",
  "statusDate": "19.09.2007",
  "formerNames": ["Aktsiaselts Tallink Takso"],
  "address": "Harju maakond, Tallinn, Kesklinna linnaosa, Liivalaia tn 9, 10118",
  "companyUrl": "https://ariregister.rik.ee/eng/company/11425524",
  "error": null
}
```

### ✨ Why choose this Actor

- **Official source.** Straight from the Estonian Business Register.
- **Name history.** Former names help you track rebrands.
- **Status aware.** Tell active from deleted at a glance.
- **Whole result sets.** Paging is handled for you.
- **Ready to export.** CSV, Excel, JSON, XML, or API, with a clean table view.

### 📈 How it compares to alternatives

| | Estonia Business Register Scraper | Manual search | Generic web scrapers |
|---|---|---|---|
| Whole-register keyword search | ✅ | ❌ | ⚠️ Needs setup |
| Former names and status | ✅ | ⚠️ | ❌ |
| Paging handled | ✅ | ❌ | ⚠️ |
| Multi-term runs | ✅ | ❌ | ⚠️ |
| Export to CSV/Excel/JSON/XML | ✅ | ❌ | ⚠️ |

### 🚀 How to use

1. Create a free Apify account using [this sign-up link](https://console.apify.com/sign-up?fpr=vmoqkp).
2. Open the Estonia Business Register Scraper.
3. Enter one or more `searchTerms` and set `maxItems`.
4. Click **Start** and watch the dataset fill in real time.
5. Export your results as CSV, Excel, JSON, or XML, or pull them via API.

### 💼 Business use cases

**🎯 Lead generation**
| Goal | How |
|---|---|
| Build prospect lists | Search an industry keyword |
| Filter active firms | Keep only active status |

**🔍 Due diligence**
| Goal | How |
|---|---|
| Verify a company | Search its exact name or code |
| Track rebrands | Read the former names |

**🗺 Market mapping**
| Goal | How |
|---|---|
| Map a sector | Aggregate companies by keyword |
| Spot groups | Group by shared name patterns |

**📊 Research**
| Goal | How |
|---|---|
| Build datasets | Pull many terms at once |
| Link records | Use the registry code as a key |

### 🔌 Automating Estonia Business Register Scraper

Connect this Actor to your stack with Apify integrations: **Make**, **Zapier**, **Slack**, **Airbyte**, **GitHub**, and **Google Drive**. Schedule runs and push fresh company data into spreadsheets, databases, or alerts.

### 🌟 Beyond business use cases

- **Research:** study company formation trends in Estonia.
- **Personal:** check a business before you deal with it.
- **Non-profit:** map the organisations in a sector.
- **Experimentation:** build company graph projects.

### 🤖 Ask an AI assistant

Paste your dataset into [ChatGPT](https://chat.openai.com), [Claude](https://claude.ai), [Perplexity](https://www.perplexity.ai), or [Copilot](https://copilot.microsoft.com) and ask for active companies, formation dates, or name clusters.

### ❓ Frequently Asked Questions

**1. Do I need an API key?**
No. The Actor uses the public register search.

**2. Does it include deleted companies?**
Yes. Check the `status` field to tell active from deleted.

**3. What is the registry code?**
A unique number that identifies each Estonian company.

**4. Can I search by code?**
Yes. Put the registry code in `searchTerms`.

**5. Are former names included?**
Yes, for companies that changed their name.

**6. Is the address always present?**
It is shown for most entities, but a few have none.

**7. What export formats are supported?**
CSV, Excel, JSON, XML, and API.

**8. Can I search several terms at once?**
Yes. Add multiple search terms.

**9. Can I run it on a schedule?**
Yes, with Apify Schedules and integrations.

**10. Is there a free option?**
Yes. Free runs are limited to 10 items as a preview. Paid plans unlock up to 1,000,000.

### 🔌 Integrate with any app

Use the Apify API, webhooks, and 5,000-plus integrations to push register data into Make, Zapier, Google Sheets, Airtable, databases, and more.

### 🔗 Recommended Actors

- [UK Companies House Scraper](https://apify.com/parseforge/uk-companies-house-scraper)
- [Finland PRH Scraper](https://apify.com/parseforge/finland-prh-scraper)
- [Norway BRREG Scraper](https://apify.com/parseforge/norway-brreg-scraper)
- [Netherlands KVK Scraper](https://apify.com/parseforge/netherlands-kvk-scraper)
- [Latvia and Baltic registries via Global Company Lookup](https://apify.com/parseforge/global-company-registry-lookup-scraper)

> 💡 **Pro Tip:** browse the complete [ParseForge collection](https://apify.com/parseforge).

**🆘 Need Help?** [Open our contact form](https://tally.so/r/BzdKgA)

> **⚠️ Disclaimer:** independent tool, not affiliated with the Estonian Centre of Registers and Information Systems (RIK). Only publicly available register data is collected.

# Actor input Schema

## `searchTerms` (type: `array`):

Company names or registry codes to search on the Estonian e-Business Register (e.g. "tallink", "11425524"). One result set per term.

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

Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000.

## Actor input object example

```json
{
  "searchTerms": [
    "tallink"
  ],
  "maxItems": 10
}
```

# Actor output Schema

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

No description

# 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 = {
    "searchTerms": [
        "tallink"
    ],
    "maxItems": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("parseforge/estonia-business-register-scraper").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 = {
    "searchTerms": ["tallink"],
    "maxItems": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("parseforge/estonia-business-register-scraper").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 '{
  "searchTerms": [
    "tallink"
  ],
  "maxItems": 10
}' |
apify call parseforge/estonia-business-register-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=parseforge/estonia-business-register-scraper",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Estonia Business Register Scraper",
        "description": "Look up any company on the Estonian Business Register and capture its name, registry code, current status, status date, former names, and registered address. Whole result sets come back in one run. Great for lead generation, due diligence, and company research in Estonia.",
        "version": "0.1",
        "x-build-id": "ZLwx9lAxvBqChcoxV"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/parseforge~estonia-business-register-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-parseforge-estonia-business-register-scraper",
                "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/parseforge~estonia-business-register-scraper/runs": {
            "post": {
                "operationId": "runs-sync-parseforge-estonia-business-register-scraper",
                "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/parseforge~estonia-business-register-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-parseforge-estonia-business-register-scraper",
                "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": [
                    "searchTerms"
                ],
                "properties": {
                    "searchTerms": {
                        "title": "Search Terms",
                        "minItems": 1,
                        "type": "array",
                        "description": "Company names or registry codes to search on the Estonian e-Business Register (e.g. \"tallink\", \"11425524\"). One result set per term.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Max Items",
                        "minimum": 1,
                        "maximum": 1000000,
                        "type": "integer",
                        "description": "Free users: limited to 10 items (preview). Paid users: optional, max 1,000,000."
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```