# Ro Business Data MCP - Romanian Company & Contact Lookup (`darknezz/ro-business-data-mcp`) Actor

Official ONRC Romanian company registry lookup (4.2M firms): status, CAEN activities, directors, address, website — plus website contact extraction (emails, phones, socials) and WHOIS/DNS/SPF/DMARC domain audits. MCP-native.

- **URL**: https://apify.com/darknezz/ro-business-data-mcp.md
- **Developed by:** [Oaida Adrian](https://apify.com/darknezz) (community)
- **Categories:** Lead generation, Business, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $10.00 / 1,000 company looked ups

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

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — 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

## Ro Business Data MCP — Romanian Company & Contact Lookup

Look up any Romanian company from the **official ONRC registry** (4.2M firms,
monthly open-data snapshot from data.gov.ro) and enrich it with live website
contacts and a WHOIS/DNS security audit. One input, three kinds of work —
delivered as an Apify actor **and** as an MCP server for agentic use.

- **lookup\_business** — company name or CUI (tax ID) → decoded company status,
  CAEN activities, legal representatives, full address, website
- **lookup\_director** — director/representative name → companies they run
- **extract\_contacts** — crawl a website → domain-matched emails, filtered
  phones, clean social profiles (Facebook/Instagram/LinkedIn/X/YouTube/GitHub)
- **lookup\_domain** — WHOIS + DNS (A/AAAA/MX/NS/TXT/CNAME/SOA/CAA) + SPF/DMARC
  email-security audit

The registry data is the same official ONRC snapshot behind the popular
Romanian business tools — but served as clean, structured, MCP-friendly JSON,
with the heavy 3.2 GB registry kept off the actor build and queried through a
thin public wrapper instead.

***

### Why this actor exists

Romanian B2B lead generation is underserved: the official company registry is
public but ships as **monthly multi-hundred-MB CSV dumps** with no query API,
and the existing directory scrapers fight anti-bot walls for data that is
already open. This actor turns the open registry into an instant API:

- **Official source** — ONRC open-data snapshot (data.gov.ro), not scraped
  directories; status + CAEN codes are decoded through the registry's own
  nomenclatures
- **Diacritic-insensitive** — `paval` finds `PAVĂL`, `stefan` finds `ȘTEFAN`
- **Lead-ready output** — company profile + domain-matched emails + filtered
  phones + social profiles + SPF/DMARC posture in one row
- **MCP-native** — run it as a batch actor *or* connect it to your agent as an
  MCP server (same four tools, same output shape)

### How it works

```
┌──────────────┐   query/CUI    ┌───────────────────────────┐
│  You / Agent │ ─────────────► │  Ro Business Data MCP     │
│              │ ◄───────────── │  (batch dataset or MCP)   │
└──────────────┘   JSON result  └─────────────┬─────────────┘
                                              │
                      ┌───────────────────────┼───────────────────────┐
                      ▼                       ▼                       ▼
              ┌───────────────┐      ┌─────────────────┐      ┌─────────────┐
              │ ONRC registry │      │ website crawl   │      │ WHOIS/DNS   │
              │ (public       │      │ (emails, phones,│      │ SPF/DMARC   │
              │  wrapper API) │      │  socials)       │      │ audit       │
              └───────────────┘      └─────────────────┘      └─────────────┘
```

The registry snapshot (4.2M firms, 3.2 GB) is too large to bundle in an actor
build (the compacted DB alone is 2.5 GB raw / 772 MB gzip), and data.gov.ro's
CKAN exposes no query endpoint for these resources — so a small read-only
wrapper serves the registry and the actor queries it at runtime. The wrapper
is itself backed by the same official ONRC snapshot the homelab Leadgen MCP
uses, refreshed monthly. Contact extraction and domain audits are stateless
and run entirely inside the actor.

### Input

| Field | Type | Default | Description |
|---|---|---|---|
| `query` | string | — | Company name or CUI (tax ID) to look up |
| `director` | string | — | Director / legal representative name to search |
| `website` | string | — | Website to crawl for contacts (e.g. `example.com`) |
| `domain` | string | — | Domain to WHOIS/DNS/SPF/DMARC audit |
| `maxResults` | int | 10 | Max companies per registry lookup (1–100) |
| `maxPages` | int | 5 | Max pages crawled during contact extraction (1–20) |
| `includeDomainLookup` | bool | true | Auto-audit each company's website domain |
| `mcpMode` | bool | false | Run as MCP server instead of batch |

You can run any combination: just `query`, `query` + enrichment, `director`,
`website` alone, or `domain` alone. With empty input the actor runs a demo
lookup for `DIGI ROMANIA`.

### Example outputs

#### lookup\_business — `"DIGI ROMANIA"`

```json
{
  "companyName": "DIGI ROMANIA S.A.",
  "cui": "21023106",
  "registrationCode": "J40/10448/2007",
  "registrationDate": "09/07/2007",
  "legalForm": "SA",
  "address": "Bucureşti Sectorul 1, Bucureşti, FRANTUZEI, 75, 1",
  "county": "Bucureşti",
  "city": "Bucureşti Sectorul 1",
  "website": "www.digi.ro",
  "caenActivities": [
    {"code": "6110", "activity": "Activități de telecomunicații prin rețele cu cablu"},
    {"code": "6120", "activity": "Activități de telecomunicații prin rețele fără cablu"}
  ],
  "directors": ["Serghei Bulgac", "Valentin Popescu"],
  "status": [{"code": "5", "name": "Înregistrată"}],
  "source": "onrc"
}
```

With `includeDomainLookup: true` the same row also carries `domainLookup`
(WHOIS registrar, DNS records, SPF/DMARC) for `www.digi.ro`.

#### extract\_contacts — `"https://www.python.org"`

```json
{
  "url": "https://www.python.org",
  "domain": "python.org",
  "pagesCrawled": 5,
  "emails": ["info@python.org", "webmaster@python.org"],
  "phones": null,
  "twitter": "https://twitter.com/ThePSF",
  "github": "https://github.com/python",
  "youtube": "https://www.youtube.com/user/PythonVE",
  "socialLinks": ["https://twitter.com/ThePSF", "https://github.com/python"]
}
```

#### lookup\_domain — `"example.com"`

```json
{
  "domain": "example.com",
  "whois": {"registrar": "RESERVED-Internet Assigned Numbers Authority", "creationDate": "1995-08-14", "expirationDate": "2031-08-13", "nameServers": ["a.iana-servers.net", "b.iana-servers.net"]},
  "dns": {"A": ["93.184.215.14", "93.184.216.34"], "NS": ["a.iana-servers.net", "b.iana-servers.net"], "MX": [], "TXT": []},
  "security": {"hasSPF": false, "spf": null, "hasDMARC": false, "dmarc": null},
  "resolvedIP": "93.184.215.14"
}
```

### Use cases

- **B2B lead generation** — find companies by industry (CAEN), verify their
  legal status, and pull direct emails/phones for outreach
- **Due diligence** — registration date, legal form, directors, current
  status, and email-security posture before signing anything
- **Sales territory mapping** — search by director name to find every company
  a decision-maker is connected to
- **Agent workflows** — expose all four lookups to a Claude/ChatGPT-style
  agent via MCP: `"find me Romanian SaaS companies and their contact emails"`

### Run it from code

```python
from apify_client import ApifyClient

client = ApifyClient("YOUR-APIFY-TOKEN")
run = client.actor("darknezz/ro-business-data-mcp").call(
    run_input={"query": "DIGI ROMANIA", "includeDomainLookup": True}
)
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["companyName"], item["cui"], item["status"])
```

```bash
curl -s "https://api.apify.com/v2/acts/darknezz~ro-business-data-mcp/run-sync-get-dataset-items?token=YOUR-TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"query": "eMAG", "maxResults": 5}'
```

### MCP server mode

Set `mcpMode: true` and the actor boots as an MCP server exposing the four
tools (`lookup_business`, `lookup_director`, `extract_contacts`,
`lookup_domain`). Point your MCP client at the actor and the tools appear in
your agent's toolset — the same surface the batch mode uses, with results
returned as JSON strings.

### Data freshness & source

- Registry: official **ONRC** open-data snapshot from data.gov.ro (dataset
  `firme-*`, refreshed monthly by ONRC). The actor's wrapper serves the latest
  loaded snapshot.
- Contacts: live crawl at run time — no cached emails.
- WHOIS/DNS: live lookups at run time.

### Limits & notes

- `maxResults` caps registry lookups at 100 rows; `maxPages` caps contact
  crawls at 20 pages.
- Emails are domain-matched first (the company's own domain), then split into
  `otherEmails`; junk/placeholder addresses are filtered.
- Phone extraction rejects barcode-like runs and year ranges (e.g.
  `2001-2026`); 8–11 digit numbers with structure (`+`, separators, `0`)
  are kept.
- Social links are anchor-tag only and filtered against a vendor denylist
  (tracking, CDN, SaaS badges).
- WHOIS responses vary by TLD registrar; missing fields are `null` rather
  than fabricated.
- The registry wrapper is a thin read-only API; if it is unreachable, batch
  registry rows return an explicit `error` item — contact and domain tools
  still work.

### Changelog

- **0.1** (2026-08-13) — initial build: batch + MCP modes, registry wrapper
  integration, contact extraction, domain audit, SEO + pricing staged
  (release candidate, private).

# Actor input Schema

## `query` (type: `string`):

Romanian company name or CUI (tax ID) to look up in the official ONRC registry (e.g. 'DIGI ROMANIA', 'eMAG', '18189442'). Diacritic-insensitive.

## `director` (type: `string`):

Search companies by director / legal representative name (e.g. 'Ion Popescu'). Returns companies with their director roles.

## `website` (type: `string`):

Crawl a website for emails, phone numbers and social profiles (e.g. 'example.com' or 'https://example.com').

## `domain` (type: `string`):

WHOIS + DNS + SPF/DMARC security audit for a domain (e.g. 'example.com').

## `maxResults` (type: `integer`):

Maximum number of companies to return per lookup (1-100).

## `maxPages` (type: `integer`):

Maximum pages to crawl during website contact extraction (1-20).

## `includeDomainLookup` (type: `boolean`):

When a company has a website, also run the WHOIS/DNS/SPF/DMARC audit on it and attach it to the row.

## `mcpMode` (type: `boolean`):

Start the actor as an MCP server (standby mode) instead of a batch lookup.

## Actor input object example

```json
{
  "maxResults": 10,
  "maxPages": 5,
  "includeDomainLookup": true,
  "mcpMode": false
}
```

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,darknezz/ro-business-data-mcp"
        }
    }
}

```

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/9nczluajyhTkOGIPn/builds/UKO9X6f57ldPNI1CS/openapi.json