# Visitor IP Enrichment Tool — Leadfeeder Alternative (`khadinakbar/leadfeeder-alternative`) Actor

Enrich authorized website-visitor IP exports with public network evidence. Get registry or ASN organization candidates, reverse DNS, visit context, and source URLs per IP. Results identify networks, not people or verified employers.

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

## Pricing

from $100.00 / 1,000 network organization candidate identifieds

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

## Visitor IP Enrichment Tool — Leadfeeder Alternative

Enrich authorized website-visitor IP exports with public network evidence. Get registry or ASN organization candidates, reverse DNS, visit context, and source URLs per IP. Results identify networks, not people or verified employers. For analytics and sales-operations reviewers, each dataset record represents one public network IP with grouped visit context.

### Workflow: put the results to work

Export authorized public visitor IPs from your server, CDN, or consented analytics system. Retain useful page-path context, then review registry and ASN evidence for each network. Treat an organization candidate as a research lead, not confirmation of the visitor's employer.

### Best fit for this Actor

- Start with an authorized export from web-server, CDN, or consented analytics logs that has public IP addresses and optional relative page-path context.
- Group repeat events into one source-cited network record before a human decides whether any candidate deserves a separate B2B research step.
- Use source URLs, candidate evidence, reverse DNS, and collection time to audit what the actor observed instead of treating an opaque match as fact.

For a browser-side visitor product with a proprietary IP-to-company graph, real-time tracker, CRM synchronization, team workspace, contact activation, and historical reporting, Leadfeeder remains the broader product.

### How this workflow compares with Leadfeeder

This Actor covers one bounded workflow: enriching caller-supplied, authorized visitor IP exports with current public network-registration and optional ASN evidence. Leadfeeder describes a broader website-visitor product that tracks visits, matches them against its proprietary database, filters traffic, and supports CRM and activation workflows.

| Decision | This Actor | Leadfeeder | Best fit |
| --- | --- | --- | --- |
| Starting point | Authorized IP/event export supplied at run time. | A website tracking setup and its visitor-identification product. | Use this Actor for a bounded export review; use Leadfeeder for an ongoing tracked-visitor workspace. |
| Match meaning | Network operator or address-block organization candidate with source evidence. | Company matching using Leadfeeder's proprietary IP database and signals. | Treat this Actor's candidate as network evidence, not proof of a visiting employer. |
| Engagement context | Groups supplied relative paths, timestamps, and durations. | Tracks page engagement and visitor history in the platform. | Use Leadfeeder when durable visit history and in-product analysis are required. |
| Output and provenance | Dataset records include source URLs, provider routes, reverse DNS, and collection time. | Leadfeeder documents company and visit workflows in its product. | Use the Actor when a JSON record with source provenance is the needed next step. |
| Integrations and automation | Uses the Apify regular-run API with dataset, OUTPUT, and RUN\_SUMMARY readback. | Leadfeeder documents CRM and visitor-workflow features in its product. | Select the API contract and downstream system that fits the approved workflow. |
| Billing | Pay per event plus Apify platform usage; see the live Pricing tab for current terms. | Leadfeeder publishes free and subscription plan tiers with usage limits and activation credits. | Compare the current plan and Pricing tab against the same authorized input volume. |

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

### Workflow: from an export to reviewable network evidence

- Export public visitor-IP events that you are authorized to process from a server, CDN, or consented analytics source.
- Send the IP, an optional opaque export ID, and relative page path. The Actor drops query strings from page paths.
- The Actor groups events by IP, reads public RDAP registration data, optionally checks reverse DNS, and uses optional owner-configured IPinfo Lite ASN data when available.
- Review the organization candidate with its evidence and source URLs as a network-level candidate.
- Pass approved, evidence-backed candidates to a separate company-research, CRM, or outreach workflow.

### Quick start

Provide one to 500 authorized events. The Actor aggregates at most 100 unique IPs in one run.

```json
{
  "visits": [
    {
      "ipAddress": "8.8.8.8",
      "pagePath": "/pricing",
      "externalId": "export-row-001",
      "observedAt": "2026-09-07T12:00:00.000Z",
      "durationSeconds": 48
    },
    {
      "ipAddress": "8.8.8.8",
      "pagePath": "/contact",
      "externalId": "export-row-002",
      "observedAt": "2026-09-07T12:04:00.000Z",
      "durationSeconds": 31
    }
  ],
  "maxVisitors": 20,
  "requestTimeoutSecs": 12,
  "includeReverseDns": true,
  "preferIpinfoLite": true
}
```

