# Company Enrichment API — Domain to Company Name, Logo & Socials (`highbrow_fame/company-enrichment-api`) Actor

Company name, legal name, logo, founding year, HQ, socials, generic mailboxes, phone and tech hints from a domain's own site and schema.org markup. No people data. Unofficial Company Enrichment API.

- **URL**: https://apify.com/highbrow_fame/company-enrichment-api.md
- **Developed by:** [yestrue](https://apify.com/highbrow_fame) (community)
- **Categories:** Business, Developer tools, AI
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

$2.00 / 1,000 companies

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?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

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

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## Company Enrichment API — Domain to Company Name, Logo & Socials

Turn a list of domains into clean company records: name and legal name, description, logo, founding year, headquarters address, the company's pages on LinkedIn, X/Twitter, Facebook, Instagram, YouTube, GitHub, TikTok and Crunchbase, generic mailboxes (info@, sales@…), the business phone line, the contact/about/careers pages and tech-stack hints — all read from the company's own website and its schema.org markup. No people data: person profiles and personal addresses are left out by design.

**Try it in 1 minute:**

1. Press **Start** — the prefilled input enriches apify.com, mozilla.org and stripe.com.
2. A few seconds later the **Output** tab shows one record per domain with name, logo, socials, HQ and tech hints.
3. Download JSON, CSV or Excel, or call the Actor from your CRM, spreadsheet or AI agent.

Price: **$2.00 per 1,000 companies**. Domains that do not resolve, answer 404, or whose robots.txt disallows reading are free.

**Use it to:**

- Enrich sign-ups and leads by their e-mail domain: company name, logo, HQ and socials next to every row in your CRM.
- Build a company directory or a prospect list from a list of websites, with the LinkedIn, X and Crunchbase pages already found.
- Give an AI agent structured facts about a company instead of a raw homepage.
- Spot the tech stack (WordPress, Shopify, HubSpot, Next.js, Cloudflare…) of hundreds of sites for segmentation or sales triggers.
- Check which domains carry schema.org Organization markup, a legal name, an address or a founding date — and which do not.

### How it works

1. Each input is normalised to a domain (www. removed, paths dropped). A single-word company name ("Apify", "Stripe, Inc.") is turned into `<word>.com`; multi-word names are not guessed and come back as a free NOT_FOUND record with a hint.
2. The site's robots.txt is read (and honoured by default), then the homepage over https — http when https does not answer — following redirects.
3. The page is parsed: schema.org JSON-LD (Organization, Corporation, LocalBusiness and their subtypes, also inside `@graph`), Open Graph and meta tags, the title tag, the site icon, every link on the page and the response headers.
4. When the homepage has no address, phone or generic mailbox, the contact page on the same host is read as well (one extra request) and fills those gaps.
5. The result is one flat record per domain. Rate limits and network hiccups are retried (the first request goes out directly, retries through the proxy); DNS failures and 404s are free NOT_FOUND records.

What is *not* done: no external registries, no Wikidata lookups (the `wikidataId` is filled only when the site's own `sameAs` links to Wikidata), no employee counts beyond what the site's schema.org markup states, no team pages, no person names, no personal e-mail addresses. Descriptions are scrubbed of phone numbers and e-mail addresses.

### Input

| Field | What it does |
|---|---|
| `domains` | Company websites, one per line: bare domain, with www, or a full address. One record per domain. |
| `names` | Optional. Single-word company names are turned into a domain the simple way; others come back as NOT_FOUND with a hint. |
| `fetchContactPage` | Read the contact page when the homepage has no address, phone or mailbox (default on). |
| `respectRobotsTxt` | Skip sites whose robots.txt disallows the homepage (default on; free ROBOTS_DISALLOWED record). |
| `maxConcurrency` | Parallel domains (default 5, up to 20). |
| `proxyConfiguration` | Used only for retries after a network error or rate limit; first requests are direct. |

### Output

One record per domain:

| Field | What it is |
|---|---|
| `domain`, `finalUrl`, `httpStatus`, `canonicalUrl`, `titleTag`, `language` | What was read and how the site answered |
| `name`, `legalName`, `description` | Company name (schema.org → og:site_name → title tag), legal name and description (scrubbed of contact details) |
| `logo`, `favicon` | Absolute image URLs: schema.org logo, else the site icon, else og:image |
| `industry`, `employeeRange`, `foundingYear`, `foundingDate`, `hq` | Only from the site's own markup: schema.org business type or keywords meta, numberOfEmployees, foundingDate, address `{ street, city, region, postalCode, country }` |
| `socials` | `{ facebook, twitter, linkedin, instagram, youtube, github, tiktok, crunchbase }` — company pages only |
| `contactPageUrl`, `aboutPageUrl`, `careersPageUrl` | Section pages the homepage links to |
| `emails`, `phone` | Generic mailboxes only (info@, sales@, press@…) and the schema.org business line |
| `wikidataId` | Q-id when the site's sameAs links to Wikidata |
| `techHints[]` | Marks of WordPress, Shopify, Webflow, Wix, Squarespace, HubSpot, Google Tag Manager, Google Analytics, Cloudflare, Next.js, Nuxt, React, Intercom, Segment, Stripe, Drift, Zendesk |
| `hasOrganizationMarkup`, `contactPageFetched` | Whether schema.org markup was found and whether the contact page was read |
| `input`, `status`, `error`, `scrapedAt` | What you gave, and why a domain gave no record |

#### Example

```json
{
  "input": "acme-robotics.example",
  "domain": "acme-robotics.example",
  "finalUrl": "https://www.acme-robotics.example/",
  "httpStatus": 200,
  "name": "Acme Robotics",
  "legalName": "Acme Robotics, Inc.",
  "description": "Acme Robotics builds pick-and-place robots for small factories.",
  "logo": "https://www.acme-robotics.example/static/img/acme-logo.svg",
  "favicon": "https://www.acme-robotics.example/favicon.ico",
  "industry": "industrial automation",
  "employeeRange": "50-200",
  "foundingYear": 2015,
  "foundingDate": "2015-03-01",
  "hq": { "street": "100 Market Street, Suite 300", "city": "San Francisco", "region": "CA", "postalCode": "94105", "country": "US" },
  "socials": {
    "facebook": "https://www.facebook.com/AcmeRobotics",
    "twitter": "https://twitter.com/acmerobotics",
    "linkedin": "https://www.linkedin.com/company/acme-robotics",
    "instagram": "https://www.instagram.com/acmerobotics",
    "youtube": "https://www.youtube.com/@acmerobotics",
    "github": "https://github.com/acme-robotics",
    "tiktok": null,
    "crunchbase": "https://www.crunchbase.com/organization/acme-robotics"
  },
  "contactPageUrl": "https://www.acme-robotics.example/contact/",
  "aboutPageUrl": "https://www.acme-robotics.example/about/",
  "careersPageUrl": "https://jobs.lever.co/acme-robotics",
  "emails": ["info@acme-robotics.example", "sales@acme-robotics.example"],
  "phone": "+1-415-555-0100",
  "wikidataId": "Q99999999",
  "techHints": ["WordPress", "Google Tag Manager", "Google Analytics", "Cloudflare", "Stripe"],
  "language": "en-us",
  "titleTag": "Acme Robotics | Industrial automation that just works",
  "canonicalUrl": "https://www.acme-robotics.example/",
  "hasOrganizationMarkup": true,
  "contactPageFetched": false,
  "status": "OK",
  "scrapedAt": "2026-10-19T12:00:00.000Z"
}
```

### FAQ

**Is this an official API?** No, it's an unofficial API built on public pages — each company's own website and the schema.org markup it publishes. Nothing is looked up in third-party databases.

**Why are some fields null?** Because the site does not state them. `legalName`, `foundingYear`, `hq`, `employeeRange` and `phone` come only from schema.org markup; `industry` only from a specific schema.org business type or the keywords meta tag. The Actor never guesses — `hasOrganizationMarkup` tells you whether the site had markup at all.

**Does it return people, personal e-mails or phone numbers?** No. Person profiles (linkedin.com/in/…), personal mailboxes (jane.doe@…) and team pages are skipped; only generic mailboxes from a fixed list (info@, hello@, contact@, support@, sales@, press@, team@, office@…) and the schema.org business line are kept, and descriptions are scrubbed of phone numbers and e-mail addresses.

**Can I pass company names instead of domains?** Single-word names, yes: "Apify" is tried as apify.com, "Stripe, Inc." as stripe.com. Multi-word names are not guessed (a wrong guess would enrich the wrong company) and come back as a free NOT_FOUND record asking for the domain.

**Does it respect robots.txt?** Yes, by default: a site whose robots.txt disallows the homepage gives a free ROBOTS_DISALLOWED record. Pages behind a bot wall or a login are not circumvented.

**Like it?** A short review on the Store page helps other people find this Actor. Something missing or broken? Tell us on the Issues tab — we read every one.

### Related Actors

- [Website Tech Stack Detector](https://apify.com/highbrow_fame/website-tech-stack) — CMS, frameworks and analytics of any site
- [Google Maps Email Extractor](https://apify.com/highbrow_fame/google-maps-email-extractor) — local businesses with their e-mail addresses
- [Sitemap Extractor](https://apify.com/highbrow_fame/sitemap-url-extractor) — every URL, date and image from a site's sitemaps
- [Domain Checker](https://apify.com/highbrow_fame/domain-whois-dns-ssl) — WHOIS, DNS and SSL expiry in bulk
- [Article Extractor API](https://apify.com/highbrow_fame/article-extractor-api) — title, author, date and full text of any article

# Actor input Schema

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

Company websites, one per line: a bare domain (apify.com), with www, or a full address (https://www.mozilla.org/en-US/) — the homepage is read either way. One record per domain.

## `names` (type: `array`):

Optional. Single-word company names are turned into a domain the simple way ("Apify" → apify.com, "Stripe, Inc." → stripe.com) and enriched like a domain. Multi-word names are not guessed: they come back as a free NOT_FOUND record with a hint — pass the domain instead.

## `fetchContactPage` (type: `boolean`):

When the homepage has no address, phone or generic mailbox, also read the site's contact page (same host, one extra request) and take them from its schema.org markup and mailto: links.

## `respectRobotsTxt` (type: `boolean`):

Skip sites whose robots.txt disallows reading the homepage (a free ROBOTS_DISALLOWED record). Keep it on unless you are sure you may read the site.

## `maxConcurrency` (type: `integer`):

How many domains to read at the same time. Each domain is at most three small requests (robots.txt, homepage, contact page).

## `proxyConfiguration` (type: `object`):

Used only to try again after a network error or a rate limit: the first request to every site goes out directly.

## Actor input object example

```json
{
  "domains": [
    "apify.com",
    "https://www.mozilla.org",
    "stripe.com"
  ],
  "fetchContactPage": true,
  "respectRobotsTxt": true,
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

Every result as a JSON record, with a status for each input.

## `resultsCsv` (type: `string`):

The same records as CSV, for a spreadsheet.

# 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": [
        "apify.com",
        "https://www.mozilla.org",
        "stripe.com"
    ],
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("highbrow_fame/company-enrichment-api").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": [
        "apify.com",
        "https://www.mozilla.org",
        "stripe.com",
    ],
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("highbrow_fame/company-enrichment-api").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": [
    "apify.com",
    "https://www.mozilla.org",
    "stripe.com"
  ],
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call highbrow_fame/company-enrichment-api --silent --output-dataset

```

## MCP server setup

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

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/HymtIHVlMb3wpgFvE/builds/me1nmagP1ycwfNrde/openapi.json