# Company Intelligence: Competitors, AI Traffic & People (`riccee/company-intelligence-profiler`) Actor

Turn a list of company domains into one profile for each row. Each profile carries competitors, AI referral traffic, a popularity rank, firmographics and technographics. You can add the named leaders as an opt-in. The actor charges nothing for an empty result.

- **URL**: https://apify.com/riccee/company-intelligence-profiler.md
- **Developed by:** [Joseph Schady](https://apify.com/riccee) (community)
- **Categories:**
- **Stats:** 2 total users, 1 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 domains

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

### What does Company Intelligence do?

Company Intelligence turns a list of company domains into one structured profile for each row.
It reads six open public sources over plain HTTP and writes one dataset row for every domain you
send.

Each profile carries a competitor list, a global popularity rank and the traffic that AI
assistants refer. It also carries firmographics, domain registration and technographics. The
named leaders are an opt-in. The actor uses no browser, no proxy, no login and no API key.

Start it from the Console, or call it from the Apify API. Both return the same dataset.

### Why use Company Intelligence?

- **Competitors with numbers, not names.** Every competitor row carries a similarity score,
  monthly visits, a category and a top-country rank.
- **AI referral traffic.** The profile reports the visits that AI assistants sent, the share of
  all referrals they account for, and the engine split.
- **One row for every input row, in your order.** You join the output back on the string you
  sent. Six spellings of one domain give you six rows, and the actor charges the domain once.
- **No charge for an empty result.** The actor charges for a distinct domain that returns real
  data. A domain that returns none costs nothing.
- **Honest nulls.** A source that answers with a challenge, a rate limit or an empty page fills
  no field. The profile records the outcome and leaves the value `null`.

### What data can Company Intelligence extract?

| Field | Type | Description |
| --- | --- | --- |
| `inputDomain` | string | The raw string you sent. Join on this field. |
| `domain` | string | The normalised domain the actor fetched. |
| `duplicateOf` | string or null | The first input row that normalises to the same domain. |
| `status` | string | `ok`, `no_data`, `invalid_input` or `not_attempted`. |
| `tier` | string | The coverage tier for this row: `FULL`, `CORE`, `THIN` or `EMPTY`. |
| `site` | object | The site record: title, meta description, category, category rank, monthly visits, tags and the linked mobile apps. |
| `competitors` | array | Up to 20 similar sites. Each row holds a domain, a similarity score, a similarity rank, monthly visits, a category and a top-country rank. |
| `aiReferral` | object | The referred visits, the share of all referral visits, the ranked engines, the top-3 engine shares and 3 months of history. |
| `popularity` | object | The global Tranco rank, the rank date, and the 30-day trend when the trend is available. |
| `firmographics` | object | The company name, the description, the industries, the founding year, the employee band floor, the revenue band floor and the head-office location. |
| `categories` | array | Every category value with the vocabulary it belongs to. The actor never merges two vocabularies. |
| `registration` | object | The registrar, the registration date, the expiry date, the statuses, the nameservers and the DNSSEC flag, from RDAP. |
| `technographics` | object | The mail provider, the DNS provider, the MX hosts, the SPF record, the DMARC policy and the vendor verification tokens. |
| `employees` | object or null | The named leaders and their roles. This block is off by default. |
| `provenance` | object | The source, the fetch time, the definition and the confidence for every value the actor filled. |
| `sourceOutcomes` | array | The typed result for every source the run attempted, for this row. |
| `billing` | object | Holds 2 flags: `billable` for the profile event, and `employeesCharged` for the employees add-on. |

The actor does **not** return keyword data, paid-search data or a traffic-source split. Version 1
excludes that source.

### How to scrape company data

1. Open the Input tab.
2. Paste your company domains into **Company domains**, one for each line.
3. Turn on **Include employees** if you want the named leaders. Read the personal-data notes below
   first.
4. Click **Start**.
5. Open the Output tab and read the dataset, or download it as JSON, CSV, Excel or HTML.

You can paste `stripe.com`, `www.stripe.com`, `STRIPE.COM` or `https://stripe.com/pricing`. The
actor normalises every entry before the first request. This matters: three of the sources answer
an un-normalised domain with an empty page and no error.

### How much will it cost to run Company Intelligence?

The actor charges 2 pay-per-event events. The table gives the price for each one.

| Event | Price | The actor charges it when |
| --- | --- | --- |
| The company profile | $5.00 for each 1,000 domains | The distinct domain returns real profile data. |
| The employees add-on | $4.00 for each 1,000 domains | Include employees is on, and the org chart returns named people. |

The 2 events are independent. A domain that returns a profile and people costs both prices. A
domain that returns people and no profile costs the add-on price alone.

- A domain that returns no data costs nothing.
- A repeat spelling of a domain you already sent costs nothing.
- A malformed input costs nothing and sends no request.
- The add-on costs nothing while **Include employees** is off.

Apify bills the platform usage on top, from your plan.

You can set a maximum total charge for the run. The limit covers both events together. The actor
stops charging before it reaches that limit, writes `not_attempted` for every remaining row, and
ends the run normally. **Caution:** if you set no limit for the run, the actor applies no cap of
its own. The run summary reports `capConfigured: false` when this happens.

### Input

The Input tab holds four fields.

| Field | Type | Default | What it does |
| --- | --- | --- | --- |
| `domains` | array of strings | required | The company domains to profile. |
| `includeEmployees` | boolean | `false` | Add the named leaders and their roles. It charges the add-on price. |
| `stripEmployeeNames` | boolean | `false` | Remove the name, the person slug and the profile image from the employees block. |
| `mode` | string | `profile` | `profile` returns one profile for each domain. `wire-proof` sends one request to every host, writes the result table, and stops. |

### Output

The run writes one row for every input row to the default dataset, in the order you sent them.
Download the dataset as JSON, CSV, Excel or HTML from the Output tab, or read it from the API.

The dataset carries six views: **Overview**, **Competitors**, **AI traffic**, **Registration and
technographics**, **Employees** and **Diagnostics**. The Overview view holds no billing column.
Read the Diagnostics view for the billing decision, or read the `billing` block in the row itself.

A shortened profile row looks like this:

```json
{
  "inputDomain": "www.Stripe.com",
  "domain": "stripe.com",
  "status": "ok",
  "tier": "FULL",
  "site": { "category": "Finance", "categoryRank": 21, "monthlyVisits": 89824847 },
  "competitors": [
    { "domain": "paypal.com", "similarityRank": 1, "similarityScore": 0.4342 }
  ],
  "popularity": { "rank": 238, "rankDate": "2026-08-26", "trend30d": 2 },
  "firmographics": { "name": "Stripe", "hqCity": "San Francisco", "wikidataQid": "Q7624104" },
  "billing": { "billable": true, "employeesCharged": true }
}
```

A row that returns nothing looks like this:

```json
{
  "inputDomain": "zzzqqxfoobarbaz-notreal.io",
  "domain": "zzzqqxfoobarbaz-notreal.io",
  "status": "no_data",
  "reason": "unknown_domain",
  "tier": "EMPTY",
  "billing": { "billable": false, "employeesCharged": false }
}
```

### Tips

- Send bare hostnames when you can. The actor normalises the rest, and a clean list is easier to
  join.
- Read the `billing` block to see which events the actor charged for each row.
- Read the `sourceOutcomes` array when a block is `null`. It names the source and the outcome.
- Read `provenance` to see which source filled a value and when it fetched the value.
- Run the actor in `wire-proof` mode when a whole block goes empty. The mode sends one request to
  every host and reports what each one answered.

### Coverage

These figures come from a 2026-08-26 probe of 52 real domains across the US, the EU, LATAM and
APAC. The list was hand-built to span company size and geography. A customer list holds more long
tail than this sample, so your own fill rate can be lower.

| Block | Fill on the tested domains |
| --- | --- |
| Competitor list | 51 of 52 |
| Global rank | 52 of 52 |
| AI referral split | 48 of 52 |
| Company name | 39 of 52 |
| Linked mobile apps | 38 of 52 |
| Wikidata company entity | 37 of 52 |
| Site tags | 16 of 52 |

Every figure above assumes a normalised domain, which the actor does for you.

The 30-day rank trend has partial coverage. The actor reads the rank for a large list from a bulk
file. That file carries no history, so `popularity.trend30d` is often `null`. The `trendReason`
field says why.

### FAQ, disclaimers and support

#### Which sources does the actor read?

Six open sources answer for the blocks below.

| Block | Source |
| --- | --- |
| `site`, `competitors` | A website-similarity directory. |
| `aiReferral`, part of `firmographics` | An AI-traffic page. |
| `popularity` | The Tranco list. |
| `firmographics`, `categories` | Wikidata. |
| `registration`, `technographics` | RDAP and public DNS. |
| `employees` | A public org chart. |

The actor names the source and the fetch time for every value it fills, in the `provenance`
block.

#### Why is a block `null`?

A source answered with a challenge, a rate limit, an empty page, or nothing about your domain. The
actor never invents a value. Read `sourceOutcomes` for the typed reason.

#### Why does the AI figure look small next to the site visits?

The two numbers count different things. `site.monthlyVisits` estimates every visit to the site.
`aiReferral.aiReferredVisits` counts only the visits an AI assistant referred in the snapshot
month. Never sum them and never compare them.

#### Personal data

**Warning:** if you turn on **Include employees**, the output contains the names of real people,
their roles and links to their public profiles. You are the controller of that data. Establish your
own lawful basis before you run the actor with the option on, and delete the output when your basis
ends.

- The employees block is **off by default**. When it is off, the actor sends no request to the org
  chart host and it charges no add-on.
- Turn on **Strip employee names** to keep the roles and the counts without the identifiers. The
  actor then omits the full name, the person slug and the profile image.
- A role alone can still identify a person at a small company. The strip does not cover that case.
- The actor reads only pages that are already public. It holds no data between runs and stores
  nothing outside your dataset.
- Send a data-subject request to the source that publishes the profile. This actor keeps no copy.

#### Other disclaimers

- The actor reports what each source published. It never corrects a source's own data defect,
  because a silent correction is harder to audit than a wrong value.
- A domain registration date is not a founding year. The profile keeps the two apart.
- A vendor verification token proves that the company has used the vendor. It does not prove that
  the company pays for the vendor now.
- The employee band floor and the revenue band floor have no ceiling. The real figure can be much
  higher.

#### Support

Open the Issues tab on this actor to report a defect or to ask for a field. Include the run id and
the input domain. Read the API tab to call the actor from your own code.

# Actor input Schema

## `domains` (type: `array`):

The company domains to profile. Paste `stripe.com`, `www.stripe.com`, `STRIPE.COM` or `https://stripe.com/pricing`. The actor cleans every entry before the first request. You get one row for every entry, in the order you sent them. The actor charges once for each distinct domain that returns real data, and nothing for a domain that returns none.

## `includeEmployees` (type: `boolean`):

Add the named leaders and their roles from `theorg.com`. The actor charges the employees add-on for each domain that returns people. **Warning:** if you turn this on, the output contains the names of real people. Read the personal-data notes on the actor page first.

## `stripEmployeeNames` (type: `boolean`):

Remove the identifiers from the employees block. The actor omits the full name, the person slug and the profile image. The actor keeps the role, the section and the counts. This switch does nothing while Include employees is off.

## `mode` (type: `string`):

The run mode. The `profile` mode returns one company profile for each domain. The `wire-proof` mode sends one request to every host, writes the result table to the run summary, and stops. Use `wire-proof` when a whole block comes back empty.

## Actor input object example

```json
{
  "domains": [
    "stripe.com",
    "notion.so",
    "danluu.com"
  ],
  "includeEmployees": false,
  "stripEmployeeNames": false,
  "mode": "profile"
}
```

# Actor output Schema

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

One profile for every input row, in the order you sent them.

# 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 = {
    "domains": [
        "stripe.com",
        "notion.so",
        "danluu.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("riccee/company-intelligence-profiler").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 = { "domains": [
        "stripe.com",
        "notion.so",
        "danluu.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("riccee/company-intelligence-profiler").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 '{
  "domains": [
    "stripe.com",
    "notion.so",
    "danluu.com"
  ]
}' |
apify call riccee/company-intelligence-profiler --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,riccee/company-intelligence-profiler"
        }
    }
}

```

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/9mfgZq860H5tYQzL0/builds/oZEgWvD02mI2BLxPR/openapi.json