# Social Media Profile Finder (LinkedIn, X, Instagram, Facebook) (`subimpact/social-media-profile-finder`) Actor

Find a company's official social media profiles (LinkedIn, X, Facebook, Instagram, YouTube, TikTok, Pinterest, GitHub) from its website links and Google search, with a confidence score per profile. $2.00 per 1,000 profiles found; companies with none are free.

- **URL**: https://apify.com/subimpact/social-media-profile-finder.md
- **Developed by:** [subimpact network](https://apify.com/subimpact) (community)
- **Categories:** Lead generation, Social media, SEO tools
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 social profile founds

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

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

## Social Media Profile Finder

Give this Actor a list of companies — domains, names, or both — and get back their official social
media profiles in one clean row per company: **LinkedIn, X/Twitter, Facebook, Instagram, YouTube,
TikTok, Pinterest and GitHub**.

Two independent signals, both plain HTTP (no browser, no API keys):

1. **The company's own website.** The homepage footer, header and markup are read for profile links:
   plain anchors, JSON-LD `sameAs` and meta tags (`og:see_also`, `article:publisher`,
   `twitter:site`, `<link rel="me">`). Up to two linked contact/about pages are read as well. A profile
   linked from the company's own site is reported with `confidence: "high"`.
2. **One Google search per missing platform** (`site:linkedin.com/company "<name>"`,
   `site:instagram.com "<name>"`, …) through Apify's Google SERP proxy. A search result is
   accepted only when the account handle is the company's own — `canva`, `canvaapp`, `stripehq`,
   `grabmy` — so a post that mentions the company, a generic word-match account or a platform's own
   corporate page is never returned as its profile. These rows carry `confidence: "medium"` and say
   how the URL was found.

You only pay for profiles that are delivered, so a company with no social presence costs nothing.

### What you get

One dataset item per company:

| Field | Meaning |
| --- | --- |
| `input` | the company entry exactly as you supplied it |
| `companyName`, `domain` | the name used for searches and the website host that was read |
| `linkedin`, `twitter`, `facebook`, `instagram`, `youtube`, `tiktok`, `pinterest`, `github` | one canonical profile URL per platform, or `null` |
| `profiles` | every delivered profile as `{platform, url, handle, confidence, foundVia}` |
| `foundCount` | number of profile URLs in the row (this is what you are billed for) |
| `pagesFetched`, `searchesRun` | how much work the row cost: website pages read and Google searches spent |
| `scrapedAt`, `status`, `error` | ISO timestamp, `Found` / `NotFound` / `Error`, and the reason for anything partial |

`confidence` is `high` when the profile is linked from the company's own website and `medium` when it
came from a Google result whose account handle names the company (`canva`, `canvaapp`, `stripehq`). `foundVia` is one of
`website`, `search` (Google exposed the real href), `search-display` (URL rebuilt from the result's
breadcrumb), `search-label` / `search-title` (account name taken from Google's own result label or the
result title).

URLs are canonicalised, so you get the same string every run: `twitter.com` becomes `x.com`,
`instagram.com/handle/?hl=en` becomes `instagram.com/handle`, `linkedin.com/company/x/about/` becomes
`linkedin.com/company/x`. Posts, shares, repos and login pages are never delivered as profiles.

### Input

```json
{
  "companies": [
    "apify.com",
    "stripe.com",
    { "name": "Mailchimp", "domain": "mailchimp.com" },
    "Notion"
  ],
  "platforms": ["linkedin", "twitter", "instagram", "facebook", "youtube", "tiktok", "pinterest", "github"],
  "useSearch": true,
  "maxInputs": 50,
  "maxPagesPerInput": 3
}
```

- **companies** — a domain (`apify.com`), a company name (`Apify`), or an object with both. A name-only
  entry is searched for on Google; a domain-only entry is scraped and searched with the domain label as
  the name.
- **platforms** — one platform name per line (`linkedin`, `twitter`, `facebook`, `instagram`, `youtube`,
  `tiktok`, `pinterest`, `github`), all eight by default. Fewer platforms means fewer searches and a
  cheaper run.
- **useSearch** — `true` (default) runs one Google search per platform the website did not cover. Set
  it to `false` for a website-only run: cheaper, and nothing but the company websites is contacted.
- **maxInputs** — hard cap on delivered rows (default 50, max 5000).
- **maxPagesPerInput** — homepage plus up to two linked contact/about pages (default 3, max 6).
- **proxyConfiguration** — optional. Websites are fetched directly by default; add an Apify Proxy
  configuration (for example residential) when your target sites block datacenter IPs. The Google
  searches always use Apify's `GOOGLE_SERP` proxy group and are unaffected by this setting.

#### Example output (a real row from a live run on 2026-11-15)

```json
{
  "input": "apify.com",
  "companyName": "apify",
  "domain": "apify.com",
  "linkedin": "https://www.linkedin.com/company/apify",
  "twitter": "https://x.com/apify",
  "facebook": null,
  "instagram": null,
  "youtube": null,
  "tiktok": "https://www.tiktok.com/@apifytech",
  "pinterest": null,
  "github": "https://github.com/apify",
  "profiles": [
    {
      "platform": "linkedin",
      "url": "https://www.linkedin.com/company/apify",
      "handle": "apify",
      "confidence": "high",
      "foundVia": "website"
    },
    {
      "platform": "twitter",
      "url": "https://x.com/apify",
      "handle": "apify",
      "confidence": "high",
      "foundVia": "website"
    },
    {
      "platform": "tiktok",
      "url": "https://www.tiktok.com/@apifytech",
      "handle": "apifytech",
      "confidence": "high",
      "foundVia": "website"
    },
    {
      "platform": "github",
      "url": "https://github.com/apify",
      "handle": "apify",
      "confidence": "high",
      "foundVia": "website"
    }
  ],
  "foundCount": 4,
  "pagesFetched": 3,
  "searchesRun": 0,
  "scrapedAt": "2026-11-15T08:27:44.492Z",
  "status": "Found",
  "error": null
}
```

A row where nothing was found costs nothing and explains itself:

```json
{
  "input": "example.com",
  "companyName": "example",
  "domain": "example.com",
  "linkedin": null,
  "foundCount": 0,
  "pagesFetched": 1,
  "searchesRun": 4,
  "status": "NotFound",
  "error": "No social profile found on the company website or in Google results"
}
```

### Tips for better results

- **Give a domain when you have one.** The website is the reliable signal; Google search is the
  fallback. Name-only entries depend on the company ranking in Google for its own name.
- **Use the legal name if the brand name is ambiguous.** `"companies": [{"name": "Acme Rockets", "domain": "acmerockets.com"}]`
  searches for "Acme Rockets" and scrapes acmerockets.com.
- **Turn `useSearch` off** when you already have the domains and want the cheapest possible run — you
  then pay for one to three page fetches per company and nothing else.
- **Check `confidence`.** `high` profiles are the company's own links. `medium` profiles come from a
  Google result and are right most of the time, but for a name that many accounts share, look at
  `foundVia` before you trust it.
- LinkedIn is returned as a company page (`/company/<slug>`); personal `/in/<slug>` profiles are
  reported only when a site links one as its social profile.

### Pricing

**$2.00 per 1,000 profiles found** on the Free plan, $1.80 Bronze, $1.60 Silver and $1.50 Gold and above.
The `profile-found` event is charged once per delivered profile URL: a company with 6 profiles costs
$0.012, a company with no social presence costs $0.00. Platform and proxy usage (including the Google
searches) is included in the price.

### How it works (and what it does not do)

- Plain HTTP only: `undici` for company websites, the absolute-URI request form through
  `proxy.apify.com` for Google (the `GOOGLE_SERP` group does not support CONNECT). No browser, so a
  run is a few seconds per company.
- One Google search per platform per company, never more. Nothing is scraped from LinkedIn, Instagram
  or any other network itself: only what the company publishes on its own site and what Google
  already indexed is used.
- `maxInputs` and Apify's paid-item limit are respected: the run stops cleanly when the charge limit
  is reached, and the rows already delivered stay in the dataset.
- Statuses: `Found` (at least one profile), `NotFound` (read fine, nothing found, free), `Error` (the
  website could not be read and no search was possible, free).

### Notes and limits

- Sites that block datacenter IPs answer 403 to the direct homepage fetch; add a residential
  `proxyConfiguration` for those. A blocked site is reported in the row's `error` field and the run
  continues with the Google search signal.
- Google search runs through Apify's `GOOGLE_SERP` proxy group. If that proxy is not available for a run, the
  Actor logs a clear warning and delivers the website signal only, so no search is charged and no profile is
  guessed.
- Google occasionally shows a follower count instead of a URL for social results. The Actor then falls
  back to the account name Google prints in the same block, which is why `confidence` is `medium` and
  `foundVia` distinguishes the two cases.
- A company with several accounts on one network (for example two Instagram accounts) gets one row
  per platform: the one linked from its own website first, otherwise the best Google match.
- A Google result is only used when its handle names the company. An account whose handle adds an
  unrelated word is not guessed from search (`github.com/makenotion` for Notion, for example): give the
  domain and the website path still finds it.
- Every field is declared in the dataset schema, so CSV and Excel exports keep their columns on rows
  where a platform was not found (`null`).

### Run monitoring and privacy

If a run fails or times out, this Actor tells its developer the run ID and status, so we can fix problems fast. It never sends your input, your results or your account data.

# Actor input Schema

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

One entry per company. An entry can be a website domain (`apify.com`), a company name (`Apify`), or an object with both (`{"name": "Apify", "domain": "apify.com"}`). The domain is scraped for social links, the name is used for the Google searches. Paste a JSON array, e.g. \["apify.com", "stripe.com"].

## `platforms` (type: `array`):

Which social networks to return, one per line: linkedin, twitter, facebook, instagram, youtube, tiktok, pinterest, github. The default is all eight. Fewer platforms means fewer Google searches and a cheaper run.

## `useSearch` (type: `boolean`):

When a platform is not linked from the company's own website, run one Google search (`site:linkedin.com/company "Company Name"`) for it. Cost is one search per input per missing platform, billed by Apify Proxy as a SERP. Turn this off for a website-only run: cheaper, and only websites are contacted.

## `maxInputs` (type: `integer`):

Hard cap on delivered company rows. At $2.00 per 1,000 profiles a company with 6 profiles costs about $0.012, so 50 companies with a handful of profiles each cost well under a dollar.

## `maxPagesPerInput` (type: `integer`):

How many pages of the company website to read: the homepage plus contact/about pages it links to. 1 disables the extra pages. More pages find more social links, at one HTTP request each.

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

Company homepages are fetched directly by default, which is enough for most sites. Supply an Apify Proxy configuration (for example residential proxies) when your target sites block datacenter IPs. The Google searches always use Apify's GOOGLE_SERP proxy group and are not affected by this setting.

## Actor input object example

```json
{
  "companies": [
    "apify.com",
    "stripe.com",
    "shopify.com"
  ],
  "platforms": [
    "linkedin",
    "twitter",
    "instagram"
  ],
  "useSearch": true,
  "maxInputs": 50,
  "maxPagesPerInput": 3,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `companies` (type: `string`):

Dataset items: input, companyName, domain, linkedin, twitter, facebook, instagram, youtube, tiktok, pinterest, github, profiles, foundCount, pagesFetched, scrapedAt, status and error.

# 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": [
        "apify.com",
        "stripe.com",
        "shopify.com"
    ],
    "platforms": [
        "linkedin",
        "twitter",
        "instagram"
    ],
    "maxInputs": 50,
    "maxPagesPerInput": 3
};

// Run the Actor and wait for it to finish
const run = await client.actor("subimpact/social-media-profile-finder").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": [
        "apify.com",
        "stripe.com",
        "shopify.com",
    ],
    "platforms": [
        "linkedin",
        "twitter",
        "instagram",
    ],
    "maxInputs": 50,
    "maxPagesPerInput": 3,
}

# Run the Actor and wait for it to finish
run = client.actor("subimpact/social-media-profile-finder").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 '{
  "companies": [
    "apify.com",
    "stripe.com",
    "shopify.com"
  ],
  "platforms": [
    "linkedin",
    "twitter",
    "instagram"
  ],
  "maxInputs": 50,
  "maxPagesPerInput": 3
}' |
apify call subimpact/social-media-profile-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,subimpact/social-media-profile-finder"
        }
    }
}
```

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/ScrA6PBH4bYYed7Az/builds/tpCGV4mrFTLxH06QP/openapi.json
