# Public B2B Contact Lookup — Lusha Alternative (`khadinakbar/lusha-alternative`) Actor

Look up public business contact evidence for people and employer domains you already know. Export published contact values, source URLs, page context, timestamps, and per-contact outcomes for CRM review.

- **URL**: https://apify.com/khadinakbar/lusha-alternative.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $120.00 / 1,000 public contact evidence founds

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/actors/running/actors-in-store.md#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

## Public B2B Contact Lookup — Lusha Alternative

Look up public business contact evidence for people and employer domains you already know. Export published contact values, source URLs, page context, timestamps, and per-contact outcomes for CRM review. For CRM owners, each dataset result records a known person's public company-page contact evidence and collection outcome.

### Workflow: put the results to work

Begin with a known person and employer domain from your CRM. Review the public page context alongside any contact value, then decide whether the record needs correction or additional research. The lookup preserves observed evidence without asserting mailbox ownership.

### Best fit and next step

Choose this Actor when your workflow begins with a person and employer domain you already know, and your decision needs fresh, reviewable website evidence. It is designed as a focused standalone workflow for CRM cleanup, account research, and contact-review queues.

For broad prospect discovery, proprietary emails, direct dials, mobile data, or sales-suite orchestration, continue with an approved licensed data provider whose coverage and permitted use match that wider job.

### Workflow story

An operations specialist starts with a CRM list containing each person’s full name and employer domain. The specialist passes that list to this Actor, then receives one cited evidence row per accepted contact. Next, the specialist reviews the source URL and role context, exports the dataset, and feeds confirmed records into the team’s approved CRM-quality or research process.

### Input

Supply one to 25 known contacts. Optional company-owned `sourceUrls` make the check especially precise; otherwise the Actor starts from the homepage and a small set of standard public routes.

```json
{
    "contacts": [
        {
            "fullName": "Ada Lovelace",
            "companyDomain": "example.com",
            "companyName": "Example Ltd",
            "externalId": "crm-001",
            "sourceUrls": ["https://example.com/team/ada-lovelace"]
        }
    ],
    "maxContacts": 25,
    "maxPagesPerContact": 3,
    "requestTimeoutSecs": 10,
    "responseFormat": "detailed",
    "useApifyUnblockerFallback": true
}
```

### Output dataset

The default dataset contains one complete evidence row for each accepted contact. Every contact value carries the public company-page URL that supported it.

| Field                     | Meaning                                                                                          |
| ------------------------- | ------------------------------------------------------------------------------------------------ |
| `nameMatched`             | The supplied full name appeared in visible text on a public page of the supplied company domain. |
| `identityEvidence`        | Source URL, page title, and optional surrounding role context for each match.                    |
| `publishedBusinessEmails` | Business email values visibly published on a matched page, each with source URLs.                |
| `publishedBusinessPhones` | Telephone-link values visibly published on a matched page, each with source URLs.                |
| `collectionOutcome`       | Per-contact collection state for a match, a completed empty check, or a source-recovery result.  |
| `collectedAt`             | ISO 8601 collection time for downstream freshness review.                                        |

```json
{
    "contactKey": "crm-001",
    "externalId": "crm-001",
    "fullName": "Ada Lovelace",
    "companyDomain": "example.com",
    "companyName": "Example Ltd",
    "nameMatched": true,
    "profileUrl": "https://example.com/team/ada-lovelace",
    "publicTitle": "Leadership | Example Ltd",
    "roleSnippet": "Ada Lovelace, Chief Scientist",
    "publishedBusinessEmails": [
        {
            "value": "ada@example.com",
            "sourceUrls": ["https://example.com/team/ada-lovelace"]
        }
    ],
    "publishedBusinessPhones": [],
    "publishedLinkedInProfileUrls": [],
    "identityEvidence": [
        {
            "sourceUrl": "https://example.com/team/ada-lovelace",
            "pageTitle": "Leadership | Example Ltd",
            "roleSnippet": "Ada Lovelace, Chief Scientist"
        }
    ],
    "fetchedSourceUrls": ["https://example.com/team/ada-lovelace"],
    "matchedSourceUrls": ["https://example.com/team/ada-lovelace"],
    "fetchRoutes": ["direct"],
    "collectionOutcome": "MATCHED_PUBLIC_CONTACT",
    "warnings": [],
    "collectedAt": "ISO-8601 timestamp supplied at collection time"
}
```

