# Company Domain & Social Links Finder (`crawlerbros/company-domain`) Actor

Given a company name, return the company's official website domain and its social media links (LinkedIn, X/Twitter, Facebook, Instagram, YouTube, TikTok, GitHub).

- **URL**: https://apify.com/crawlerbros/company-domain.md
- **Developed by:** [Crawler Bros](https://apify.com/crawlerbros) (community)
- **Categories:** Lead generation, Developer tools, Social media
- **Stats:** 6 total users, 5 monthly users, 100.0% runs succeeded, 22 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use 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 Domain & Social Links Finder — Website + Social Handles From a Company Name

Give this actor a list of company names and it returns each company's official website plus its LinkedIn, X/Twitter, Facebook, Instagram, YouTube, TikTok, and GitHub links.

### What this actor does

Supply one or more company names — "OpenAI", "Stripe", "Porsche AG" — and the actor resolves each one to its canonical root domain and social media presence. It works by running a public web search for the official site, picking the most likely corporate result, and then parsing that homepage for outbound links to known social platforms. The result is one flat record per company you asked about.

An optional **country hint** (`"US"`, `"Germany"`, `"Japan"`…) biases the search towards the local version of the company when the name is ambiguous — useful for chains and brands that operate under different domains per region. When the target homepage is protected by an anti-bot wall, the actor's **auto proxy fallback** kicks in automatically: if the first direct HTTP fetch is blocked, the request is retried through a residential proxy session so the social link extraction still succeeds. This happens transparently — you don't need to flip a switch.

The actor is cookie-free, login-free, API-key-free, and LLM-free by design. It is built for bulk use: feed it hundreds of companies and get clean, structured output you can drop straight into a CRM, a lead list, or an enrichment pipeline.

### Key features

- **Company name → official website** resolution via public web search.
- **Flat per-platform columns** — `linkedin`, `twitter`, `facebook`, `instagram`, `youtube`, `tiktok`, `github` — ready for spreadsheets and CRMs.
- **Country hint** for region-specific resolution (useful for multinational brands).
- **Auto proxy fallback** — when a company website blocks datacenter IPs, the actor retries through residential proxy automatically. No manual configuration required.
- **No cookies, no API keys, no LLMs** — just HTTP fetch + HTML parsing.
- **Bulk-friendly** — process long company lists in one run.
- **Clean output** — empty fields are omitted, so you don't post-process `null` values.

### Input

| Field | Type | Description |
|---|---|---|
| `companies` | array | One company name per entry (e.g. `"OpenAI"`, `"Porsche AG"`). |
| `country` | string | Optional country hint, e.g. `"US"`, `"Germany"`, `"Japan"`. Disambiguates multinational brands. |
| `maxSocialLinks` | integer | Cap on extra social links per company (default 10). |
| `autoProxyFallback` | boolean | When true (default), retry via residential proxy if the homepage blocks the direct fetch. |

**Example input**

```json
{
  "companies": ["OpenAI", "Stripe", "Porsche AG"],
  "country": "US",
  "maxSocialLinks": 10,
  "autoProxyFallback": true
}
````

### Output

Each record maps one input company to its web + social footprint:

```json
{
  "companyName": "OpenAI",
  "officialWebsite": "https://openai.com",
  "linkedin": "https://www.linkedin.com/company/openai",
  "twitter": "https://twitter.com/openai",
  "youtube": "https://www.youtube.com/@OpenAI",
  "github": "https://github.com/openai",
  "socialLinks": [
    { "platform": "linkedin", "url": "https://www.linkedin.com/company/openai" },
    { "platform": "twitter", "url": "https://twitter.com/openai" }
  ],
  "searchQuery": "\"OpenAI\" official site",
  "scrapedAt": "2026-04-24T10:15:00+00:00"
}
```

**Field descriptions**

- `companyName` — the company name you provided, echoed back verbatim.
- `officialWebsite` — canonical root URL of the company's primary site.
- `linkedin`, `twitter`, `facebook`, `instagram`, `youtube`, `tiktok`, `github` — flat per-platform columns, each holding the company's profile URL on that platform.
- `socialLinks` — full list of `{platform, url}` objects including any platforms not covered by the flat columns.
- `searchQuery` — the exact query string used to resolve the site (useful for debugging).
- `scrapedAt` — ISO 8601 UTC timestamp of extraction.

Fields that cannot be populated (e.g. a company without a TikTok account) are omitted from the record, so you never have to filter out `null` values downstream.

### Use cases

- **Lead generation & sales enrichment** — take a raw list of company names from a conference attendee sheet or LinkedIn export and enrich each one with its website and handles.
- **CRM hygiene** — fill in missing domain/social fields across thousands of existing CRM accounts.
- **Investor / market research** — map the online presence of an industry's key players in one run.
- **Competitive tracking** — pull every competitor's social handles so you can follow them in a monitoring tool.
- **Recruiting outreach** — resolve target-employer domains so you can find work emails via a downstream pattern checker.

### FAQ

**Do I need a proxy?**
Not usually. The actor runs cookieless and succeeds on most sites direct. When a specific company homepage blocks datacenter IPs, `autoProxyFallback` (on by default) silently retries through a residential session so the run keeps going.

**What happens if a company has no website?**
The record is still emitted with `officialWebsite` omitted and `socialLinks` empty. This makes it easy to filter down to "unresolved" companies for manual follow-up.

**What if my company has multiple legitimate domains (e.g. regional sites)?**
Provide the `country` hint to bias the search. Setting `country: "Germany"` for "Porsche" returns `porsche.de` rather than `porsche.com`.

**Does the actor check that the social links are still active?**
No. It extracts links that appear on the company's homepage. Defunct accounts can still appear if the homepage still references them.

**How accurate is the official-website detection?**
Directory sites (Wikipedia, LinkedIn company pages, Crunchbase, etc.) are filtered out so the top "real" corporate result wins. For extremely generic names ("Apple", "Shell") a country hint improves accuracy significantly.

**Can I pass domains instead of names?**
Use the [Sitemap URL Extractor](https://apify.com/) or a direct crawler if you already have the domain — this actor specifically solves the name → domain step.

**Is this using an AI model?**
No. The actor uses deterministic HTML parsing and a curated list of social platform domains. Costs are predictable and outputs are reproducible.

### Known limitations

- **Ambiguous brand names** ("Apollo", "Fusion", "Nova") may resolve to the wrong company without a `country` hint — always supply one when processing high-risk names.
- **Companies without a homepage** (pre-launch startups, stealth companies) cannot be resolved; you'll get an empty `officialWebsite` and empty `socialLinks`.
- **Aggressive anti-bot walls** on a minority of corporate sites can block both direct and residential fetches; in those cases the social links may be partial.
- **The actor does not verify social handle ownership** — it only extracts links the homepage itself publishes. A homepage that links to a wrong/third-party handle will be echoed faithfully.
- **Language-specific social platforms** (VK, Weibo, Line) are not included in the flat columns but may appear in `socialLinks` if the homepage links them.

# Actor input Schema

## `companies` (type: `array`):

One company name per entry. Each is resolved independently. Examples: 'OpenAI', 'Anthropic', 'Stripe'.

## `country` (type: `string`):

Country name or 2-letter code (e.g., 'US', 'Germany'). Narrows the search when multiple companies share a name across regions.

## `maxSocialLinks` (type: `integer`):

Cap on the number of social links returned per company.

## `autoProxyFallback` (type: `boolean`):

When the initial datacenter-IP fetch of a company site returns an empty / block-page response (common on openai.com, some banks), automatically retry that one URL via Apify residential proxy. Only blocked pages burn proxy credits — most companies respond fine to direct fetches. Leave on for best results; turn off to guarantee zero proxy spend.

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

Force every request through the configured proxy. Prefer `autoProxyFallback` over this — that way most companies use free datacenter fetching and only blocked ones burn residential proxy credits.

## Actor input object example

```json
{
  "companies": [
    "OpenAI",
    "Stripe"
  ],
  "maxSocialLinks": 10,
  "autoProxyFallback": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "companies": [
        "OpenAI",
        "Stripe"
    ],
    "maxSocialLinks": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("crawlerbros/company-domain").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 = {
    "companies": [
        "OpenAI",
        "Stripe",
    ],
    "maxSocialLinks": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("crawlerbros/company-domain").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "companies": [
    "OpenAI",
    "Stripe"
  ],
  "maxSocialLinks": 10
}' |
apify call crawlerbros/company-domain --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=crawlerbros/company-domain",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Company Domain & Social Links Finder",
        "description": "Given a company name, return the company's official website domain and its social media links (LinkedIn, X/Twitter, Facebook, Instagram, YouTube, TikTok, GitHub).",
        "version": "1.0",
        "x-build-id": "vjemT0tbrW5pQO2ei"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/crawlerbros~company-domain/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-crawlerbros-company-domain",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/crawlerbros~company-domain/runs": {
            "post": {
                "operationId": "runs-sync-crawlerbros-company-domain",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/crawlerbros~company-domain/run-sync": {
            "post": {
                "operationId": "run-sync-crawlerbros-company-domain",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "companies": {
                        "title": "Company names (one per line)",
                        "type": "array",
                        "description": "One company name per entry. Each is resolved independently. Examples: 'OpenAI', 'Anthropic', 'Stripe'.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "country": {
                        "title": "Country hint (optional)",
                        "type": "string",
                        "description": "Country name or 2-letter code (e.g., 'US', 'Germany'). Narrows the search when multiple companies share a name across regions."
                    },
                    "maxSocialLinks": {
                        "title": "Max social links per company",
                        "minimum": 1,
                        "maximum": 50,
                        "type": "integer",
                        "description": "Cap on the number of social links returned per company.",
                        "default": 10
                    },
                    "autoProxyFallback": {
                        "title": "Auto-retry via proxy when blocked",
                        "type": "boolean",
                        "description": "When the initial datacenter-IP fetch of a company site returns an empty / block-page response (common on openai.com, some banks), automatically retry that one URL via Apify residential proxy. Only blocked pages burn proxy credits — most companies respond fine to direct fetches. Leave on for best results; turn off to guarantee zero proxy spend.",
                        "default": true
                    },
                    "proxyConfiguration": {
                        "title": "Proxy configuration (use for ALL requests)",
                        "type": "object",
                        "description": "Force every request through the configured proxy. Prefer `autoProxyFallback` over this — that way most companies use free datacenter fetching and only blocked ones burn residential proxy credits.",
                        "default": {
                            "useApifyProxy": false
                        }
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```