# DACH Business Intelligence MCP Server (`actorpilot/dach-business-intelligence-mcp`) Actor

DACH business intelligence MCP server for AI agents. Search the German Handelsregister, monitor EU tenders from TED, and generate structured company research. Works with Claude, Codex, Cursor, VS Code, n8n, LangChain, OpenAI Agents SDK, Gemini, and other MCP clients.

- **URL**: https://apify.com/actorpilot/dach-business-intelligence-mcp.md
- **Developed by:** [S. Klein](https://apify.com/actorpilot) (community)
- **Categories:** AI, Agents, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 1 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

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

## DACH Business Intelligence MCP Server

Give your AI agent structured access to German company register data and EU public tenders — in one MCP server, one connection, three tool calls.

Instead of manually browsing Handelsregister.de or TED procurement portals, your agent calls `search_company_register`, `search_eu_tenders`, or `research_company` and gets clean JSON back in seconds. No browser automation. No fragmented portals. No expensive data contracts.

**Works with Claude, Cursor, VS Code, n8n, LangChain, OpenAI Agents SDK, Gemini, and any MCP-compatible client.**

---

### Quick Connect

#### MCP endpoint

Use this remote MCP server URL:

```text
https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN
````

Replace `YOUR_APIFY_API_TOKEN` with your token from [Apify API & Integrations](https://console.apify.com/account/integrations).

#### Copy-paste prompt for AI tools that can set up MCP for you

If your AI assistant can manage MCP configuration, paste this:

```text
Please connect this remote MCP server for me.

Name: dach-bi
Transport: Streamable HTTP
URL: https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN

After setup, verify that these tools are available:
- search_company_register
- search_eu_tenders
- research_company
```

Important: use the MCP endpoint URL above, not the normal Apify Actor page URL. A link like `https://apify.com/actorpilot/...` is the product page, not the MCP transport endpoint.

#### Works with

- Claude
- Codex
- Cursor
- VS Code
- Windsurf
- Zed
- n8n
- LangChain / LangGraph
- OpenAI Agents SDK
- Google Gemini / Vertex AI
- Any MCP client that supports remote Streamable HTTP

***

### Why use this instead of individual tools

If you only need one data source, use the individual Actors:

- [German Trade Register Scraper](https://apify.com/actorpilot/german-trade-register-scraper) for register lookups only
- [TED Procurement Radar](https://apify.com/actorpilot/ted-procurement-radar) for EU tenders only

This MCP Server is the right choice when your agent workflow needs **both** in a single session:

| Scenario | What happens |
|---|---|
| Due diligence on a supplier | Agent calls `search_company_register` → confirms legal status → calls `search_eu_tenders` → checks if supplier wins public contracts → calls `research_company` → returns combined profile |
| Lead research for a consulting firm | Agent identifies a prospect → verifies register data → surfaces open tenders in their sector → generates first-pass research packet |
| Compliance check | Agent confirms counterparty registration, legal form, and authorised representatives in a single `research_company` call |

**ROI context:** Bloomberg ESG and Refinitiv company data start at €10,000+/year. This MCP server costs $0.05 per tool call.

***

### What this MCP server does

This MCP server acts as a structured gateway between your AI agent and authoritative DACH business data sources. Instead of browsing fragmented government portals or scraping inconsistent pages, your agent calls a tool and receives structured JSON ready for analysis, summarization, enrichment, or downstream automation.

#### Data sources covered

- **Handelsregister** - Official German commercial register. Returns registered address, legal form, register number, register court, business purpose, and current decision-makers.
- **TED (Tenders Electronic Daily)** - Official EU public procurement platform. Returns tenders with authority, dates, country, and source links.
- **Company Research Aggregator** - Combines register data and tender data into one structured company profile.

#### Best fit for

- AI developers building business research agents
- VC and PE teams automating deal screening
- Consultancies doing rapid market and company profiling
- Procurement teams monitoring TED opportunities
- Compliance and legal teams checking counterparties

***

### Typical use cases

- **Due diligence and KYC** - Verify whether a company is registered and who is authorized to represent it.
- **Lead research** - Enrich CRM and outbound workflows with official company information.
- **Tender monitoring** - Track public procurement opportunities by keyword and country.
- **Company profiling** - Generate first-pass research packets for consulting, VC, PE, and M\&A workflows.

***

### Available MCP tools

#### `search_company_register`

Search the official German Handelsregister by company name or register number.

**Typical inputs**

| Parameter | Type | Description |
|---|---|---|
| `companyName` | string | Company name, for example `SAP SE` |
| `registerNumber` | string | Register number, for example `HRB 719782` |
| `registerCourt` | string | Register court, for example `Mannheim` |
| `registerType` | enum | `HRB`, `HRA`, `GnR`, `PR`, `VR`, or `all` |
| `maxResults` | integer | Result limit from 1 to 20 |

#### `search_eu_tenders`

Search TED procurement notices by keyword, country, CPV code, or minimum value.

**Typical inputs**

| Parameter | Type | Description |
|---|---|---|
| `searchPhrase` | string | Search keyword, for example `IT services` |
| `country` | string | ISO3 country code such as `DEU`, `AUT`, `CHE` |
| `cpvCode` | string | CPV code such as `72000000` |
| `minValueEur` | number | Minimum estimated value in EUR |
| `maxResults` | integer | Result limit from 1 to 50 |

#### `research_company`

Run combined company research in a single call by aggregating register data and tender data.

**Typical inputs**

| Parameter | Type | Description |
|---|---|---|
| `companyName` | string | Company name to research |
| `includeSources` | array | One or both of `register` and `tenders` |

***

### How to connect your AI agent

#### Claude

Add the MCP server URL from the **Quick Connect** section to your Claude MCP or custom connector setup.

Use this endpoint:

```text
https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN
```

If your Claude client supports natural-language setup through another agent, use the copy-paste prompt from **Quick Connect**.

#### Codex and other coding agents

Some coding agents can edit MCP configuration for you. Paste this:

```text
Please add this remote MCP server to my MCP configuration.

Server name: dach-bi
Transport: Streamable HTTP
URL: https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN

Then verify that these tools are available:
- search_company_register
- search_eu_tenders
- research_company
```

#### Cursor, VS Code, Windsurf, Zed

Use a config like this:

```json
{
  "mcpServers": {
    "dach-bi": {
      "url": "https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN"
    }
  }
}
```

If your client supports header-based auth, you can also use:

```json
{
  "mcpServers": {
    "dach-bi": {
      "url": "https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_API_TOKEN"
      }
    }
  }
}
```

#### n8n

1. Add an **MCP Client** node
2. Choose remote MCP or Streamable HTTP transport if available
3. Set the URL to `https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN`
4. Let n8n discover the tools
5. Connect it to your AI Agent node

#### LangChain, LangGraph, OpenAI Agents SDK, Gemini, custom apps

Point your remote MCP client to:

```text
https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN
```

This server uses **Streamable HTTP** for MCP requests.

***

### Example tool calls

#### Example: company register search

```json
{
  "name": "search_company_register",
  "arguments": {
    "companyName": "SAP SE",
    "registerCourt": "Mannheim",
    "maxResults": 1
  }
}
```

#### Example: TED tender search

```json
{
  "name": "search_eu_tenders",
  "arguments": {
    "searchPhrase": "IT services",
    "country": "DEU",
    "maxResults": 5
  }
}
```

#### Example: full company research

```json
{
  "name": "research_company",
  "arguments": {
    "companyName": "Siemens AG",
    "includeSources": ["register", "tenders"]
  }
}
```

***

### Output reference

#### `search_company_register` returns fields such as

- `companyName`
- `legalForm`
- `registerNumber`
- `registerCourt`
- `address`
- `businessPurpose`
- `decisionMakers`
- `sourceUrl`
- `scrapedAt`

#### `search_eu_tenders` returns fields such as

- `noticeId`
- `title`
- `contractingAuthority`
- `country`
- `publicationDate`
- `deadline`
- `estimatedValueEur`
- `cpvCodes`
- `description`
- `sourceUrl`
- `scrapedAt`

#### `research_company` returns fields such as

- `companyName`
- `sourcesQueried`
- `registerData`
- `euTenders`
- `summary`
- `errors`
- `scrapedAt`

***

### Pricing

This Actor uses **Pay Per Event** pricing. You are charged per successful tool call, not per server start.

| Event | Price |
|---|---|
| `search_company_register` | $0.05 per call |
| `search_eu_tenders` | $0.05 per call |
| `research_company` | $0.05 per call |

Typical usage patterns:

- 100 company lookups per day -> about $150 per month
- 20 due diligence reports per day -> about $30 per month
- 50 tender monitoring checks per day -> about $75 per month

***

### FAQ

#### Does this use only public data?

Yes. The data comes from public registries and public procurement sources such as the German Handelsregister and TED.

#### Which countries are covered?

Primary register coverage is Germany. Tender coverage includes Germany, Austria, Switzerland, and broader EU TED search results depending on the query.

#### How fast are the responses?

Typical response times:

- `search_company_register`: about 8 to 15 seconds
- `search_eu_tenders`: about 5 to 12 seconds
- `research_company`: about 12 to 25 seconds

#### What happens if no company is found?

The tool returns a structured result or an empty result set instead of crashing your workflow.

#### Can I test the MCP server directly before connecting it to an agent?

Yes. Open:

```text
https://actorpilot--dach-business-intelligence-mcp.apify.actor/openapi.json?token=YOUR_APIFY_API_TOKEN
```

You can also send MCP requests directly to:

```text
https://actorpilot--dach-business-intelligence-mcp.apify.actor/mcp?token=YOUR_APIFY_API_TOKEN
```

#### How long does a `research_company` call take?

Typical response times:

- `search_company_register`: 8–15 seconds
- `search_eu_tenders`: 5–12 seconds
- `research_company` (both sources): 12–25 seconds

These times reflect live data retrieval. The server does not cache results.

#### Can I use this in an automated n8n or LangGraph workflow?

Yes. Point your MCP client at the Streamable HTTP endpoint. In n8n, use the MCP Client node. In LangGraph or LangChain, use any MCP-compatible client library. The server handles session management and returns structured JSON on every call.

***

### Support

Found a bug or want another DACH data source integrated? Open an issue on the Actor page or contact us through Apify.

Planned future extensions:

- Bundesanzeiger filings
- Kununu employer reviews
- StepStone job postings
- Broader multi-source research aggregation

# Actor input Schema

## Actor input object example

```json
{}
```

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("actorpilot/dach-business-intelligence-mcp").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("actorpilot/dach-business-intelligence-mcp").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 '{}' |
apify call actorpilot/dach-business-intelligence-mcp --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "DACH Business Intelligence MCP Server",
        "description": "DACH business intelligence MCP server for AI agents. Search the German Handelsregister, monitor EU tenders from TED, and generate structured company research. Works with Claude, Codex, Cursor, VS Code, n8n, LangChain, OpenAI Agents SDK, Gemini, and other MCP clients.",
        "version": "1.0",
        "x-build-id": "WZEpP621ipgBXhepH"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/actorpilot~dach-business-intelligence-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-actorpilot-dach-business-intelligence-mcp",
                "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/actorpilot~dach-business-intelligence-mcp/runs": {
            "post": {
                "operationId": "runs-sync-actorpilot-dach-business-intelligence-mcp",
                "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/actorpilot~dach-business-intelligence-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-actorpilot-dach-business-intelligence-mcp",
                "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",
                "properties": {}
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```