`OUTPUT` provides the compact run outcome and count summary. `RUN_SUMMARY` adds route, charge, and collection diagnostics for a complete readback.

### Comparison: a bounded workflow alongside Lusha

| Decision dimension          | This Actor                                                                                                                | Lusha and broader prospecting suites                                        |
| --------------------------- | ------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------- |
| Workflow scope              | Starts with a known person and employer domain, then collects bounded public company-page evidence.                       | Supports wider prospecting and contact-data workflows.                      |
| Billing and same-job cost   | Pay per event pricing is stated per public name-match evidence record, with platform usage shown separately.              | Plan and credit allocation guide the applicable workload cost.              |
| Effective efficiency        | One machine-readable row keeps identity evidence, source URLs, collection time, and outcome together for operator review. | Broader suite workflows can serve data-search and sales-process needs.      |
| Input friction              | Full name and employer domain create a focused, auditable starting point.                                                 | Search and filtering workflows can start from broader prospecting criteria. |
| Output contract             | Typed public values carry their source URLs, plus a concise outcome and warnings.                                         | Product-specific records and fields depend on the selected Lusha workflow.  |
| Integrations and automation | Apify dataset/API readback supports batch handoff and scheduled operation after live configuration.                       | Lusha documents its own integration and workspace capabilities.             |
| Freshness and provenance    | Each collection pass reads public pages again and records collection time alongside source URLs.                          | Provider database freshness follows the provider’s documented operations.   |

### API example

```bash
curl -sS -X POST "https://api.apify.com/v2/acts/khadinakbar~lusha-alternative/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "contacts": [
      {
        "fullName": "Ada Lovelace",
        "companyDomain": "example.com",
        "externalId": "crm-001"
      }
    ],
    "maxPagesPerContact": 3
  }'
```

After collection completes, read the default dataset together with `OUTPUT` and `RUN_SUMMARY` for source provenance, collection outcome, and event-charge readback.

### AI agent and MCP guidance

An AI agent or MCP client can use the Actor as a bounded public-evidence step before a downstream CRM-quality decision.

> Check these known CRM contacts against public pages on their supplied employer domains. Return the dataset rows, cite the source URLs, read the `OUTPUT` outcome, and keep the resulting contact evidence separate from broad prospect discovery.

The agent should preserve `externalId`, use `collectionOutcome` to route follow-up, and include source URLs and collection time in any human-facing summary. The event price and platform usage remain part of the run’s cost context.

### Practical guidance

Provide the most specific public team, leadership, or bio page through `sourceUrls` when it is already known. Start with a small contact set, confirm the cited source context, then schedule the same focused input pattern for recurring CRM-quality work. The direct route receives a short retry, and Apify Unblocker can add a single public-page route when enabled.

### Builder's note

I designed this Actor around a simple invariant: every returned contact value should point back to a public page owned by the supplied employer domain. My goal was a small, reviewable evidence set that helps a person make a clear CRM or research decision without hiding the source context.

### Responsible use

Use contacts and company domains you are authorized to research, respect applicable laws and site terms, and review the cited public page before taking downstream action. Public availability supports evidence review; your organization’s privacy, marketing, employment, and data-governance standards guide the next step.

### Relationship to Lusha

`Lusha is a trademark of its owner. This independent Actor is not affiliated, associated, or endorsed by Lusha.`

### Provider architecture

The primary workflow reads the public employer pages supplied by the caller, so it operates without a third-party contact-data API. A future data-provider route can be added after an approved pay-per-use provider, permitted-use review, field-parity probe, and live acceptance matrix are in place.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/lusha-alternative/pricing) lists the current event rates and billing terms.

| Event | Billing unit | When it applies |
|---|---|---|
| `apify-actor-start` | Actor Start | Charged when the Actor starts running. Number of events charged depends on Actor memory (one event per GB, minimum one event). |
| `public-contact-found` | Public contact evidence found | One persisted, source-cited record where the supplied person appeared on a public page of the supplied company domain. Valid-empty, invalid, and unavailable-source records are not charged. |

Run cost combines the charged events and Apify platform usage. Review the run charge limit and requested result count before starting.

### Connect an AI agent

