# Company Enrichment - What a Website Actually Sells (`salomon.labs/company-enrichment-scraper`) Actor

Give it a company website and get what that company sells - product categories, brand and product names, whether there is a checkout and on which platform - each fact with the page it came from.

- **URL**: https://apify.com/salomon.labs/company-enrichment-scraper.md
- **Developed by:** [Alan Salomon](https://apify.com/salomon.labs) (community)
- **Categories:** Lead generation, E-commerce, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 company profiles

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

## Company Enrichment — what a website actually sells

Give it a company website. Get back **what that company sells** — product
categories, brand and product names, whether there is a checkout and on which
platform — with **the page every fact came from**.

Most enrichment tells you a company's size, revenue band and tech stack. That is
useful for routing a lead and useless for the question people actually ask before
they spend money: *what do these people do, and is it what I do?*

***

### What you get, per website

| Field | What it is |
|---|---|
| `company_name` | The name, preferring what the site declares in schema.org over what we read off its `<title>` |
| `description` | How the company describes itself, in its own words |
| `sells` | Product categories and service lines, read from the navigation and from structured data |
| `product_examples` | Real product names, where the site publishes them |
| `brands` | Brands the site declares it carries or owns |
| `sells_online` | Whether there is a checkout — with the evidence beside it |
| `ecommerce_platform` | Shopify, WooCommerce, Squarespace, Wix, BigCommerce, PrestaShop, Magento, Shopware, Ecwid |
| `currencies` | What it prices in, when it says so |
| `social_links` | The profiles it links to |
| `hosted_on` | Set when the URL is a profile on a shared platform - GitHub, Linktree, Etsy - because a profile page is not a company website |
| `*_evidence` | For each of the above: the page it came from, and how it was known |

### Every fact says where it came from

`company_name_evidence` reads *"schema.org Organization on https://example.com/"*
or *"page title on https://example.com/"* — and those are not the same claim. One
is the company asserting a fact about itself. The other is us cutting a string in
half at a dash.

You can sort on that. Most enrichment hands you a value and asks you to trust it.

### We read markup, never prose

Every answer comes from a machine marker: a schema.org block, a `<meta>` tag, a
CDN host, a navigation link. Never from a sentence.

That sounds pedantic until you meet the failure it prevents. A blog post reading
*"we left Shopify last year and add to cart was always slow"* will be reported by
a naive detector as a Shopify store with a checkout. It is neither. There is a
test suite here made of ordinary English that is asserted to produce **nothing**.

### What it does not do

- **It does not render JavaScript.** A shop that draws its catalogue client-side
  gives up `sells_online`, its platform and its evidence — and no product names.
  You get an honest empty `sells` rather than a guess assembled from headings.
- **It does not judge.** No fit score, no category verdict, no "is this a
  competitor". You get the facts and the pages they came from; the judgement is
  yours, and it belongs to somebody who knows their own market.
- **It does not mistake a platform for a company.** Point it at a GitHub
  profile or a Linktree and you get `hosted_on: GitHub`, not that company's
  marketing menu reported as what this person sells. A storefront address - Etsy,
  Gumroad, Ko-fi - is instead taken as evidence that they *are* selling.
- **It reads what is published.** A company that says nothing about itself on its
  own website comes back mostly empty, and says so.

### Input

```json
{
  "websites": ["allbirds.com", "https://www.mate-verde.de/"],
  "pageLimit": 3
}
```

Paste domains or full URLs — `acme.com`, `www.acme.com` and
`https://acme.com/about` are one company and one charge.

Already have a list somewhere else? Point it at another Actor's dataset:

```json
{ "inputDatasetId": "aBcD1234", "websiteField": "website" }
```

Every row's website gets profiled, so this slots into a pipeline behind a Maps
scraper, a lead list or a creator search instead of being pasted into by hand.

**`pageLimit` is your cost dial.** The homepage says who a company is; the shop,
catalogue or services page says what they sell. Three further pages is usually
enough. Pages within one site are fetched one at a time — hammering a small
business's shared hosting to save two seconds is how a scraper earns a block.

### Output

One row per website, every row carrying every column — including the ones that
failed, which arrive with a reason rather than disappearing. A site we could not
read is our problem and is never charged for.

Two views: **What they sell** for the answers, **Evidence** for where each came
from.

# Actor input Schema

## `websites` (type: `array`):

Company websites to read. Paste domains or full URLs - acme.com, www.acme.com and https://acme.com are all accepted and count as one company. Leave empty to run a short sample.

## `inputDatasetId` (type: `string`):

The dataset ID of an earlier run - a lead list, a Maps scrape, a creator search. Every row's website is profiled, so this Actor slots into a pipeline instead of being pasted into by hand.

## `websiteField` (type: `string`):

Which field of that dataset holds the website. Only needed if the automatic detection (website, url, domain, companyWebsite) picks the wrong one.

## `pageLimit` (type: `integer`):

How many further pages to open per site. A homepage says who a company is; the shop, catalogue or services page says what they sell. Three is usually enough, and every extra page costs compute.

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

How many different sites to read in parallel. Pages within one site are always fetched one at a time, because hammering a small business's shared hosting is how a scraper earns a block.

## Actor input object example

```json
{
  "websites": [
    "acme.com",
    "https://mate-verde.de/"
  ],
  "pageLimit": 3,
  "concurrency": 4
}
```

# Actor output Schema

## `profiles` (type: `string`):

One row per website: the company, what it sells, whether it has a checkout, and on which platform.

## `evidence` (type: `string`):

The page each fact came from and how it was known - declared in schema.org, taken from a meta tag, or read off a navigation link.

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

Every column, including the run summary row.

# 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 = {
    "websites": [
        "apify.com",
        "allbirds.com"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("salomon.labs/company-enrichment-scraper").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 = { "websites": [
        "apify.com",
        "allbirds.com",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("salomon.labs/company-enrichment-scraper").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 '{
  "websites": [
    "apify.com",
    "allbirds.com"
  ]
}' |
apify call salomon.labs/company-enrichment-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,salomon.labs/company-enrichment-scraper"
        }
    }
}

```

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/UMjjXWTRJ1dLOppHB/builds/eyCb4cnRzBMTFlh3y/openapi.json