# Local Business Lead Enricher & Website Contact Auditor (`leadforge412/local-business-lead-enricher-website-contact-auditor`) Actor

Enrich Google Maps Scraper results and local business lists with emails, phones, social links, website checks, contact pages, and transparent CRM-ready lead scores.

- **URL**: https://apify.com/leadforge412/local-business-lead-enricher-website-contact-auditor.md
- **Developed by:** [Mezhnun Orudzhaliev](https://apify.com/leadforge412) (community)
- **Categories:** SEO tools, Lead generation, Automation
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $8.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.

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

## Local Business Lead Enricher & Website Contact Auditor

Turn Google Maps Scraper datasets, local business lists, CRM exports, or website URLs into cleaner CRM-ready leads.

This Apify Actor enriches existing local business records by visiting public business websites, extracting public contact information, auditing website quality, normalizing phone numbers, detecting conversion signals, and returning scored lead records that are ready for sales, outreach, research, or CRM import.

It works especially well as a second-step enrichment tool after Google Maps Scraper, Google Places Scraper, or any local business scraper that returns company names, websites, phone numbers, ratings, categories, and addresses.

> This Actor is not a Google Maps scraper. It does not discover new businesses from Google Maps. It enriches business records and websites that you already provide.

### What You Can Use It For

Use this Actor when you already have a list of local businesses and want to improve the data quality before sending it to sales, marketing, or a CRM.

Common use cases:

- Enrich Google Maps Scraper results with emails, phone numbers, social links, contact pages, booking links, and menu pages.
- Clean and normalize restaurant, salon, clinic, venue, shop, agency, and professional service leads.
- Find missing business contact data from public websites.
- Audit local business websites for CRM-readiness.
- Score leads before cold email, cold calling, agency outreach, or local sales campaigns.
- Convert messy scraped business data into structured output for HubSpot, Pipedrive, Salesforce, Airtable, Google Sheets, or internal data pipelines.
- Keep Google Maps records even when the business has no website.
- Identify unreachable, blocked, expired, or low-quality websites.

### Best For

This Actor is useful for:

- Lead generation agencies
- Local SEO agencies
- Sales development teams
- Restaurant and hospitality data projects
- B2B enrichment workflows
- CRM data cleaning teams
- Growth marketers
- Market researchers
- Data teams building local business databases
- Developers building automation around Apify datasets

Typical industries:

- Restaurants
- Cafes
- Bars
- Salons
- Clinics
- Dentists
- Gyms
- Hotels
- Venues
- Retail stores
- Professional services
- Local service businesses

### Main Features

- Reads from an Apify Dataset ID or direct website URLs.
- Works with Google Maps Scraper and Google Maps-like datasets.
- Supports fields such as `title`, `name`, `companyName`, `website`, `url`, `phone`, `address`, `street`, `city`, `state`, `countryCode`, `categoryName`, `categories`, `rating`, `reviewsCount`, and `placeId`.
- Preserves Google Maps records without websites as source-only leads.
- Crawls the homepage and likely contact, about, location, legal, booking, reservation, and menu pages.
- Uses `CheerioCrawler` for fast HTML crawling and low memory usage.
- Extracts public emails from websites.
- Handles common public email obfuscation such as `name [at] domain [dot] com`.
- Filters fake, example, technical, and placeholder emails.
- Extracts and normalizes phone numbers from source records, `tel:` links, and visible page text.
- Supports international phone normalization with `defaultCountryCode`.
- Filters dates, IDs, tracking numbers, prices, coordinates, card-like numbers, demo numbers, and other phone false positives.
- Extracts social profile links from Instagram, Facebook, LinkedIn, YouTube, TikTok, WhatsApp, and Telegram.
- Filters noisy social URLs such as posts, reels, stories, watch pages, and vendor profile links.
- Detects contact pages, booking links, menu pages, contact forms, SSL, HTTP status, redirects, and schema.org local business data.
- Detects unreachable websites, 403/404 responses, and possible parked or expired domains.
- Deduplicates leads by normalized domain, phone number, and company/address signals.
- Keeps the richest duplicate record and merges useful contact fields.
- Returns a transparent 0-100 lead score, lead quality label, and sales reason.
- Produces clean JSON records suitable for CSV, Excel, Google Sheets, CRM import, or API workflows.

### Why Use This Actor After Google Maps Scraper?

Google Maps Scraper is great for discovering businesses. But many local business datasets still need a second enrichment step.

Google Maps results often contain:

- Business name
- Google Maps URL
- Phone number
- Rating
- Review count
- Category
- Address
- Website URL, when available

This Actor adds website-level enrichment:

- Public email addresses
- Better website phone extraction
- Contact page URL
- Booking or reservation URL
- Menu URL
- Social media profiles
- Website status
- SSL status
- Contact form detection
- Website quality signals
- Lead score
- CRM-ready sales reason

If a Google Maps record has no website, the Actor still outputs the lead instead of dropping it.

### Input Options

You can provide either:

1. An Apify Dataset ID from Google Maps Scraper or another local business scraper.
2. A direct list of business website URLs.
3. Both. Dataset records are processed first, then direct URLs until `maxItems` is reached.

### Input Example

```json
{
  "apifyDatasetId": "YOUR_GOOGLE_MAPS_DATASET_ID",
  "startUrls": [
    "https://example-restaurant.com",
    "https://example-salon.com"
  ],
  "maxItems": 100,
  "maxPhonesPerSite": 10,
  "defaultCountryCode": "US",
  "maxPagesPerWebsite": 5,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30,
  "crawlContactPages": true,
  "extractEmails": true,
  "extractPhones": true,
  "extractSocials": true,
  "checkWebsiteProblems": true,
  "makeLeadScore": true,
  "allowedDomainsOnly": true,
  "debugMode": false
}
````

#### Important Input Fields

| Field | Description |
|---|---|
| `apifyDatasetId` | Dataset ID from Google Maps Scraper or another local business scraper. |
| `startUrls` | Direct business website URLs to enrich. |
| `maxItems` | Maximum number of input businesses to process. |
| `maxPagesPerWebsite` | Maximum number of pages to crawl per business website. |
| `maxPhonesPerSite` | Maximum normalized phone numbers to keep per website. |
| `defaultCountryCode` | Optional ISO 3166-1 alpha-2 country code such as `US`, `DE`, `GB`, `FR`, `IT`, `ES`, or `CA`. Useful when `.com` websites contain local phone numbers. |
| `allowedDomainsOnly` | Keeps crawling on the original business website domain. |
| `debugMode` | Adds more diagnostic information and debug warnings. |

### Google Maps Dataset Support

This Actor supports Google Maps-like records with fields such as:

```json
{
  "title": "Example Restaurant",
  "totalScore": 4.6,
  "reviewsCount": 120,
  "street": "1 Main Street",
  "city": "New York",
  "state": "New York",
  "countryCode": "US",
  "website": "https://example.com",
  "phone": "(212) 555-1234",
  "categories": ["Restaurant"],
  "url": "https://www.google.com/maps/...",
  "categoryName": "Restaurant",
  "placeId": "place123"
}
```

Mapping behavior:

- `title`, `name`, or `companyName` becomes `companyName`.
- `website` becomes `sourceWebsite`.
- Google Maps `url` is preserved as `source.googleMapsUrl` and is not crawled as a business website.
- `totalScore` becomes `source.rating`.
- `reviewsCount` becomes `source.reviewsCount`.
- `phone` is normalized and stored in `phones` when valid.
- `countryCode` is used for local phone normalization.
- `street`, `city`, `state`, and `countryCode` are used to build the source address.

### Output Example

```json
{
  "companyName": "Example Restaurant",
  "sourceWebsite": "https://example.com",
  "finalUrl": "https://www.example.com/",
  "domain": "example.com",
  "emails": ["info@example.com"],
  "phones": ["+12125551234"],
  "socials": {
    "instagram": ["https://instagram.com/example"],
    "facebook": [],
    "linkedin": [],
    "youtube": [],
    "tiktok": [],
    "whatsapp": [],
    "telegram": []
  },
  "contactPage": "https://example.com/contact",
  "bookingUrl": "https://example.com/reservations",
  "menuUrl": "https://example.com/menu",
  "audit": {
    "hasWebsite": true,
    "websiteStatusCode": 200,
    "finalUrl": "https://www.example.com/",
    "hasSsl": true,
    "hasContactPage": true,
    "hasContactForm": true,
    "hasBookingLink": true,
    "hasMenuPage": true,
    "hasSocialLinks": true,
    "hasEmail": true,
    "hasPhone": true,
    "hasSchemaOrgLocalBusiness": true,
    "pageCountCrawled": 4
  },
  "source": {
    "apifyDatasetId": "abc123",
    "googleMapsUrl": "https://www.google.com/maps/...",
    "placeId": "place123",
    "categoryName": "Restaurant",
    "categories": ["Restaurant"],
    "rating": 4.6,
    "reviewsCount": 120,
    "address": "1 Main Street, New York, NY",
    "street": "1 Main Street",
    "city": "New York",
    "state": "New York",
    "countryCode": "US",
    "originalPhone": "(212) 555-1234",
    "phone": "+12125551234"
  },
  "leadScore": 82,
  "leadQuality": "high",
  "salesReason": "Has website, email, phone, social links, and contact form. Good CRM-ready lead.",
  "warnings": [],
  "errors": []
}
```

### Output Fields

| Field | Description |
|---|---|
| `companyName` | Business name from the input dataset or URL. |
| `sourceWebsite` | Website URL from the source dataset or direct input. |
| `finalUrl` | Final crawled URL after redirects. |
| `domain` | Normalized final domain. |
| `emails` | Public business email addresses found on the website. |
| `phones` | Normalized phone numbers in international E.164 format when possible. |
| `socials` | Social profile links grouped by platform. |
| `contactPage` | Best detected contact, location, about, legal, or similar business page. |
| `bookingUrl` | Booking, reservation, appointment, or private party page. |
| `menuUrl` | Menu page for restaurants, cafes, bars, and similar businesses. |
| `audit` | Website quality and enrichment signals. |
| `source` | Original source metadata from Google Maps or another dataset. |
| `leadScore` | Transparent score from 0 to 100. |
| `leadQuality` | `high`, `medium`, or `low`. |
| `salesReason` | Human-readable explanation of the score. |
| `warnings` | Non-fatal data quality or website warnings. |
| `errors` | Per-record errors, if any. |

### Lead Scoring

The Actor assigns a transparent 0-100 lead score.

Positive signals include:

- Valid website
- HTTPS
- Email found
- Phone found
- Contact page found
- Contact form found
- Social links found
- Booking, reservation, or menu link found
- schema.org local business data found

Negative signals include:

- Website unreachable
- HTTP errors such as 403 or 404
- No contact data found
- Possible noisy phone extraction
- Parked or expired domain signals
- Weak or incomplete website enrichment

Quality buckets:

- `high`: strong CRM-ready lead
- `medium`: usable lead with missing enrichment signals
- `low`: weak, source-only, unreachable, or low-confidence lead

### Records Without Websites

If a Google Maps or source record has no website, the Actor still returns a lead.

For source-only leads, it preserves:

- Company name
- Phone number, when available
- Address
- Category
- Rating
- Reviews count
- Google Maps URL
- Place ID

This is useful because many local businesses have no website but still have a valid phone number and Google Maps profile.

### Failed, Blocked, Or Unreachable Websites

If a website returns a 403, 404, timeout, DNS error, or similar failure, the Actor does not crash.

It returns a partial lead with:

- Source data
- Normalized source phone, when available
- Website status code, when known
- Warning message
- Lower lead score

This makes large local business audits more reliable because one blocked website does not break the whole run.

### Email Extraction

The Actor extracts public emails from website HTML and visible text. It also handles common public obfuscation patterns.

It filters common false positives such as:

- `example.com`
- `test.com`
- `localhost`
- `noreply`
- `no-reply`
- `donotreply`
- technical monitoring endpoints
- fake template emails such as `info@yoursite.com`

### Phone Extraction And Normalization

Phones are collected from:

- Source dataset records
- `tel:` links
- Visible website text

The Actor normalizes valid numbers to international format when possible.

To improve phone normalization for local numbers, set:

```json
{
  "defaultCountryCode": "US"
}
```

Examples:

- `(212) 555-1234` with `US` becomes `+12125551234`.
- `030 2391 0482` with `DE` becomes `+493023910482`.

The Actor aggressively rejects phone-like false positives such as dates, prices, IDs, coordinates, tracking codes, card-like numbers, versions, and demo numbers.

### Social Link Extraction

The Actor extracts likely business profile links for:

- Instagram
- Facebook
- LinkedIn
- YouTube
- TikTok
- WhatsApp
- Telegram

It filters noisy URLs such as:

- Instagram posts and reels
- Instagram stories
- Facebook events and photo URLs
- YouTube watch URLs
- Vendor or platform social profiles when they are unlikely to belong to the business

### How To Use With Google Maps Scraper

1. Run Google Maps Scraper or another local business scraper.
2. Open the scraper run.
3. Go to the default dataset.
4. Copy the Dataset ID.
5. Open this Actor.
6. Paste the Dataset ID into `apifyDatasetId`.
7. Set `defaultCountryCode`, for example `US`, `DE`, `GB`, or `FR`.
8. Start with `maxItems: 25` for a test run.
9. Increase `maxItems` for production.
10. Export results as JSON, CSV, Excel, or connect the dataset to your CRM workflow.

### Common Workflows

#### Google Maps Scraper To CRM

1. Scrape local businesses with Google Maps Scraper.
2. Pass the dataset ID into this Actor.
3. Export enriched leads.
4. Filter leads by `leadQuality`, `leadScore`, `emails`, `phones`, or `warnings`.
5. Import into HubSpot, Pipedrive, Salesforce, Airtable, Google Sheets, or a custom CRM.

#### Local SEO Agency Audit

1. Provide a list of business websites.
2. Find missing contact pages, missing forms, missing emails, weak websites, or expired domains.
3. Prioritize outreach based on `leadScore` and `salesReason`.

#### Restaurant Lead Enrichment

1. Use Google Maps Scraper to collect restaurants in a city.
2. Run this Actor to find emails, phone numbers, menus, booking pages, and social profiles.
3. Export CRM-ready restaurant leads.

### Recommended Settings

#### Small test run

```json
{
  "maxItems": 25,
  "maxPagesPerWebsite": 5,
  "maxConcurrency": 2,
  "debugMode": false
}
```

#### Production run

```json
{
  "maxItems": 500,
  "maxPagesPerWebsite": 5,
  "maxConcurrency": 5,
  "debugMode": false
}
```

#### More careful audit

```json
{
  "maxItems": 100,
  "maxPagesPerWebsite": 10,
  "maxConcurrency": 2,
  "debugMode": true
}
```

### Limitations

- This Actor does not discover businesses. It enriches business records and websites you provide.
- It does not scrape Google Maps directly.
- It does not use paid email verification, phone verification, WHOIS, Google APIs, or proprietary databases.
- It cannot extract data hidden behind logins, CAPTCHAs, paywalls, blocked pages, or heavy client-side rendering.
- It uses HTML crawling by default. JavaScript-rendered contact data may be missed.
- Phone normalization depends on country inference and `defaultCountryCode` for local numbers.
- Some third-party platform emails or social links may still require manual review.
- Website terms, privacy laws, and outreach regulations vary by jurisdiction.

### FAQ

#### Is this a Google Maps scraper?

No. This Actor does not scrape Google Maps. It enriches datasets created by Google Maps Scraper or similar local business scrapers.

#### Can I use it with Google Maps Scraper?

Yes. Copy the default Dataset ID from your Google Maps Scraper run and paste it into `apifyDatasetId`.

#### Can I use it without Google Maps Scraper?

Yes. You can provide direct business website URLs in `startUrls`.

#### Does it find emails?

Yes. It extracts public business emails from source websites and filters common fake, example, technical, and placeholder emails.

#### Does it normalize phone numbers?

Yes. It normalizes valid phone numbers to international format when possible. Use `defaultCountryCode` for local numbers on generic domains.

#### Does it crawl social media pages?

No. It extracts social profile links but does not crawl social media platforms.

#### Does it use Playwright?

No. It uses `CheerioCrawler` by default for speed and lower memory usage.

#### Can it handle websites without contact pages?

Yes. It still returns whatever contact, website, source, and audit data is available.

#### What happens if a website is blocked or returns 403?

The Actor outputs a partial lead with source data, website status, warning, and a lower lead score.

#### Can I export to CSV or Excel?

Yes. Apify datasets can be exported as JSON, CSV, Excel, XML, RSS, or JSONL.

### Privacy And Legal Note

This Actor only extracts publicly available business contact data from user-provided websites and user-provided datasets.

You are responsible for using the results lawfully, respecting website terms, privacy laws, data protection rules, anti-spam laws, and outreach regulations in your jurisdiction.

### Local Development

```bash
npm install
npm run lint
npm run typecheck
npm test
npm run build
apify run
```

The sample local input is stored in:

```text
storage/key_value_stores/default/INPUT.json
```

### Related Keywords

Google Maps lead enrichment, Google Maps Scraper enrichment, local business lead enrichment, business contact finder, email extractor, phone number extractor, local business email finder, website contact scraper, restaurant lead scraper, CRM lead enrichment, Apify lead generation, local SEO audit, business website auditor, Google Places enrichment, contact data extraction, sales lead enrichment, B2B lead enrichment, restaurant email finder, local business database cleaner, website audit scraper.

# Actor input Schema

## `apifyDatasetId` (type: `string`):

Optional dataset ID containing business records. Expected fields include title, name, companyName, website, url, phone, address, categoryName, categories, rating, reviewsCount, and placeId.

## `startUrls` (type: `array`):

Optional direct list of business website URLs. String URLs and Apify request-list objects with a url field are accepted.

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

Maximum number of input businesses to process across dataset records and direct URLs.

## `maxPhonesPerSite` (type: `integer`):

Maximum number of reliable phone numbers to keep per website after source-aware filtering. Tel links are kept first.

## `defaultCountryCode` (type: `string`):

Optional ISO 3166-1 alpha-2 country code used to normalize local phone numbers when the country cannot be inferred automatically. Examples: DE, US, GB, FR, IT.

## `maxPagesPerWebsite` (type: `integer`):

Maximum number of pages to crawl for each business website, including the homepage.

## `maxConcurrency` (type: `integer`):

Maximum number of concurrent HTTP requests used by CheerioCrawler.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each page request and handler.

## `crawlContactPages` (type: `boolean`):

When enabled, the Actor follows likely contact, about, impressum, booking, reservation, menu, legal, and privacy pages on the same website.

## `extractEmails` (type: `boolean`):

Extract email addresses from text and mailto links, including common public obfuscation patterns.

## `extractPhones` (type: `boolean`):

Extract phone numbers from visible page text and tel links.

## `extractSocials` (type: `boolean`):

Extract Instagram, Facebook, LinkedIn, YouTube, TikTok, WhatsApp, and Telegram links.

## `checkWebsiteProblems` (type: `boolean`):

Detect SSL, contact pages, contact forms, booking/menu pages, schema.org business data, and missing contact data.

## `makeLeadScore` (type: `boolean`):

Calculate a transparent 0-100 lead score and quality label.

## `allowedDomainsOnly` (type: `boolean`):

When enabled, the Actor will not crawl pages outside the original business website domain.

## `debugMode` (type: `boolean`):

Enable more verbose run logs.

## Actor input object example

```json
{
  "startUrls": [
    "https://example.com",
    "https://www.iana.org/domains/reserved"
  ],
  "maxItems": 100,
  "maxPhonesPerSite": 10,
  "defaultCountryCode": "DE",
  "maxPagesPerWebsite": 5,
  "maxConcurrency": 5,
  "requestTimeoutSecs": 30,
  "crawlContactPages": true,
  "extractEmails": true,
  "extractPhones": true,
  "extractSocials": true,
  "checkWebsiteProblems": true,
  "makeLeadScore": true,
  "allowedDomainsOnly": true,
  "debugMode": false
}
```

# Actor output Schema

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

Default dataset items containing enriched contact data, socials, audit flags, lead scores, and source metadata.

# 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 = {
    "startUrls": [
        "https://example.com",
        "https://www.iana.org/domains/reserved"
    ],
    "defaultCountryCode": "DE"
};

// Run the Actor and wait for it to finish
const run = await client.actor("leadforge412/local-business-lead-enricher-website-contact-auditor").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 = {
    "startUrls": [
        "https://example.com",
        "https://www.iana.org/domains/reserved",
    ],
    "defaultCountryCode": "DE",
}

# Run the Actor and wait for it to finish
run = client.actor("leadforge412/local-business-lead-enricher-website-contact-auditor").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 '{
  "startUrls": [
    "https://example.com",
    "https://www.iana.org/domains/reserved"
  ],
  "defaultCountryCode": "DE"
}' |
apify call leadforge412/local-business-lead-enricher-website-contact-auditor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=leadforge412/local-business-lead-enricher-website-contact-auditor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Local Business Lead Enricher & Website Contact Auditor",
        "description": "Enrich Google Maps Scraper results and local business lists with emails, phones, social links, website checks, contact pages, and transparent CRM-ready lead scores.",
        "version": "0.1",
        "x-build-id": "hcevlY7zIJfNdmdFe"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/leadforge412~local-business-lead-enricher-website-contact-auditor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-leadforge412-local-business-lead-enricher-website-contact-auditor",
                "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/leadforge412~local-business-lead-enricher-website-contact-auditor/runs": {
            "post": {
                "operationId": "runs-sync-leadforge412-local-business-lead-enricher-website-contact-auditor",
                "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/leadforge412~local-business-lead-enricher-website-contact-auditor/run-sync": {
            "post": {
                "operationId": "run-sync-leadforge412-local-business-lead-enricher-website-contact-auditor",
                "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": {
                    "apifyDatasetId": {
                        "title": "Apify Dataset ID",
                        "type": "string",
                        "description": "Optional dataset ID containing business records. Expected fields include title, name, companyName, website, url, phone, address, categoryName, categories, rating, reviewsCount, and placeId."
                    },
                    "startUrls": {
                        "title": "Business website URLs",
                        "type": "array",
                        "description": "Optional direct list of business website URLs. String URLs and Apify request-list objects with a url field are accepted.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxItems": {
                        "title": "Maximum input businesses",
                        "minimum": 1,
                        "type": "integer",
                        "description": "Maximum number of input businesses to process across dataset records and direct URLs.",
                        "default": 100
                    },
                    "maxPhonesPerSite": {
                        "title": "Maximum phones per website",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Maximum number of reliable phone numbers to keep per website after source-aware filtering. Tel links are kept first.",
                        "default": 10
                    },
                    "defaultCountryCode": {
                        "title": "Default country code",
                        "type": "string",
                        "description": "Optional ISO 3166-1 alpha-2 country code used to normalize local phone numbers when the country cannot be inferred automatically. Examples: DE, US, GB, FR, IT.",
                        "default": null
                    },
                    "maxPagesPerWebsite": {
                        "title": "Maximum pages per website",
                        "minimum": 1,
                        "maximum": 25,
                        "type": "integer",
                        "description": "Maximum number of pages to crawl for each business website, including the homepage.",
                        "default": 5
                    },
                    "maxConcurrency": {
                        "title": "Maximum concurrency",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Maximum number of concurrent HTTP requests used by CheerioCrawler.",
                        "default": 5
                    },
                    "requestTimeoutSecs": {
                        "title": "Request timeout seconds",
                        "minimum": 5,
                        "maximum": 120,
                        "type": "integer",
                        "description": "Timeout for each page request and handler.",
                        "default": 30
                    },
                    "crawlContactPages": {
                        "title": "Crawl contact and business pages",
                        "type": "boolean",
                        "description": "When enabled, the Actor follows likely contact, about, impressum, booking, reservation, menu, legal, and privacy pages on the same website.",
                        "default": true
                    },
                    "extractEmails": {
                        "title": "Extract emails",
                        "type": "boolean",
                        "description": "Extract email addresses from text and mailto links, including common public obfuscation patterns.",
                        "default": true
                    },
                    "extractPhones": {
                        "title": "Extract phone numbers",
                        "type": "boolean",
                        "description": "Extract phone numbers from visible page text and tel links.",
                        "default": true
                    },
                    "extractSocials": {
                        "title": "Extract social links",
                        "type": "boolean",
                        "description": "Extract Instagram, Facebook, LinkedIn, YouTube, TikTok, WhatsApp, and Telegram links.",
                        "default": true
                    },
                    "checkWebsiteProblems": {
                        "title": "Audit website quality signals",
                        "type": "boolean",
                        "description": "Detect SSL, contact pages, contact forms, booking/menu pages, schema.org business data, and missing contact data.",
                        "default": true
                    },
                    "makeLeadScore": {
                        "title": "Calculate lead score",
                        "type": "boolean",
                        "description": "Calculate a transparent 0-100 lead score and quality label.",
                        "default": true
                    },
                    "allowedDomainsOnly": {
                        "title": "Stay on original domain",
                        "type": "boolean",
                        "description": "When enabled, the Actor will not crawl pages outside the original business website domain.",
                        "default": true
                    },
                    "debugMode": {
                        "title": "Debug logging",
                        "type": "boolean",
                        "description": "Enable more verbose run logs.",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