Use the [Apify MCP configurator](https://mcp.apify.com) to choose an available client connection. Inspect this Actor’s current input schema and required credentials before running it.

# Actor input Schema

## `contacts` (type: `array`):

Provide 1 to 25 people you already know, each with a full name and the employer’s public website domain. Optional companyName and externalId are carried through so the returned evidence can join back to your CRM or spreadsheet. Optional sourceUrls must be HTTPS pages on that same employer domain and are checked before standard public pages. This Actor is not a free-text people search, LinkedIn scraper, email-pattern generator, or outreach tool.

## `maxContacts` (type: `integer`):

Hard cap on distinct valid contacts processed in one run. Defaults to 25 and accepts 1 to 25, limiting public-page collection and the maximum public-contact-found event charge. Duplicate name-and-domain entries are skipped before collection. Apify platform usage is billed separately to the caller.

## `maxPagesPerContact` (type: `integer`):

How many public company-owned pages to inspect per contact, from 1 to 3. The Actor tries caller-provided source URLs first, then bounded standard public routes. Defaults to 3 to make the evidence set small and reviewable. It never crawls a whole website or follows a redirect to another domain.

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

Maximum wait for each direct or fallback public-page request. Defaults to 10 seconds and accepts 5 to 20 seconds, keeping a single run bounded. A transient or blocked direct request gets one short retry and, if enabled, one Apify Unblocker fallback. This does not extend the overall Actor timeout.

## `responseFormat` (type: `string`):

Choose detailed to include a short surrounding role snippet for every name match, or concise to omit snippets while keeping source URLs and structured evidence. Defaults to detailed for human review. The setting does not change which pages are fetched. It does not infer a title, email, or phone number when evidence is absent.

## `useApifyUnblockerFallback` (type: `boolean`):

After a direct request is blocked or transiently unavailable, make one bounded retry through Apify Unblocker. Defaults to true to improve public-page reachability while preserving the same domain and redirect checks. Unblocker is Apify platform usage paid by the caller, not an external contact-data subscription. Disable it for a direct-only control run.

## Actor input object example

```json
{
  "contacts": [
    {
      "fullName": "Ada Lovelace",
      "companyDomain": "example.com",
      "companyName": "Example Ltd",
      "externalId": "crm-001"
    }
  ],
  "maxContacts": 25,
  "maxPagesPerContact": 3,
  "requestTimeoutSecs": 10,
  "responseFormat": "detailed",
  "useApifyUnblockerFallback": true
}
```

# Actor output Schema

## `dataset` (type: `string`):

One source-cited result for each accepted input contact, including valid-empty and upstream-failure rows.

## `output` (type: `string`):

Compact terminal outcome, counts, billing events, and warnings.

## `runSummary` (type: `string`):

Detailed operational diagnostics, source-fetch routes, and per-run completion state.

# 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 = {
    "contacts": [
        {
            "fullName": "Ada Lovelace",
            "companyDomain": "example.com",
            "companyName": "Example Ltd",
            "externalId": "crm-001"
        }
    ],
    "maxContacts": 25,
    "maxPagesPerContact": 3,
    "requestTimeoutSecs": 10,
    "responseFormat": "detailed",
    "useApifyUnblockerFallback": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/lusha-alternative").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 = {
    "contacts": [{
            "fullName": "Ada Lovelace",
            "companyDomain": "example.com",
            "companyName": "Example Ltd",
            "externalId": "crm-001",
        }],
    "maxContacts": 25,
    "maxPagesPerContact": 3,
    "requestTimeoutSecs": 10,
    "responseFormat": "detailed",
    "useApifyUnblockerFallback": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/lusha-alternative").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 '{
  "contacts": [
    {
      "fullName": "Ada Lovelace",
      "companyDomain": "example.com",
      "companyName": "Example Ltd",
      "externalId": "crm-001"
    }
  ],
  "maxContacts": 25,
  "maxPagesPerContact": 3,
  "requestTimeoutSecs": 10,
  "responseFormat": "detailed",
  "useApifyUnblockerFallback": true
}' |
apify call khadinakbar/lusha-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/lusha-alternative"
        }
    }
}

```

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/n7oPOKjLe1OLcfC5Q/builds/CjK8T1yyn5tcjyr0I/openapi.json