# Handelsregister Firm Scraper (`axiomworks/handelsregister-company-scraper`) Actor

Find company entries on the German Handelsregister portal and return structured records with register type and number, court, federal state, seat, status and legal form. Search by company keywords or register number, and optionally include closed register sheets and earlier company names.

- **URL**: https://apify.com/axiomworks/handelsregister-company-scraper.md
- **Developed by:** [Axiom Works](https://apify.com/axiomworks) (community)
- **Categories:** Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.76 / 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/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

**Returns:** one row per German company with `companyName`, `register`, `registerCourt`, `registerType`, `registerNumber`, `seat`, `status`, `legalForm` and `previousNames`.
**Input:** `{"keyword": "Siemens", "maxItems": 20}`
**Best for:** German B2B lead lists, KYC and supplier checks (confirm a company's HRB number and court), tracking renamed or closed companies.

```json
{
    "companyName": "Siemens Aktiengesellschaft",
    "register": "Amtsgericht München HRB 6684",
    "registerNumber": "6684",
    "federalState": "Bayern",
    "seat": "Berlin und München",
    "status": "aktuell",
    "legalForm": "AG"
}
```

### What does Handelsregister Firm Scraper do?

Handelsregister Firm Scraper searches the official German company register portal (handelsregister.de, the joint register portal of the German federal states) and returns every matching company as a clean, structured row. It works like the portal's advanced search ("erweiterte Suche"): you search by company name keywords, by register court, register type and register number, by federal state, legal form, city or registered seat, and you can include closed register sheets of dissolved or merged companies.

For each company you get the company name as registered, the full register reference (for example `Amtsgericht München HRB 6684`) split into court, register type and number, the federal state, the registered seat, the register status, the list of register documents the portal offers, the earlier names and seats from the entry's history, and a normalised legal form such as GmbH, AG, KG or e.V. No login and no account on the portal are needed; the Actor reads only the public search results.

It is a practical Handelsregister API for the jobs people usually do by hand in the portal: building lead lists of German companies in a region or industry, checking that a supplier or customer really exists under the register number it gave you, and following a company through renames and moves. One run is one search on the portal, and the portal returns at most 100 companies per search.

### What data can you get from the Handelsregister?

| Field | Description | Example |
|---|---|---|
| `companyName` | Company name as entered in the register (Firma), with its legal-form words | `Siemens Aktiengesellschaft` |
| `register` | Full register reference shown by the portal: court, type and number | `Amtsgericht München HRB 6684` |
| `registerCourt` | Local court (Amtsgericht) that keeps the entry | `München` |
| `registerType` | Register section: HRA, HRB, GnR, PR, VR or GsR | `HRB` |
| `registerNumber` | Register number at that court, as text (may carry a suffix such as `PI`) | `6684` |
| `federalState` | German federal state (Bundesland) of the register court | `Bayern` |
| `seat` | Registered seat (Sitz) or branch location | `Berlin und München` |
| `status` | Register status as the portal shows it: `aktuell` or `Geschlossenes Registerblatt` | `aktuell` |
| `documentTypes` | Register documents the portal offers for the entry (AD, CD, HD, DK, UT, VÖ, SI) | `["AD", "CD", "HD", "DK", "UT", "VÖ", "SI"]` |
| `previousNames` | Earlier names from the entry's history, each with its seat at the time | `[{"name": "Wire Card AG", "seat": "Berlin"}]` |
| `legalForm` | Legal form abbreviation read from the company name, or from your legal form filter | `AG` |
| `id` | Stable id from court, type and number | `muenchen-hrb-6684` |
| `sourceUrl` | The portal's advanced search page the record was found through | `https://www.handelsregister.de/rp_web/erweitertesuche/welcome.xhtml` |
| `scrapedAt` | When the record was collected (ISO 8601, UTC) | `2026-10-18T00:12:02.906Z` |

The document codes mean: AD current printout, CD chronological printout, HD historical printout, DK document view, UT company owner data, VÖ publications, SI structured register data. The Actor lists which of them exist for each company; it does not download the documents themselves.

### How to use Handelsregister Firm Scraper

1. Open Handelsregister Firm Scraper in Apify Console and go to the Input tab.
2. Type a company name keyword, for example `Siemens` or `Bäckerei`. To look up one known company instead, leave the keyword empty and fill in the register court (`München`), register type (`HRB`) and register number (`6684`).
3. Narrow the search if you expect many hits: pick one or more federal states, a legal form such as `Gesellschaft mit beschränkter Haftung`, a city, or a registered seat.
4. Set `maxItems` to the number of companies you want (1-100).
5. Click Start. A search usually finishes in 10-30 seconds.
6. Open the Output tab to see the companies, then export them as JSON, CSV, Excel, XML or HTML, or fetch them through the API.

Tips: The portal stops every search at 100 hits. When a search reaches that cap the run log says so; split the search by federal state, register court, legal form or city to get the rest.

Court names are matched without caring about case or umlauts, so `muenchen` finds `München`, and a unique part such as `Charlottenburg` finds `Berlin (Charlottenburg)`. A court the portal doesn't know fails the run with a list of close matches.

Legal forms accept the portal's labels and the usual abbreviations (GmbH, AG, SE, KG, OHG, e.V., eG, e.K.).

The portal's own postcode search currently answers with an error page, so this Actor has no postcode filter. Use the city filter instead.

### Input

| Field | Type | Required | Description |
|---|---|---|---|
| `keyword` | string | One of keyword, registerNumber, registerCourt, city or seat | Words from the company name, e.g. `Siemens`. German umlauts work. |
| `keywordMatch` | string | No | `all` (default): every word must appear; `any`: at least one word; `exact`: the exact company name. |
| `similarSounding` | boolean | No | Also match names that sound like the keyword. Default false. |
| `registerCourt` | string | No | Register court as the portal names it, e.g. `München`, `Berlin (Charlottenburg)`. |
| `registerType` | string | No | `HRA`, `HRB`, `GnR`, `PR`, `VR` or `GsR`. Empty means all. |
| `registerNumber` | string | No | Register number without court or type, e.g. `6684`. Up to 10 characters. |
| `federalStates` | array of strings | No | Federal states to search in, e.g. `["Sachsen"]`. English names such as `Bavaria` work too. |
| `legalForm` | string | No | Legal form label or abbreviation, e.g. `Gesellschaft mit beschränkter Haftung` or `GmbH`. |
| `city` | string | No | City of the business address, e.g. `Regensburg`. |
| `seat` | string | No | Registered seat or branch location, e.g. `Hamburg`. |
| `includeDeleted` | boolean | No | Also return closed register sheets and deleted branches. Default false. |
| `onlyBranches` | boolean | No | Return only branch establishments registered under the new law. Default false. |
| `maxItems` | integer | No | Maximum number of companies, 1-100, default 50. |
| `proxyConfiguration` | object | No | Proxy settings. Default: no proxy. |

Example: GmbH bakeries registered in Saxony.

```json
{
    "keyword": "Bäckerei",
    "federalStates": ["Sachsen"],
    "legalForm": "Gesellschaft mit beschränkter Haftung",
    "maxItems": 50
}
```

Example: look up one company by its register reference.

```json
{
    "registerCourt": "München",
    "registerType": "HRB",
    "registerNumber": "6684"
}
```

### Output

Each company is one item in the run's dataset. These two items come from real runs: a lookup of München HRB 6684, and a search for `Wirecard` with closed register sheets included.

```json
[
    {
        "companyName": "Siemens Aktiengesellschaft",
        "registerCourt": "München",
        "registerType": "HRB",
        "registerNumber": "6684",
        "register": "Amtsgericht München HRB 6684",
        "federalState": "Bayern",
        "seat": "Berlin und München",
        "status": "aktuell",
        "documentTypes": ["AD", "CD", "HD", "DK", "UT", "VÖ", "SI"],
        "previousNames": [],
        "legalForm": "AG",
        "id": "muenchen-hrb-6684",
        "sourceUrl": "https://www.handelsregister.de/rp_web/erweitertesuche/welcome.xhtml",
        "scrapedAt": "2026-10-18T00:12:02.906Z"
    },
    {
        "companyName": "Wirecard AG",
        "registerCourt": "Berlin (Charlottenburg)",
        "registerType": "HRB",
        "registerNumber": "88060",
        "register": "Amtsgericht Berlin (Charlottenburg) HRB 88060",
        "federalState": "Berlin",
        "seat": "Grasbrunn bei München",
        "status": "Geschlossenes Registerblatt",
        "documentTypes": [],
        "previousNames": [
            { "name": "InfoGenie Europe Aktiengesellschaft", "seat": "Berlin" },
            { "name": "Wire Card AG", "seat": "Berlin" },
            { "name": "Wirecard AG", "seat": "Berlin" }
        ],
        "legalForm": "AG",
        "id": "berlin-charlottenburg-hrb-88060",
        "sourceUrl": "https://www.handelsregister.de/rp_web/erweitertesuche/welcome.xhtml",
        "scrapedAt": "2026-10-18T00:14:41.512Z"
    }
]
```

The portal's result list has no legal-form column, so `legalForm` is read from the legal-form words in the company name ("Aktiengesellschaft" and "AG" both become `AG`, "GmbH & Co. KG" stays `GmbH & Co. KG`). When the name has no such words and you searched with a legal form filter, the filter's value is used; otherwise the field is null. You can download the dataset as JSON, CSV, Excel, XML, RSS or an HTML table from the Output tab or the API.

### How much does it cost to scrape the Handelsregister?

Handelsregister Firm Scraper is charged per result. You pay only for the companies returned, and `maxItems` caps how many that can be in one run. A search that matches nothing costs no results. See the Pricing tab for the current price.

### Use with AI agents (MCP)

Connect Handelsregister Firm Scraper to Claude, Cursor or any MCP client through the Apify MCP server:

```json
{
    "mcpServers": {
        "apify": {
            "url": "https://mcp.apify.com/?tools=axiomworks/handelsregister-company-scraper"
        }
    }
}
```

Example prompts:

1. "Look up the German company register entry for München HRB 6684 and tell me the company's seat and status."
2. "Find GmbH companies with 'Bäckerei' in their name registered in Sachsen and give me a table of name, register number and seat."
3. "Search the Handelsregister for Wirecard including closed register sheets and list each company's previous names."

An agent should pass a keyword or a court plus register number, and keep `maxItems` at 100 or below. If a search hits the 100-company cap, the agent can split it by `federalStates` or `legalForm`.

### Integrations and API

Run Handelsregister Firm Scraper from your own code with the Apify API. Set `APIFY_TOKEN` to your Apify API token (send it in the `Authorization` header, never in the URL).

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("axiomworks/handelsregister-company-scraper").call(run_input={"keyword": "Siemens", "maxItems": 50})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["register"])
```

**JavaScript**

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_API_TOKEN>' });
const run = await client.actor('axiomworks/handelsregister-company-scraper').call({ keyword: 'Siemens', maxItems: 50 });
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**cURL**

```bash
curl -X POST "https://api.apify.com/v2/acts/axiomworks~handelsregister-company-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"keyword": "Siemens", "maxItems": 50}'
```

You can also connect the Actor to Make, Zapier, n8n, Google Sheets, Slack or your own webhooks from the Integrations tab, and schedule it from the Schedules page to refresh a company list every week.

### FAQ

**Why do I get at most 100 companies?**
The register portal itself stops every search at 100 hits and shows a notice that the maximum was exceeded. The Actor logs a warning when that happens. Split the search into narrower ones, for example one run per federal state or per legal form.

**Why did my run return 0 results?**
No company in the register matched all your criteria. Check the spelling, try fewer keywords, set `keywordMatch` to `any`, or remove filters. German umlauts are fine (`Übersee Café` works). Active entries only are returned unless you set `includeDeleted`.

**Can I search by postcode?**
Not at the moment. The portal's postcode field answers with a server error page, so the Actor offers the city (`city`) and registered seat (`seat`) filters instead, which work.

**What does "Geschlossenes Registerblatt" mean?**
The register sheet is closed: the company was dissolved, merged into another company or moved to another court. Such entries appear only when `includeDeleted` is true, and the portal offers no documents for most of them, so `documentTypes` is often empty.

**Does it download register printouts or shareholder lists?**
No. It lists which documents exist (`documentTypes`) but does not download them. The portal's terms count every retrieval, and more than 60 retrievals an hour count as misuse, so the Actor runs one search per run.

**How fresh is the data?**
Every run queries the live portal, so the data is as current as the register itself at that moment.

**Do I need a proxy?**
Usually not. The portal limits how often one IP may search. If you run many searches in a short time and get blocked, turn on Apify Proxy in the input; a blocked search is then retried on a new IP.

**Why is `legalForm` sometimes null?**
The result list has no legal-form column. The Actor reads it from the company name, and some names (often sole traders or associations with unusual wording) contain no legal-form words. Search with the `legalForm` filter to fill it for every row.

### Is it legal to scrape the Handelsregister?

The Handelsregister is a public register: German law lets anyone inspect it, and the portal shows these search results without a login. Handelsregister Firm Scraper collects only the data on the public result list and runs one search per run, well within the portal's usage limits. Company names of sole traders (e.K.) can contain a person's name; if you store or process such data, you are responsible for doing so lawfully, for example under the GDPR. This is not legal advice.

Handelsregister Firm Scraper is an independent tool. It is not affiliated with, endorsed by or sponsored by the Handelsregister, the register courts or the German federal states that run handelsregister.de.

### Related Actors

| Actor | What it does |
|---|---|
| [UK Companies House Scraper](https://apify.com/axiomworks/uk-companies-house-scraper) | Company records from the UK register |
| [French Companies Scraper](https://apify.com/axiomworks/french-companies-scraper) | Company records for France |
| [Brazil CNPJ Company Scraper](https://apify.com/axiomworks/brazil-cnpj-company-scraper) | Company records for Brazil by CNPJ |

### Feedback

Found a bug or need a field that isn't here? Open an issue on the Issues tab and we'll look at it.

# Actor input Schema

## `keyword` (type: `string`):

Words from the company name to search for, e.g. 'Siemens' or 'Bäckerei'. German umlauts work. Leave empty only when you give registerNumber (with registerCourt), registerCourt, city or seat instead. A name that matches nothing ends the run with 0 results and a message.

## `keywordMatch` (type: `string`):

How the keyword words are matched: 'all' (default) finds names containing every word, 'any' names containing at least one word, 'exact' the exact company name.

## `similarSounding` (type: `boolean`):

Also match names that sound like the keyword (the portal's phonetic search). Default false.

## `registerCourt` (type: `string`):

Local court (Amtsgericht) that keeps the register, as the portal names it, e.g. 'München', 'Berlin (Charlottenburg)', 'Hamburg'. Case and umlauts don't matter ('Muenchen' works). Combine with registerType and registerNumber to look up one company. An unknown court fails the run with a list of close matches.

## `registerType` (type: `string`):

Register section: HRB (corporations: GmbH, AG), HRA (partnerships, sole traders), GnR (cooperatives), PR (partnerships of professionals), VR (associations), GsR (civil-law partnerships). Empty = all.

## `registerNumber` (type: `string`):

Register number without court or type, e.g. '6684' (Siemens AG at München HRB 6684). Up to 10 characters. Works best together with registerCourt and registerType.

## `federalStates` (type: `array`):

German federal states (Bundesländer) to search in, e.g. 'Sachsen', 'Bayern', 'Nordrhein-Westfalen'. English names ('Bavaria', 'Saxony') also work. Empty = all of Germany.

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

Legal form as the portal lists it, e.g. 'Gesellschaft mit beschränkter Haftung', 'Aktiengesellschaft', 'eingetragener Verein'. Abbreviations work too: GmbH, AG, SE, KG, OHG, e.V., eG, e.K. Empty = all. An unknown legal form fails the run with close matches.

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

City of the business address, e.g. 'Regensburg'. Up to 30 characters. The portal's postcode search is broken (it answers with an error page), so filter by city instead.

## `seat` (type: `string`):

Registered seat (Sitz) or branch location (Niederlassung), e.g. 'Hamburg'. Up to 30 characters.

## `includeDeleted` (type: `boolean`):

Also return companies whose register sheet is closed (status 'Geschlossenes Registerblatt', e.g. dissolved or merged companies) and deleted branches. Default false: active entries only.

## `onlyBranches` (type: `boolean`):

Return only branch establishments (Zweigniederlassungen) registered under the new law. Default false.

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

Maximum number of companies to return, 1-100, default 50. The portal itself returns at most 100 hits per search; you are charged only for results returned.

## `proxyConfiguration` (type: `object`):

Proxy for requests to the register portal. Default: no proxy, which works for normal use. If runs get blocked (the portal limits each IP to about 60 searches an hour), turn on Apify Proxy; a blocked search is retried on a new IP.

## Actor input object example

```json
{
  "keyword": "Siemens",
  "keywordMatch": "all",
  "similarSounding": false,
  "registerCourt": "",
  "registerType": "",
  "registerNumber": "",
  "federalStates": [],
  "legalForm": "",
  "city": "",
  "seat": "",
  "includeDeleted": false,
  "onlyBranches": false,
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

Dataset with one item per result, in the order found.

# 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 = {
    "keyword": "Siemens",
    "maxItems": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("axiomworks/handelsregister-company-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 = {
    "keyword": "Siemens",
    "maxItems": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("axiomworks/handelsregister-company-scraper").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 '{
  "keyword": "Siemens",
  "maxItems": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call axiomworks/handelsregister-company-scraper --silent --output-dataset

```

## MCP server setup

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

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/rmfyl6gbclqZTi3ny/builds/CMwSS77FT1ONW5ueo/openapi.json