# Business Data Enrichment (`moving_beacon-owner1/business-data-enrichment`) Actor

Business Data Enrichment — enrich company records with public website, contact, social, technology, location, and review data while preserving all original fields and providing an audit trail.

- **URL**: https://apify.com/moving\_beacon-owner1/business-data-enrichment.md
- **Developed by:** [Jamshaid Arif](https://apify.com/moving_beacon-owner1) (community)
- **Categories:** Lead generation, Integrations, Other
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $9.99 / 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.

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

## Data Enrichment

Enrich a list of company/business records with **publicly observable information** — website technology stack, social profiles, public contact email/phone, structured‑data location, and review/rating signals — while **preserving every original field** and clearly marking the fields that could not be found.

### What does this Actor do?

You give it records (e.g. `{"company": "Acme", "website": "https://acme.com"}`). For each record it:

1. **Resolves a website** — from your website field, or (optionally) by looking the company up in a business directory when it has none.
2. **Analyzes the website** — extracting the technology/CMS stack, social profiles, public email and phone, JSON‑LD location, and aggregate rating/reviews.
3. **Falls back to a business directory** — filling phone, address, category and rating when a website is missing or thin.
4. **Merges the results non‑destructively** — original fields are never overwritten; only missing fields are filled.

Every record gets an `_enrichment` audit object so you can always tell *"not found"* apart from *"not attempted"*.

### Why use it?

- Turn a bare CRM export (just company + website) into an enriched lead list.
- Auditable by design: each record lists exactly which fields were added, which were not found, and which sources were used.
- Idempotent and safe: if you already have a value, the Actor keeps yours.

### Input

Provide records in **any one** of these ways (resolved in priority order):

| Field | Type | Description |
| --- | --- | --- |
| `records` | array | Inline JSON array of record objects. |
| `csv` | string | CSV text with a header row. |
| `json` | string | JSON array/object as text. |
| `datasetId` | string | Enrich the items of an existing Apify dataset. |
| `datasetUrl` | string | Public URL returning a JSON array. |

Enrichment options:

| Field | Type | Description |
| --- | --- | --- |
| `enrichFrom` | array | `website`, `business_directory` (default `["website"]`). |
| `websiteField` | string | Record field holding the website URL (default `website`). |
| `companyField` | string | Record field holding the company name (default `company`). |
| `proxyConfiguration` | object | Proxy settings for outbound fetches. |

#### Input example

```json
{
  "records": [
    { "company": "Acme Corp", "website": "https://acme.com" },
    { "company": "NoWeb Plumbing" }
  ],
  "enrichFrom": ["website", "business_directory"],
  "websiteField": "website",
  "companyField": "company"
}
```

### Output

One record per input record. **All original fields are preserved.** The Actor adds any of these public fields it can find (and sets the rest to `null`):

`industry`, `category`, `technology` (list), `socialProfiles` (map), `publicEmail`, `publicPhone`, `location`, `rating`, `reviewCount`.

Each record also carries an `_enrichment` audit object:

```json
{
  "company": "Acme Corp",
  "website": "https://acme.com",
  "crmId": 42,
  "technology": ["WordPress", "jQuery"],
  "socialProfiles": { "facebook": "https://facebook.com/acmecorp" },
  "publicEmail": "hello@acme.com",
  "publicPhone": null,
  "location": "100 Main St, Austin, TX",
  "industry": null,
  "category": null,
  "rating": 4.5,
  "reviewCount": 88,
  "_enrichment": {
    "fieldsAdded": ["technology", "socialProfiles", "publicEmail", "location", "rating", "reviewCount"],
    "fieldsNotFound": ["industry", "category", "publicPhone"],
    "sources": ["website"]
  }
}
```

- **`fieldsAdded`** — enrichment fields (and any discovered website) that were newly filled.
- **`fieldsNotFound`** — fields that were attempted but not found; these are set to `null`.
- **`sources`** — which enrichment sources actually contributed (`website`, `business_directory`).

You can download the dataset in JSON, CSV, Excel or HTML.

### Field preservation & not‑found marking

- Original keys are copied verbatim — the Actor never drops or renames your data.
- If you already supply a value for an enrichment field (e.g. `rating`), it is preserved; the Actor will not overwrite it, nor list it as added or not‑found.
- Fields that were attempted but could not be found are explicitly set to `null` and listed in `fieldsNotFound`.

### Sources

- **Website analysis** — HTTPS, title/meta, technology/CMS fingerprints, social links, public email/phone, JSON‑LD `Organization`/`LocalBusiness` address and `aggregateRating`.
- **Business directory** — Bing Maps (worldwide) lookup to recover a website, phone, address, category and rating for companies with no website.

### Limitations & legal

- Only **publicly accessible** information is processed. No authentication is bypassed and no private personal data is collected.
- Enrichment is best‑effort — always validate before acting on a field.
- Respect each source's Terms of Service, `robots.txt` and applicable law.

# Actor input Schema

## `records` (type: `array`):

Records to enrich, e.g. \[{"company": "Acme", "website": "https://acme.com"}]. All original fields are preserved in the output.

## `csv` (type: `string`):

Alternative to 'records': paste CSV text with a header row. Each row becomes a record.

## `json` (type: `string`):

Alternative to 'records': paste a JSON array (or single object) of records as text.

## `datasetId` (type: `string`):

Enrich the items of an existing Apify dataset (by id or name) instead of pasting records.

## `datasetUrl` (type: `string`):

Public URL returning a JSON array of records to enrich.

## `enrichFrom` (type: `array`):

Which public sources to enrich from. 'website' analyzes each record's website; 'business\_directory' looks a company up in a business directory when it has no website.

## `websiteField` (type: `string`):

The record field that holds the website URL.

## `companyField` (type: `string`):

The record field that holds the company / business name (used for directory lookups).

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

Proxy settings used when fetching websites and directories.

## `cookies` (type: `string`):

Optional Cookie header string to replay on every request.

## Actor input object example

```json
{
  "records": [
    {
      "company": "Microsoft",
      "website": "https://www.microsoft.com"
    },
    {
      "company": "Apple",
      "website": "https://www.apple.com"
    }
  ],
  "csv": "",
  "json": "",
  "datasetId": "",
  "datasetUrl": "",
  "enrichFrom": [
    "website",
    "business_directory"
  ],
  "websiteField": "website",
  "companyField": "company",
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "cookies": ""
}
```

# 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("moving_beacon-owner1/business-data-enrichment").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("moving_beacon-owner1/business-data-enrichment").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 moving_beacon-owner1/business-data-enrichment --silent --output-dataset

```

## MCP server setup

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

```

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/SgGMeQpjUVCxHbm2i/builds/AkMV3n9fR8KaOIVrN/openapi.json