### Data you receive

One dataset record represents one public visitor IP after grouping.

| Field | Meaning |
| --- | --- |
| organizationCandidate | A network operator or address-block organization candidate, not a verified visiting employer or person. |
| organizationCandidateEvidence | The evidence type and source URL for the candidate. |
| pagePaths and highIntentPagePaths | Deduplicated, caller-supplied relative paths. High-interest paths are transparent labels, not inferred buyer intent. |
| rdap, ipinfoLite, and reverseDns | Public network evidence returned by each enabled route. |
| sourceUrls and collectedAt | Source provenance and lookup time for the record. |
| identificationStatus | Whether a network organization candidate was attributable from the returned evidence. |

```json
{
  "ipAddress": "8.8.8.8",
  "externalIds": [
    "export-row-001",
    "export-row-002"
  ],
  "visitCount": 2,
  "pagePaths": [
    "/pricing",
    "/contact"
  ],
  "organizationCandidate": "Google LLC",
  "organizationCandidateEvidence": {
    "type": "rdap_entity",
    "sourceUrl": "https://rdap.arin.net/registry/ip/8.8.8.8"
  },
  "identificationStatus": "NETWORK_ORGANIZATION_IDENTIFIED",
  "identificationScope": "Network operator or registered address-block entity only; not a verified employer, account, or individual website visitor.",
  "reverseDns": [
    "dns.google"
  ],
  "sourceUrls": [
    "https://rdap.arin.net/registry/ip/8.8.8.8"
  ],
  "collectedAt": "2026-09-07T12:00:00.000Z"
}
```

The default key-value store also writes OUTPUT for a compact terminal result and RUN\_SUMMARY for source-route diagnostics, cap state, and non-secret run metrics.

### Run from the API

Set APIFY\_TOKEN locally, start a run, then read both the dataset and terminal records.

```bash
curl "https://api.apify.com/v2/acts/khadinakbar~leadfeeder-alternative/runs?token=$APIFY_TOKEN" \
  -X POST \
  -H "content-type: application/json" \
  -d '{
    "visits": [
      {
        "ipAddress": "8.8.8.8",
        "pagePath": "/pricing",
        "externalId": "export-row-001"
      }
    ],
    "maxVisitors": 1
  }'
```

Retrieve the run's default dataset, then inspect OUTPUT and RUN\_SUMMARY before automating any downstream action.

### For AI-agent workflows

> I am an AI agent handling authorized server-log visitor events containing public IP addresses and relative page paths. Group them by IP, report the named run outcome and dataset readback, return source-cited network organization candidates with source URLs and collection time, show observed paths and timestamps, and clearly state the network-evidence scope before any downstream decision.

The Actor is read-only with respect to external sources. It creates an Apify dataset and terminal run records. Valid input with a source outage produces an explicit diagnostic, while invalid input and useful partial records retain their named outcomes.

### Best results and limits

| Starting situation | Recommended action | Expected result |
| --- | --- | --- |
| You have server/CDN IP export data | Start with a small maxVisitors canary. | Grouped network records with auditable source evidence. |
| You need current ASN context | Keep preferIpinfoLite enabled when the owner has configured the optional free source. | Additional ASN name and domain context without putting a token in input. |
| You need the company that employed a visitor | Review the network evidence, then use a separately licensed visitor-intelligence provider or authorized company-research process. | A defensible next step without presenting a network owner as a verified employer. |
| You need individual identity or contact data | Use a consented first-party form or customer-authorized identity workflow. | This Actor intentionally does not provide person identification. |

RDAP and reverse DNS can be incomplete, changed, unavailable, or associated with an ISP, cloud host, VPN, mobile carrier, shared office, or network operator. A returned candidate is therefore evidence about the network address, not proof that a named company or person visited your site.

### Optional third-party source

The default workflow uses public RDAP and optional reverse DNS, so no paid third-party API is required. If the owner configures the free IPinfo Lite service as an encrypted IPINFO\_LITE\_TOKEN environment variable, the Actor can add basic ASN name/domain context. The token never belongs in the input, dataset, terminal records, or logs.

Leadfeeder-style employer-level coverage, residential/mobile resolution, proprietary account matching, and contact enrichment use a separately licensed visitor-intelligence provider, an approved data-rights review, a provider-specific pricing gate, and a dedicated acceptance matrix.

### Responsible use

