# PredictLeads Company Enrichment (`predictleads/predictleads-company-enrichment`) Actor

Fetch real-time company signals from PredictLeads across 10 endpoints including job openings, news events, technology detections, financing events, connections, similar companies, GitHub repositories, products, and website evolution. Supports company-specific lookups.

- **URL**: https://apify.com/predictleads/predictleads-company-enrichment.md
- **Developed by:** [PredictLeads](https://apify.com/predictleads) (community)
- **Categories:** Lead generation, Jobs, News
- **Stats:** 1 total users, 0 monthly users, 100.0% runs succeeded, 1 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## 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

## PredictLeads Company Enrichment

Enrich a list of company domains with real-time signals from the [PredictLeads](https://predictleads.com) API across 10 endpoints — company profiles, job openings, news events, technology detections, financing, connections, similar companies, GitHub repos, products, and website evolution. Configurable concurrency makes large lists fast.

> This actor enriches a **known list** of companies. To **discover** companies by filters (location, size, technology, funding), use the PredictLeads discovery endpoints directly — see the [PredictLeads API docs](https://docs.predictleads.com).

### Quick Start

1. **Set credentials** — enter your PredictLeads API Key and API Token.
2. **Add companies** — paste the domains or PredictLeads company IDs to enrich.
3. **Pick modules** — select one or more endpoints.
4. **Run** — click Start and find clean, flat records in the dataset.

### Input Reference

| Field | Type | Default | Description |
| --- | --- | --- | --- |
| `apiKey` | string | — | PredictLeads API key (secret). |
| `apiToken` | string | — | PredictLeads API token (secret). |
| `companyInputs` | string\[] | — | Company domains or PredictLeads company IDs to enrich. Required. |
| `selectedModules` | string\[] | — | Endpoint modules to run (see list below). |
| `maxResultsPerCompany` | integer | `100` | Max records per company/module, and your main cost dial (see [API Credits](#api-credits)). `0` = unlimited. |
| `concurrency` | integer | `3` | Domains processed in parallel (1–10). |
| `requestDelayMs` | integer | `300` | Milliseconds between API requests (min 100). |
| `proxy` | object | — | Optional Apify proxy configuration. |

### Available Modules

| Module | Description |
| --- | --- |
| `company` | Base company profile — name, description, location, ticker, parent/subsidiary companies. |
| `job_openings` | Active and historical job postings from a company career pages. |
| `news_events` | Structured and categorized company news events from news sites, PR sites, and company blogs. |
| `technology_detections` | Technologies used by companies from job descriptions, company websites, DNS records, and more. |
| `financing_events` | Funding companies receive derived from news events. |
| `connections` | Customer/vendor, partners, and investor relationships between companies. |
| `similar_companies` | Company lookalikes, ranked and with reason. |
| `website_evolution` | Tracked subpages of a company's website with content in markdown. |
| `github_repositories` | Open-source repos linked to the company. |
| `products` | Products and services offered by the company. |

### Example Input

```json
{
  "apiKey": "your-api-key",
  "apiToken": "your-api-token",
  "companyInputs": ["stripe.com", "shopify.com"],
  "selectedModules": ["company", "job_openings", "news_events", "technology_detections"],
  "maxResultsPerCompany": 100,
  "concurrency": 3
}
```

### Example Output

```json
{
  "module_name": "job_openings",
  "fetched_at": "2026-07-21T12:00:00.000Z",
  "input_identifier": "stripe.com",
  "job_opening_id": "4239672f-ec39-4031-aa72-c93a04446f66",
  "company_domain": "stripe.com",
  "company_name": "Stripe, Inc.",
  "company_ticker": null,
  "title": "Staff Data Engineer",
  "url": "https://stripe.com/jobs/listing/staff-data-engineer",
  "location": "San Francisco, California, United States, Northern America, Americas",
  "seniority": "mid_senior",
  "categories": "engineering, software_development",
  "posted_at": null,
  "first_seen_at": "2026-07-18T10:00:00Z",
  "last_seen_at": "2026-07-19T10:06:54Z",
  "onet_data": { "code": "15-1254.00", "family": "Computer and Mathematical", "occupation_name": "Web Developers" },
  "location_data": [
    { "city": "San Francisco", "state": "California", "country": "United States", "region": "Northern America", "continent": "Americas", "fuzzy_match": false }
  ],
  "raw_extra": {}
}
```

Each record includes `module_name`, `fetched_at`, `input_identifier`, mapped fields, and `raw_extra` for any unmapped PredictLeads attributes.

### Output & Dataset Naming

Every record is written to two places:

- The run's **default dataset** — shown in the Console's **Output** tab and used by standard exports (CSV/JSON/Excel). Records from all selected modules land here together; each carries a `module_name` field so you can tell them apart.
- A **per-module named dataset** for a clean split by type:

```
predictleads-job-openings
predictleads-news-events
predictleads-technology-detections
...
```

### Performance Tips

- **Concurrency**: Set `concurrency` to 5–10 for runs with many domains. Each domain processes modules sequentially to avoid rate limits, but multiple domains run in parallel.
- **Request delay**: The default 300ms is conservative. If you have a high-quota plan, try 100–200ms.
- **Max results**: Set a lower `maxResultsPerCompany` (e.g. 25) for initial exploration, then increase for production.
- **Timeout**: Individual domains time out after 5 minutes. The actor gracefully shuts down 60 seconds before the Apify actor timeout.

### API Credits

This actor calls the PredictLeads API with **your** credentials, so runs consume **your PredictLeads API credits** (Apify platform usage is billed separately). The actor is built to spend as few as possible by requesting exactly what you ask for in a single page where it can.

**How billing works:**

- **Most endpoints** — job openings, news events, technology detections, financing events, connections, website evolution, GitHub repositories, products, and the company profile — are billed **1 credit per API request (page)**. The actor sets the page size to your `maxResultsPerCompany` (page size max **1000**), so requesting up to 1000 records costs **1 credit** per company per module. Asking for more (or `0` for unlimited) pages again — roughly 1 extra credit per additional 1000 records.
- **Similar Companies** is billed differently: **1 credit per lookalike company returned** (not per page). Requesting 10 similar companies costs **10 credits**. The endpoint returns at most **50** (default 20).

**Estimating a run** (credits ≈ per company × number of companies × selected modules):

| Module | Credits per company |
| --- | --- |
| Company profile & the other 8 normal endpoints | ~1 per module (≈ `ceil(records ÷ 1000)`) |
| Similar Companies | 1 per company returned (e.g. `maxResultsPerCompany = 10` → 10) |

*Example:* 100 domains, running `job_openings` (≤1000 each) + `similar_companies` (10 each) ≈ **100** credits for job openings + **1,000** credits for similar companies ≈ **1,100 credits**. Lower `maxResultsPerCompany` — especially for Similar Companies — to spend less.

### Rate Limits and Quota

PredictLeads enforces per-account API quotas and rate limits. The actor retries 429 responses using `Retry-After` headers and retries transient 5xx errors with exponential backoff. Monitor your PredictLeads dashboard for remaining quota.

### Run Summary

After every run, the actor saves a machine-readable `RUN_SUMMARY` to the default key-value store with total records, errors, skipped modules, duration, and per-module/per-domain breakdowns. Access it via the Apify API or console.

### FAQ

**Can I run only one module?**
Yes. Select a single module and one or more company domains.

**What happens if a company is not found?**
The actor logs a warning, marks it as skipped, and continues with the next module or domain.

**Why is `raw_extra` included?**
PredictLeads may return additional attributes beyond the mapped schema. `raw_extra` preserves them without breaking the stable output format.

**Can I use PredictLeads company IDs instead of domains?**
Yes. `companyInputs` accepts both domains and PredictLeads company identifiers.

**What if I paste a full URL like `https://www.stripe.com/`?**
The actor automatically cleans it to `stripe.com`.

**Does the actor stop if one module or domain fails?**
No. Errors are logged per-module and summarized at the end while the run continues.

### Links

- [PredictLeads API Documentation](https://predictleads.com/api/v3/docs)
- [Apify Actor Documentation](https://docs.apify.com/actors)

### Changelog

#### 3.0.0

- Added `company` module (base company profile — descriptions, location, ticker, parent/subsidiary/similar companies).
- Credit-efficient paging: the API page size (`limit`) now follows `maxResultsPerCompany` (capped at 1000, or 50 for Similar Companies), so small fetches complete in one request instead of many — fewer PredictLeads credits and less API load. See the new [API Credits](#api-credits) section.
- Removed discovery modes; this actor is now focused solely on enriching a known list of companies. For company discovery, use the PredictLeads discovery endpoints directly (see the [API docs](https://docs.predictleads.com)).
- List fields (`tags`, `categories`, `contract_types`, …) are now comma-joined strings for clean single CSV columns.
- Added an output-schema view so exports lead with the most useful columns instead of alphabetical order.
- Records are written to both the default dataset (Console Output tab / exports) and per-module named datasets.

#### 2.0.0

- Added configurable concurrency for parallel domain processing (3–10x faster).
- Added input sanitization (URL cleaning, whitespace trimming, lowercasing).
- Added deduplication of records across pages.
- Added per-domain timeout (5 minutes) and graceful shutdown on SIGTERM/actor timeout.
- Added machine-readable `RUN_SUMMARY` to key-value store.
- Added structured logging with timing, progress percentage, and summary table.
- Added `concurrency`, `requestDelayMs`, and `proxy` input fields.
- Added connection pooling with keep-alive for reduced latency.
- Added smart pagination (stops early when the reported `count` is reached).
- Added `QuotaExhaustedError` (402) handling.
- Added human-readable module labels and grouped sections in input UI.
- Improved null safety: unmapped fields return `null` instead of `undefined`.
- Refactored to module registry pattern, centralized constants, and typed error hierarchy.

#### 1.0.0

- Initial release with 17 PredictLeads endpoints, company and discovery modes.

# Actor input Schema

## `apiKey` (type: `string`):

Your PredictLeads API key. Find it in your PredictLeads account under API settings.

## `apiToken` (type: `string`):

Your PredictLeads API token. Found alongside the API key in your account settings.

## `companyInputs` (type: `array`):

List of company domains (e.g. stripe.com) or PredictLeads company IDs to fetch data for. URLs like https://www.stripe.com/ are automatically cleaned to stripe.com.

## `selectedModules` (type: `array`):

PredictLeads endpoints to fetch for each company.

## `maxResultsPerCompany` (type: `integer`):

Maximum records to fetch per company/module, and your main cost dial. Most endpoints are billed 1 API credit per page (up to 1000 records), so a value of 1000 or less costs 1 credit per company/module. Similar Companies is billed 1 credit per company returned (max 50). Set to 0 for unlimited.

## `concurrency` (type: `integer`):

Number of company domains to process in parallel. Higher values speed up large runs but use more API quota. Each domain still processes its modules sequentially.

## `requestDelayMs` (type: `integer`):

Milliseconds to wait between API requests. Lower values are faster but increase risk of rate limiting. Minimum 100ms.

## `proxy` (type: `object`):

Optional Apify proxy configuration. Enable if you want requests routed through Apify's proxy infrastructure.

## Actor input object example

```json
{
  "apiKey": "bovu41-spqr3gq4qfhed",
  "apiToken": "QU3z8zYChur6_rPK-8Hs",
  "companyInputs": [
    "stripe.com",
    "shopify.com",
    "twilio.com"
  ],
  "selectedModules": [
    "company",
    "job_openings",
    "news_events"
  ],
  "maxResultsPerCompany": 50,
  "concurrency": 5,
  "requestDelayMs": 200
}
```

# Actor output Schema

## `enrichedRecords` (type: `string`):

All enriched records across the selected modules, ordered for readable export (Overview view). Each row carries a module\_name field identifying its endpoint.

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

Machine-readable RUN\_SUMMARY: total records, errors, skipped modules, duration, and per-module/per-domain breakdowns.

# 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("predictleads/predictleads-company-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("predictleads/predictleads-company-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 predictleads/predictleads-company-enrichment --silent --output-dataset

```

## MCP server setup

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