Run only against visitor events you are authorized to process. Respect applicable privacy, data-protection, and website terms; minimize exported fields; keep any opaque IDs non-personal; and review source evidence before a sales or marketing action. The Actor intentionally avoids person-level identity, cookies, browser fingerprints, credential collection, and covert tracking.

### Builder's note

Visitor-enrichment products can make a network label look more certain than it is. I designed this workflow to keep the input bounded, preserve the caller's page context, and return source-level evidence beside every candidate so an operator or agent can distinguish a network operator from a verified account match.

### Pricing and run costs

This Actor uses **Pay per event plus Apify platform usage**. The [Pricing tab](https://apify.com/khadinakbar/leadfeeder-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). |
| `network-organization-identified` | Network organization candidate identified | Charged only after a schema-valid visitor-network record with an attributable network-organization candidate is persisted. |

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

## `visits` (type: `array`):

Provide 1–500 authorized visitor events from server or CDN logs, for example an IP address with a relative page path. Each event must include a public IPv4 or IPv6 address such as "8.8.8.8"; private, local, and reserved addresses are rejected. Use only data you are authorized to process, not browser-side identities or credentialed logs. Events are aggregated into one network-enrichment record per IP address.

## `maxVisitors` (type: `integer`):

Maximum number of unique public IP addresses to enrich after grouping, from 1 to 100. The default is 20 and provides a bounded first run; duplicate events for an accepted IP stay in the same result. Use a smaller value to canary a new export or constrain event charges. This is a unique-IP cap, not a raw visit-event cap.

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

Per-source lookup timeout from 5 to 30 seconds, with a default of 12 seconds. Use the default for normal registry and DNS lookups; lower values prioritize quick diagnostics and higher values tolerate a slow public registry. This controls one source request, not the total run duration. The Actor preserves source diagnostics rather than retrying indefinitely.

## `includeReverseDns` (type: `boolean`):

When enabled, the Actor asks public DNS for hostnames associated with each IP address and returns any response as supporting network evidence. It defaults to true and is useful when a registry record alone does not expose a readable network label. Disable it only when DNS lookup is outside your data-processing policy. Reverse DNS is context, not proof of the visiting employer.

## `preferIpinfoLite` (type: `boolean`):

When enabled, the Actor uses the owner-configured free IPinfo Lite source if an encrypted IPINFO\_LITE\_TOKEN environment secret is available, then retains public registry evidence. It defaults to true but never asks you to supply a token in the input, and the Actor works through public RDAP when the optional source is not configured. Disable it to use public registry and DNS sources only. IPinfo Lite adds ASN context, not proprietary visitor-company identity.

## Actor input object example

```json
{
  "visits": [
    {
      "ipAddress": "8.8.8.8",
      "pagePath": "/pricing",
      "externalId": "export-row-001",
      "observedAt": "2026-09-07T12:00:00.000Z",
      "durationSeconds": 48
    }
  ],
  "maxVisitors": 20,
  "requestTimeoutSecs": 12,
  "includeReverseDns": true,
  "preferIpinfoLite": true
}
```

# Actor output Schema

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

No description

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

No description

## `visitorNetworks` (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 = {
    "visits": [
        {
            "ipAddress": "8.8.8.8",
            "pagePath": "/pricing",
            "externalId": "export-row-001",
            "observedAt": "2026-09-07T12:00:00.000Z",
            "durationSeconds": 48
        }
    ],
    "maxVisitors": 20,
    "requestTimeoutSecs": 12,
    "includeReverseDns": true,
    "preferIpinfoLite": true
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/leadfeeder-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 = {
    "visits": [{
            "ipAddress": "8.8.8.8",
            "pagePath": "/pricing",
            "externalId": "export-row-001",
            "observedAt": "2026-09-07T12:00:00.000Z",
            "durationSeconds": 48,
        }],
    "maxVisitors": 20,
    "requestTimeoutSecs": 12,
    "includeReverseDns": True,
    "preferIpinfoLite": True,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/leadfeeder-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 '{
  "visits": [
    {
      "ipAddress": "8.8.8.8",
      "pagePath": "/pricing",
      "externalId": "export-row-001",
      "observedAt": "2026-09-07T12:00:00.000Z",
      "durationSeconds": 48
    }
  ],
  "maxVisitors": 20,
  "requestTimeoutSecs": 12,
  "includeReverseDns": true,
  "preferIpinfoLite": true
}' |
apify call khadinakbar/leadfeeder-alternative --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/leadfeeder-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/fyd7Cx8LJzjsc8bNv/builds/cn9EjgS1J8sf6Blv6/openapi.json