# Company Email Finder — Published Emails & Phones by Name (`insight.solutions/company-contact-finder`) Actor

Give it company names, get back each company's verified website and its business emails, phone numbers, LinkedIn and social profiles, contact page and postal address — one row per company. HTTP only, no browser, no API key. Unresolved names are free.

- **URL**: https://apify.com/insight.solutions/company-contact-finder.md
- **Developed by:** [Insight Solutions](https://apify.com/insight.solutions) (community)
- **Categories:** Lead generation, Business, Marketing
- **Security:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $3.00 / 1,000 company with contacts

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

## Company Email Finder — Published Emails & Phones by Name

**Find business emails and phone numbers from a list of company names.** Give this Actor the names — a conference exhibitor list, a directory, a CRM export, a trade register — and get back one row per company: its **verified website**, and the business email addresses, phone numbers, LinkedIn and social profiles, contact-page URL and postal address published on it. JSON, CSV or Excel.

It is the [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) with a name-resolution front end. Each name is first resolved to its website — and a website counts only when **its own home page names the company** — then that website goes through the Website Contact Extractor's own extraction code, unchanged: same pages, same rules, same privacy defaults, same row. HTTP only: no browser, no login, no API key, no email verification pings.

**You pay only for what resolves.** A name that cannot be verified, or that two different websites both claim, comes back as a free row with the reason. $6.00 per 1,000 companies with contacts on the FREE tier.

### Try it in 30 seconds

This is the Store prefill; paste it and run:

```json
{ "companies": ["Apify", "Mozilla", "Basecamp", "Stripe", "Zapier", "Notion", "Vercel", "Cloudflare"] }
```

Eight well-known names that between them exercise the resolver's rungs (SEC's ticker index, the YC directory, candidate domains, web search). In our offline test against captured copies of these sites it finishes in about two seconds, resolves six of the eight and finds contacts for four. On the live web the outcome depends on the sites and the search engines on the day.

A list of smaller companies, with a country to bias the search:

```json
{
  "companies": ["Acme Plumbing & Heating", "Riverside Dental Group", "Northwind Traders Ltd"],
  "country": "GB",
  "industryHint": "",
  "maxPagesPerDomain": 6
}
```

Lines that are already a domain, URL or email address (`stripe.com`, `https://acme.example/contact`, `press@stripe.com`) skip resolution and go straight to extraction, so a mixed column from a spreadsheet works as it is.

**From code** — `client.actor("insight.solutions/company-contact-finder").call(run_input={"companies": ["Stripe", "Basecamp"]})` with `apify-client`, or `POST https://api.apify.com/v2/acts/insight.solutions~company-contact-finder/run-sync-get-dataset-items`.

### What comes back

One row per input line, always — including the ones that could not be resolved. The fields you will use most:

- **`status`** — `resolved`, `ambiguous` or `unresolved`.
- **`companyName`**, **`domain`**, **`resolvedUrl`** — who the company is by its own website's account, and where that website is.
- **`resolvedBy`** and **`confidence`** — which rung found the website (`input`, `sec`, `yc`, `slug`, `search`) and which signal confirmed it.
- **`emails[]`**, **`phones[]`**, **`socials`**, **`contactPageUrl`**, **`addressText`**, **`hasContactForm`** — exactly the Website Contact Extractor's fields, filled the same way.
- **`found`** — at least one usable contact route. This and `status` are what decide the charge.
- **`candidates[]`** — on an `ambiguous` row, every website that passed the identity check, so you can pick.
- **`reason`** — on an `ambiguous` or `unresolved` row, one sentence saying why, with the candidate domains that were tried.

Full list under *Output reference*.

**We extract** role-based and generic business addresses (`info@`, `sales@`, `kontakt@`, `owner@`, `bookings@` …), published business phone numbers normalised to E.164, company social profiles (LinkedIn, X/Twitter, Facebook, Instagram, YouTube, GitHub), the contact page, the postal address and whether there is a contact form.

**We do not extract, by default,** addresses shaped like a named individual (`jane.doe@`) — opt in with `includePersonalEmails` — and **never** contact details a page's structured data attributes to a `Person`, and never names, in any field.

### Use cases

- **Turn a conference exhibitor list into a lead list** — paste the company names, get websites, role addresses, phones and LinkedIn pages back.
- **Enrich a CRM export that has company names but no domains** — one row per company, with a machine-readable reason wherever a name did not resolve.
- **Work a directory or trade register** — names and a country in (`country: "DE"` puts `.de` candidates first and regionalises the search), contacts out.
- **Find the official website for a list of companies** — `domain`, `resolvedUrl`, `resolvedBy` and `confidence` are useful on their own, and a name whose site was found but publishes nothing costs only the resolution fee.
- **Clean a mixed column** — names, domains, URLs and email addresses in one list; the domain-shaped lines skip resolution.

### How it compares

- **A guessed domain is never an answer.** Many tools turn `Acme` into `acme.com` and scrape whatever is there. Here a candidate website is accepted only when its own page names the company — its JSON-LD `Organization`, its `og:site_name`, its title or its footer copyright — and parked pages, placeholder pages and pages naming someone else are refused. When two different websites both pass, you get an `ambiguous` row listing both, free, instead of a coin toss.
- **You pay per resolved company, not per input line.** Unresolved and ambiguous names, unreachable sites and invalid lines are rows in your dataset at $0.00.
- **The extraction is the one with the paying users.** The contact fields are produced by the Website Contact Extractor's own code, vendored byte-for-byte; a test compares this Actor's rows with the extractor's own run on the same captured pages, field for field.
- **Organisations, not people.** The resolver looks for an organisation's official website and drops social networks, people directories and data brokers before anything is fetched. There is no person search, and no names in the output.
- **No browser, no API key, no proxy bill for site fetches.** Company websites are fetched directly; only the web search and the YC directory lookup go through the datacenter proxy.

### How a name is resolved

Five rungs, cheapest first, stopping at the first verified hit:

| Rung | `resolvedBy` | Source | Requests | Verified by | `confidence` |
|---|---|---|---|---|---|
| 0 | `input` | the line is already a domain, URL or email address | none | — it is your own answer | 1.0 |
| 1 | `sec` | SEC's `company_tickers.json` — the US public filer this line names, by its registered name, its ticker in capitals (`NET`) or its CIK — then candidate domains from the filer's name | 1 per run (cached a week) + 1–4 | the home page names the filer | 0.9 |
| 2 | `yc` | the Y Combinator directory's public search index — the website a YC company keeps on file | 2 per run (the search key, then one search for up to 25 names) | the directory itself | 0.9 |
| 3 | `slug` | `<name>.com`, `.io`, `.ai`, `.co` — your `country`'s domain ending first (`.de`, `.co.uk`) | 1–4 | the home page names the company | 0.8 / 0.6 |
| 4 | `search` | one web search, `"<name>" <industryHint> official website`: DuckDuckGo, Bing as the fallback; the top 8 organic results, about 160 aggregator sites dropped (encyclopedias, social networks, review and job sites, business-data directories, app stores, marketplaces, news sites, company registries) | 1 search + at most 3 candidates | the home page names the company | 0.8 / 0.6 |

- **The identity check** reads the home page's own name — JSON-LD `Organization.name`, then `og:site_name`, then the `<title>`, then the footer copyright — and compares it with the name you gave, ignoring legal forms (`Stripe` matches `Stripe, Inc.`). A match in JSON-LD scores 0.8; a match anywhere else 0.6. These are not probabilities; they record which signal matched, which is the thing you can check.
- **SEC matches narrowly**: a registered name equal to yours once the legal form is stripped, a ticker typed in capitals, or a CIK — never a prefix (`Apple` is not `Apple Hospitality REIT`). **YC matches narrowly**: the directory's company must have exactly your name (or a former name). A rung that matches nothing simply passes the name on.
- **Search candidates** are ranked by how well the domain's own label matches the name, then by your country's domain ending, then by position. A candidate whose label *is* the name and whose page says so is accepted at once; otherwise up to three are probed, and two different survivors make the row `ambiguous`.
- **A common short name resolves to whoever owns the obvious domain.** `Acme` will be `acme.com` if that site calls itself Acme. If your list is full of common names, add the domain to the line, or a `country`.
- **The search engines may refuse.** DuckDuckGo either answers or challenges with an image CAPTCHA; Bing is asked directly, because through datacenter proxies it answers with unrelated pages. A challenge or a block marks that engine off for the rest of the run, so it costs a few requests once (at most three per search already in flight), not three per company; with both engines off, names that needed the search get a free `search_blocked` row while rungs 0–3 keep working. Pass the domain for those lines.
- **News search is deliberately not a rung**: a news item's source is the *publisher's* website, never the subject company's.
- **Names in non-Latin scripts do not resolve yet.** The identity check compares the Latin letters and digits of the two names, so `株式会社サンプル` or `Пример` comes back `unresolved`, free. Pass the domain for those lines.

### Input reference

| Field | Type | Default | What it does |
|---|---|---|---|
| `companies` | array of strings | — *(required)* | Company names, one per line, up to 2,000 per run. A domain, URL or email address on a line skips resolution. Empty lines are ignored; IP addresses, non-http URLs and consumer mailbox addresses (`@gmail.com`) get a free diagnostic row |
| `country` | string | `""` | Optional two-letter code (`DE`, `GB`, `US`). Puts that country's domain ending first among the candidate domains and regionalises the web search |
| `industryHint` | string | `""` | Optional words added to the web search to tell apart companies with the same name (`software`, `plumbing`). Used by the search rung only |
| `maxPagesPerDomain` | integer 1–10 | `4` | Pages fetched per resolved website, home page included — the Website Contact Extractor's setting. Costs nothing extra |
| `contactPathHints` | array of strings | `/contact`, `/contact-us`, `/about`, `/imprint`, `/impressum`, `/legal` | Paths preferred when following contact links |
| `includePersonalEmails` | boolean | `false` | Also return person-shaped addresses. **Read the data-protection notes before enabling** |
| `extractPhones` | boolean | `true` | Parse `tel:` links, JSON-LD `telephone` and visible text; normalise to E.164 |
| `extractSocials` | boolean | `true` | Detect the six social platforms, normalised to the profile root |
| `requestTimeoutSecs` | integer 5–120 | `20` | Timeout for each resolved website's home page during extraction; candidate websites checked during resolution get at most 12 s each |
| `maxRunSecs` | integer 30–3600 | `240` | Wall-clock budget. When reached, no further companies are started; the status message says how many were skipped, and skipped companies are never charged |
| `proxyConfiguration` | object | `{ "useApifyProxy": true }` | Used for the web search (DuckDuckGo) and the YC directory. Company websites, SEC and Bing are fetched directly |
| `secUserAgentContact` | string | `""` | Optional. SEC asks automated clients to name themselves and a contact (`Acme Research data@acme.com`); left empty, the Actor names itself and its Store page. If SEC refuses, rung 1 is skipped for the run, free |

### Output reference

One row per input line — always. The dataset is never empty.

```json
{
  "inputName": "Alpha Robotics",
  "inputKind": "name",
  "companyName": "Alpha Robotics",
  "domain": "alpha-robotics.example",
  "resolvedUrl": "https://www.alpha-robotics.example/",
  "resolvedBy": "slug",
  "confidence": 0.8,
  "candidates": [],
  "inputUrl": "alpha-robotics.example",
  "redirectChain": ["https://www.alpha-robotics.example/"],
  "httpStatus": 200,
  "pageTitle": "Alpha Robotics — Industrial automation",
  "emails": [
    { "address": "info@alpha-robotics.example", "type": "role", "foundOn": "https://www.alpha-robotics.example/" }
  ],
  "phones": [{ "raw": "+44 20 7946 0958", "e164": "+442079460958", "foundOn": "https://www.alpha-robotics.example/" }],
  "socials": {
    "linkedin": "https://linkedin.com/company/alpha-robotics", "twitter": null,
    "facebook": null, "instagram": null, "youtube": null, "github": "https://github.com/alpha-robotics"
  },
  "contactPageUrl": "https://www.alpha-robotics.example/contact",
  "contactPageConfirmed": true,
  "addressText": "12 Kingsway, London, WC2B 6UN, GB",
  "hasContactForm": true,
  "pagesFetched": ["https://www.alpha-robotics.example/", "https://www.alpha-robotics.example/contact"],
  "source": "www.alpha-robotics.example",
  "sourceUrl": "https://www.alpha-robotics.example/",
  "found": true,
  "error": null,
  "status": "resolved",
  "reason": null,
  "duplicateOf": null,
  "scrapedAt": "2026-10-22T09:14:02.117Z"
}
```

**Field notes**

- **`inputKind`** — `name` (resolved through the ladder), or `domain` / `url` / `email` (used as given — rung 0).
- **`companyName`** — the name the resolved website gives itself; else the brand in its page title; else the directory's name for it (YC, SEC); else your line. `null` when unresolved.
- **`resolvedBy`** / **`confidence`** — see *How a name is resolved*. `null` when unresolved or ambiguous.
- **`candidates`** — on an `ambiguous` row only: `domain`, `url`, `companyName`, `matchedOn`, `confidence` and `searchPosition` for every website that passed the identity check. Empty otherwise.
- **The extractor's fields** (`inputUrl` to `sourceUrl`, `found`) — exactly as the [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) documents them: role addresses sorted first, `phones[].e164` null when a number could not be validated, all six `socials` keys always present, and only a contact page that was actually fetched counts towards `found`. On `ambiguous` and `unresolved` rows every one of them is `null`: there was no website to read.
- **`error`** — `null` on success. On a resolved row, the extractor's code: `no_contacts`, `blocked`, `robots_disallowed`, `dns`, `timeout`, `tls`, `connection`, `not_html`, `too_large` or `http_<status>`. Otherwise `ambiguous`, `not_found` (no rung verified a website), `search_blocked`, `timeout` (the time budget ran out mid-resolution), `invalid_input`, `freemail`, or `connection` if an unexpected error stopped that one line.
- **`duplicateOf`** — set when an earlier line of the same run already reached this website (the same name twice, or a name and its domain): the row repeats that line's contacts and is not charged.

### Pricing

| Event | Free | Bronze | Silver | Gold |
|---|---|---|---|---|
| `actor-start` — once per run, only after the first paid row is delivered | $0.001 | $0.001 | $0.001 | $0.001 |
| `company-resolved` — per name resolved to a website whose home page was read | $0.001 | $0.001 | $0.0008 | $0.0006 |
| **`company-with-contacts`** — per company where contacts were found | **$0.005** | **$0.005** | **$0.004** | **$0.003** |

A fully resolved company with contacts bills both: **$6.00 per 1,000 companies with contacts** on the Free and Bronze tiers. A company whose website was found but publishes nothing bills `company-resolved` only. A line that was already a domain, URL or email address was never resolved, so it bills `company-with-contacts` only, when contacts are found — and if your whole list is domains, the [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor) is the cheaper tool for it.

**Worked example.** 1,000 company names on the Free tier; 820 resolve, 650 of those publish contacts, 180 are unresolved or ambiguous:

```
actor-start              1 × $0.001 = $0.001
company-resolved       820 × $0.001 = $0.820
company-with-contacts  650 × $0.005 = $3.250
                                      ──────
                                      $4.071
```

The 180 unresolved and ambiguous names are in your dataset with the reason, and cost $0.00.

You are **not** charged for a name that did not resolve (`not_found`, `search_blocked`, `timeout`), a name two websites both claim (`ambiguous`), a resolved name whose website then could not be read (`blocked`, `dns`, `robots_disallowed`, …), an invalid line, a second line for a website the run already delivered, or anything the run did not reach before `maxRunSecs` or your run-cost limit. The one flat charge, `actor-start`, is billed once per run and only after the first paid row is in your dataset — a run that resolves nothing costs nothing at all. No charge is ever made that your run's maximum cost cannot cover.

### Limits

| | Limit |
|---|---|
| Companies per run | 2,000 |
| Companies in parallel | 10; the extraction step never has more than one request in flight per website |
| Search legs in parallel | 3, each from its own proxy session |
| One candidate website | 2 requests at most (`https://` apex, then `www.`), 12 s each |
| One name's resolution | 60 s, every rung included |
| One search request | 20 s; at most one search leg per company |
| Extraction | the Website Contact Extractor's limits: robots.txt honoured, `maxPagesPerDomain` pages, 4 MB per page, 60 s of network time per website (or 3 × `requestTimeoutSecs` if higher) |
| The whole run | `maxRunSecs` \[240 s]: no company starts after it; one already running finishes |

**Run speed.** A name that resolves on the slug rung costs the extractor's own work on its domain plus one home-page read; one that needs the web search adds a results page (≈ 30–60 KB through the proxy) and up to three home-page reads. The extraction step is the Website Contact Extractor's, which measured 40–100 live domains a minute at the default 512 MB; resolution comes on top of that, so plan on fewer names a minute than that, and raise `maxRunSecs` for lists of more than a couple of hundred names. Companies a run does not reach are never charged.

**Websites change**, and so do search engines. Extraction reads each site's current markup; a redesign can move or remove what a previous run found, and a search engine that answers today may challenge tomorrow.

### Use it from an AI agent, or from code

One JSON object in, one flat array out — the shape agent runtimes want. The Actor runs with **limited permissions** and **pay-per-event** pricing, so it works over the Apify MCP server (`mcp.apify.com`) and with prepaid agentic (x402) tokens. The **Integrations** tab pushes results to Slack, a webhook, Zapier, Make, Google Sheets, Snowflake or BigQuery, and Apify Schedules run it unattended.

```bash
curl -X POST "https://api.apify.com/v2/acts/insight.solutions~company-contact-finder/run-sync-get-dataset-items?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"companies":["Stripe","Basecamp","Notion"]}'
```

```python
## pip install apify-client
from apify_client import ApifyClient

client = ApifyClient("<APIFY_TOKEN>")
run = client.actor("insight.solutions/company-contact-finder").call(run_input={
    "companies": ["Stripe", "Basecamp", "Notion", "Acme Plumbing & Heating"],
    "country": "US",
})

for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    if row["status"] == "resolved" and row["found"]:
        emails = ", ".join(e["address"] for e in row["emails"])
        print(row["companyName"], row["domain"], emails, row["socials"]["linkedin"], sep=" | ")
    else:
        print(row["inputName"], row["status"], row["reason"], sep=" | ")
```

**Building an app with Lovable?** Apify's Lovable connector runs any Actor from inside a Lovable project with your Apify token. Connect Apify in Lovable once, then ask it: *"Use Apify to run insight.solutions/company-contact-finder on a list of company names I paste in and build a lead list around the results, with each company's website, emails, phone numbers and social profiles, and a list of the names that did not resolve."* A list of a few dozen names finishes well inside Lovable's 300-second synchronous limit, and every result is one JSON object per row, so the generated app needs no extra parsing. Usage bills to the Apify account whose token is connected.

### FAQ

**Why did a well-known company come back `unresolved`?**
No rung verified a website: SEC and YC did not list it under that exact name, none of the candidate domains served a page that names it, and the search results either did not include its site or the engines refused this run (`search_blocked`). The `reason` lists the domains tried. Add the domain to the line, or a `country` or `industryHint`, and run it again — the free row cost you nothing.

**What does `ambiguous` mean?**
Two or more different websites each call themselves the company you named. Rather than pick one, the row lists them in `candidates` and is free. Pass the domain you meant.

**Can I look up a person?**
No. This Actor resolves organisations. A line that is a person's name comes back `unresolved` unless an organisation's website names itself that way; there is no person search, social networks and people directories are never fetched, and no names appear in the output.

**Why is `companyName` different from what I typed?**
It is the name the company's own website uses (`Vercel Inc.` for `Vercel`), which is usually what you want in a CRM. Your line is kept in `inputName`.

**Do you check whether the email address actually works?**
No, and we will not add it — the same policy as the Website Contact Extractor. We report exactly what the website publishes.

**I already have the domains.**
Then use the [Website Contact Extractor](https://apify.com/insight.solutions/website-contact-extractor): same extraction, $0.004 per domain with contacts, nothing for the rest. Domain lines work here too, at this Actor's prices.

**Why are company websites fetched without a proxy?**
That is how the Website Contact Extractor fetches them, and it keeps the cost down. Only the web search goes through the proxy, because the search engines are the ones that look at the exit IP.

### Legal and data-protection notes

- **Public pages and public directories only.** Everything this Actor reads is served to any anonymous visitor: company websites, SEC's public ticker file, the YC directory's public search index, and search result pages. It never logs in, never supplies cookies or session tokens, and never accepts credentials as input.
- **robots.txt is honoured** on every website the extraction step reads, and a refusal is reported (`robots_disallowed`) rather than worked around. No SMTP probing, no verification APIs.
- **The default output is business contact data.** Role-based addresses like `info@` and `sales@` identify a function, not a person. `includePersonalEmails` changes that: `jane.doe@company.com` identifies a natural person and is personal data under the GDPR and the CCPA/CPRA, whether or not it was published. **If you enable it, you are the controller** — you need a lawful basis, you owe the Article 13/14 notice at first contact, and you must honour access, rectification, erasure and objection requests. Marketing to these addresses is a separate question governed by ePrivacy, national law and CAN-SPAM.
- **No names, by construction.** Contact details a page's structured data attributes to a `Person` are never read, even with `includePersonalEmails` on; the YC directory is read through its search index only, never the company pages where founder records live; and the name a refused candidate page gives itself is never written to a row.
- **We are not a data broker.** This Actor holds no database and sells no list. It reads pages on demand and writes the result to *your* dataset on *your* account. The only thing kept between runs is a week-long cache of SEC's public ticker file, in a key-value store on your account.
- **Not affiliated with, endorsed by or sponsored by** any company you look up, nor by SEC, Y Combinator, DuckDuckGo, Microsoft (Bing), LinkedIn, X/Twitter, Meta, Google, YouTube or GitHub. Names are used descriptively, to say which source was read or which link was detected.
- **You are responsible for how you use the output.** Compliance with the GDPR, the CCPA, ePrivacy, CAN-SPAM and applicable marketing law sits with you as the operator. Nothing here is legal advice.

### Our other Actors

Every Insight Solutions Actor is pay-per-result with no browser, no login and no API key, and every one of them returns free diagnostic rows instead of billing for failures. Prices are per 1,000 results.

**Video, audio & social**

- [YouTube Transcript Scraper & API — Captions to Text, SRT & VTT](https://apify.com/insight.solutions/youtube-transcript-api) — captions as timed segments, text, SRT or VTT, with language fallback and translation.
- [YouTube Comments Scraper — Comments & Replies with Likes](https://apify.com/insight.solutions/youtube-comments-api) — comments and replies with likes, pinned and hearted flags, newest or top sort.
- [YouTube Channel Scraper — Videos, Shorts & Search](https://apify.com/insight.solutions/youtube-channel-api) — a channel's videos, Shorts and live streams, plus YouTube search.
- [Podcast Search, Episodes & Charts API](https://apify.com/insight.solutions/podcast-api) — Apple Podcasts search, charts and full episode feeds.
- [Bluesky Scraper](https://apify.com/insight.solutions/bluesky-scraper) — profiles, posts, followers and follows from the public AT Protocol API.
- [Telegram Channel Scraper — Posts, Views & Stats](https://apify.com/insight.solutions/telegram-channel-scraper) — posts, views and channel stats from public Telegram channels.
- [Substack Scraper](https://apify.com/insight.solutions/substack-scraper) — posts with full free text, comments and publication profiles.
- [Sponsor & Advertiser Finder — YouTube, Podcasts & Newsletters](https://apify.com/insight.solutions/sponsorship-intelligence-api) — which brands sponsor which YouTube channels, podcasts and Substack newsletters, with promo codes, offers and sponsor links, company-level only.
- [Google Ads Transparency Center API — Advertisers & Ads](https://apify.com/insight.solutions/google-ads-transparency-api) — every ad a verified advertiser runs on Google, from the Ads Transparency Center, by brand name, AR id or domain: format, first and last shown, days shown and preview links, individuals excluded.
- [Hacker News API](https://apify.com/insight.solutions/hacker-news-api) — stories, comments, users, front page and a structured "Who is hiring?" parser from the official HN APIs.
- [GitHub Trending & Repo Scraper — Stars, Releases & Search](https://apify.com/insight.solutions/github-repos-api) — repository facts, trending lists, releases and search, no token needed for small runs.
- [Discourse Forum Scraper — Topics, Posts & Categories](https://apify.com/insight.solutions/discourse-forum-api) — topics, posts and categories from any Discourse community via its own JSON endpoints, usernames only.

**News, documents & the web**

- [Google News Scraper — Search, Topics & Real Article URLs](https://apify.com/insight.solutions/google-news-api) — news search and topic feeds with the publisher's real URL decoded.
- [Website to Markdown Converter & API — for LLMs & RAG](https://apify.com/insight.solutions/website-content-extractor) — any site as clean Markdown, text and heading-aware chunks.
- [WordPress Scraper — Posts & Pages from Any WP Site, No Login](https://apify.com/insight.solutions/wordpress-posts-api) — posts and pages from any WordPress site as clean text or Markdown, with categories, tags and images.
- [Website Metadata Extractor — Schema.org, Open Graph & JSON-LD](https://apify.com/insight.solutions/website-metadata-api) — any URL's meta tags, Open Graph, Twitter cards, hreflang, feeds, JSON-LD and microdata, with normalised Product, Article, Event and FAQ entities.
- [Subdomain Finder — Certificate Logs & DNS, No API Key](https://apify.com/insight.solutions/subdomain-finder-api) — every subdomain of a domain from certificate-transparency logs, resolved over DNS, with an optional live HTTP check.
- [Internet Archive Scraper & API — Search, Metadata & Files](https://apify.com/insight.solutions/internet-archive-api) — archive.org search, item metadata, files and reviews.
- [Wayback Machine Scraper — Archived URLs, Snapshots & Diffs](https://apify.com/insight.solutions/wayback-toolkit) — archived URL inventories, snapshots and text diffs between dates.
- [Website Technology Detector — Tech Stack Checker & Lookup](https://apify.com/insight.solutions/website-tech-detector) — the tech stack behind any site, with the evidence for each detection.
- [Domain Lookup API — DNS, WHOIS/RDAP, SSL & Providers](https://apify.com/insight.solutions/domain-intelligence-api) — DNS, RDAP registration, TLS certificate and HTTP facts in one row per domain.
- [SEO Audit Tool — Sitemap Crawl & On-Page Checker](https://apify.com/insight.solutions/seo-page-audit) — sitemap crawl with on-page checks, structured data and broken-link reports.
- [Keyword Suggestions Tool & API — Google, Bing & Amazon](https://apify.com/insight.solutions/keyword-suggestions-api) — Google, YouTube, Bing, Amazon and eBay autocomplete with alphabet and question expansions.
- [Website Contact Scraper — Email, Phone & Socials Extractor](https://apify.com/insight.solutions/website-contact-extractor) — emails, phone numbers and social profiles from any list of websites.
- [Web Search Results API](https://apify.com/insight.solutions/web-search-api) — Bing and DuckDuckGo organic results with snippets, no key, no browser.
- [Company Enrichment API](https://apify.com/insight.solutions/company-enrichment-api) — a domain in, a company profile out: firmographics, contacts, tech stack, DNS and hiring signal.
- [Company Dossier API](https://apify.com/insight.solutions/company-dossier-api) — one company in, twelve sections out: profile, tech, contacts, DNS, open roles, news, SEC filings, federal awards, recalls, YC batch and apps.
- [Press Release Scraper — GlobeNewswire, PR Newswire & More](https://apify.com/insight.solutions/press-releases-api) — GlobeNewswire and PR Newswire releases plus any newsroom feed, by keyword, company, ticker or subject.
- [Federal Register API](https://apify.com/insight.solutions/federal-register-api) — rules, proposed rules, notices and the Public Inspection desk with dockets, comment deadlines and CFR references.
- [Academic Papers Search API](https://apify.com/insight.solutions/academic-papers-api) — OpenAlex, Crossref, arXiv and PubMed in one row per paper: abstract, citations, open-access PDF, authors and venue.
- [RSS & Atom Feed Monitor](https://apify.com/insight.solutions/rss-feed-monitor) — any RSS, Atom or JSON feed (or an OPML file) in, only the new items out, with keyword filters and a webhook.
- [Website Change Monitor](https://apify.com/insight.solutions/website-change-monitor) — watch any pages, diff the text between runs, get change rows with added/removed lines, keyword alerts and a webhook.
- [Wikipedia & Wikidata API](https://apify.com/insight.solutions/wikipedia-api) — article text, search, daily pageviews and Wikidata entity facts, any language edition.

**Business, finance & jobs**

- [Congress Trades Tracker API — STOCK Act PTRs + SEC Form 4](https://apify.com/insight.solutions/congress-insider-trades-api) — STOCK Act periodic transaction reports and SEC Form 4 insider trades in one schema.
- [Federal Contracts, Grants & Lobbying API](https://apify.com/insight.solutions/federal-contracts-grants-api) — SAM.gov opportunities, USAspending awards, Grants.gov notices and Senate lobbying filings in one schema.
- [SEC EDGAR API](https://apify.com/insight.solutions/sec-edgar-api) — filings, XBRL financials and full-text search by ticker or CIK.
- [Litigation Signals API — Lawsuits, Settlements & Investigations](https://apify.com/insight.solutions/litigation-signals-api) — lawsuits, settlements and investigations per public company from SEC 10-K, 10-Q and 8-K disclosures, press wires and SEC, FTC and DOJ notices, company-level only.
- [Startup Funding Rounds API — SEC Form D, Wires & News](https://apify.com/insight.solutions/funding-signals-api) — who just raised money: one row per funding round from SEC Form D filings, press wires and Google News, with amount, round, investors, industry and state, company-level only.
- [Clinical Trials & FDA API](https://apify.com/insight.solutions/clinical-trials-fda-api) — ClinicalTrials.gov studies plus openFDA recalls, labels, approvals, 510(k)s and adverse-event reports.
- [Product & Vehicle Recalls API](https://apify.com/insight.solutions/product-recalls-api) — CPSC, NHTSA, FDA and USDA recalls, vehicle complaints and ratings, plus a VIN decoder.
- [YC Companies List & Directory Scraper — Batches & Founders](https://apify.com/insight.solutions/yc-companies-directory) — the YC directory with founders and social links, filterable by batch, industry and hiring status.
- [Job Scraper for Greenhouse, Lever, Ashby & 10+ ATS Career Sites](https://apify.com/insight.solutions/ats-jobs-api) — jobs straight from Greenhouse, Lever, Ashby, Workable and 10+ other ATS career sites.
- [Workday Jobs Scraper — All Postings from Any Workday Site](https://apify.com/insight.solutions/workday-jobs-api) — every posting on any Workday career site, with facets, search, posted dates and full descriptions.
- [Job Postings Monitor — New & Closed Roles, Hiring Alerts](https://apify.com/insight.solutions/job-postings-monitor) — new, closed and changed postings on the career sites you watch.
- [Hiring Signals API — Open Roles & Hiring Surge by Company](https://apify.com/insight.solutions/hiring-signals-api) — one row per company per run: open roles, what opened and closed, department and seniority breakdowns, and a hiring-surge flag.
- [Careers Page Scraper — Open Roles from Any Company's Site](https://apify.com/insight.solutions/careers-page-jobs-api) — open roles from any company's own careers site: domain in, the platform recognised (Eightfold, Phenom, Jibe, iCIMS, Google, Amazon, 14 ATSs) or the site's structured data read, one row per job.
- [Wellfound Jobs Scraper — Startup Roles, Salary & Equity](https://apify.com/insight.solutions/wellfound-jobs-api) — startup jobs from Wellfound's role listings, by role and city or remote: salary and equity as shown, remote policy, experience, and each startup's size, stage and badges, no recruiter contacts.
- [Remote Jobs API](https://apify.com/insight.solutions/remote-jobs-api) — RemoteOK, Remotive, We Work Remotely, Himalayas, Jobicy and more in one schema, deduplicated.
- [Shopify Products Scraper — Catalogue, Prices & Stock](https://apify.com/insight.solutions/shopify-products-api) — any Shopify store's catalogue, variants, prices and stock signals.
- [WooCommerce Products Scraper — Prices, Variants & Stock](https://apify.com/insight.solutions/woocommerce-products-api) — any WooCommerce store's catalogue, prices, variants and stock through its public Store API.
- [Price Tracker & Monitor — Any Retailer's Prices & Stock](https://apify.com/insight.solutions/price-tracker-api) — price, stock, list price and discount from any product URL, read from the page's structured data, with price-drop and restock rows between runs.
- [Rightmove Scraper — UK Listings for Sale & Rent by Area](https://apify.com/insight.solutions/rightmove-property-api) — UK property for sale and to rent by area from Rightmove's own search API: price, bedrooms, type, tenure, size, coordinates, photos, status and the agent branch, one row per listing.
- [Shopify App Store Scraper — Apps, Pricing, Ratings & Reviews](https://apify.com/insight.solutions/shopify-app-store-api) — Shopify App Store listings by category, collection or developer: pricing plans, ratings and merchant reviews.
- [Luma Events Scraper — Events by City, Category & Calendar](https://apify.com/insight.solutions/luma-events-api) — upcoming Luma events by city, category or calendar: dates, venue, price, capacity and organiser calendar, no host names.
- [Eventbrite Scraper — Events by City, Category & Organizers](https://apify.com/insight.solutions/eventbrite-events-api) — upcoming Eventbrite events by city, category, online or organiser, with the organising companies behind them: dates, venue, price, ticket status, followers and website, no browser, individuals never named.
- [Meetup Scraper — Upcoming Events & Group Stats](https://apify.com/insight.solutions/meetup-events-api) — upcoming events of the Meetup groups you name, and the groups themselves: dates, venue, RSVPs, fee, member count, topics and ratings, no member data.
- [Shopify Store Monitor](https://apify.com/insight.solutions/shopify-store-monitor) — price drops, sales, restocks, sell-outs and new products on any Shopify store, one row per change.
- [Shopify Store Finder — Discover & Verify Stores by Niche](https://apify.com/insight.solutions/shopify-store-finder) — Shopify stores by niche and country, each verified on its own storefront, with product count, currency, country, price range and sample products.
- [Public Tenders API](https://apify.com/insight.solutions/public-tenders-api) — EU TED, UK Find a Tender and Contracts Finder notices by keyword, CPV code, country, stage and deadline.
- [Nonprofit Lookup & IRS 990 API — EIN, Financials, NTEE](https://apify.com/insight.solutions/nonprofit-990-api) — search US nonprofits and get EIN, NTEE code and multi-year Form 990 financials.
- [OpenStreetMap Places API](https://apify.com/insight.solutions/osm-places-api) — businesses and points of interest by category and area from OpenStreetMap: name, address, coordinates, website, phone, opening hours.

**Apps & games**

- [App Store & Google Play Reviews Scraper — Ratings & Replies](https://apify.com/insight.solutions/app-reviews-api) — reviews from both stores with ratings, versions and developer replies.
- [App Store Top Charts & App Search API](https://apify.com/insight.solutions/app-charts-api) — Apple top charts by country and genre, plus app search and details.
- [App Store Keyword Rank Tracker](https://apify.com/insight.solutions/app-store-keyword-rank-tracker) — where any app ranks for any keyword on the App Store and Google Play, with rank changes and ASO suggestions.
- [Steam Reviews Scraper — Reviews & Game Details](https://apify.com/insight.solutions/steam-reviews-api) — Steam reviews with playtime, helpfulness and game details.
- [Steam Game Data API](https://apify.com/insight.solutions/steam-store-stats-api) — prices, tags, review scores, live player counts and top charts.
- [Sports Scores & Schedules API](https://apify.com/insight.solutions/sports-scores-api) — scores, schedules, standings, teams and headlines for the NFL, NBA, MLB, NHL, soccer and more, no key.
- [App Store Monitor](https://apify.com/insight.solutions/app-store-monitor) — App Store and Google Play listings watched between runs: new versions with release notes, price, rating and listing changes, one row per change.

# Actor input Schema

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

One company per line: a name (<code>Stripe</code>, <code>Acme Plumbing Ltd</code>), or a domain, URL or e-mail address (<code>stripe.com</code>, <code>press@stripe.com</code>), which skips resolution. A name is resolved to its website through SEC's ticker index, the YC directory, candidate domains and one web search, and a website counts only when its own home page names the company. This Actor resolves <b>organisations, not people</b>: a line that names no organisation comes back <code>unresolved</code>, free. Up to 2,000 lines per run.

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

Two-letter country code, e.g. <code>DE</code>, <code>GB</code>, <code>US</code>. Puts that country's domain ending first among the candidate domains (<code>.de</code>, <code>.co.uk</code>) and regionalises the web search. Leave empty for no bias.

## `industryHint` (type: `string`):

A few words added to the web search to tell apart companies with the same name, e.g. <code>software</code>, <code>plumbing</code>, <code>law firm</code>. Used by the search rung only.

## `maxPagesPerDomain` (type: `integer`):

Total pages fetched per resolved website, including the home page; the rest go to the most promising contact/about/imprint links. Extra pages cost nothing — pricing is per company, not per page.

## `contactPathHints` (type: `array`):

Internal paths preferred when looking for contact details. Case-insensitive prefix matching, so <code>/contact</code> also matches <code>/contact-us/</code>. Anchor text containing contact/about/imprint/impressum/kontakt is followed even if the path is not listed.

## `includePersonalEmails` (type: `boolean`):

⚠️ <b>Leave this OFF unless you have a lawful basis.</b> By default only role-based and generic business addresses are returned (<code>info@</code>, <code>sales@</code>, <code>careers@</code>, …); switching it on also returns addresses shaped like a named individual (<code>jane.doe@</code>), which are <b>personal data</b> under the GDPR and the CCPA. Turn it on only if you are ready to be the data controller for them — the README's data-protection notes set out what that means.

## `extractPhones` (type: `boolean`):

Parse <code>tel:</code> links, JSON-LD <code>telephone</code> values and visible text, then normalise to E.164 using the country hinted by the site's postal address or its top-level domain.

## `extractSocials` (type: `boolean`):

Detect LinkedIn, X/Twitter, Facebook, Instagram, YouTube and GitHub profile links, normalised to the profile root. Share buttons and intent links are ignored.

## `requestTimeoutSecs` (type: `integer`):

Timeout for each resolved website's home page during extraction; robots.txt gets at most 10 s and contact/about pages half of this (at least 5 s). Candidate websites checked during resolution get at most 12 s each.

## `maxRunSecs` (type: `integer`):

Wall-clock budget for the whole run. When it is reached no further companies are started; every company already finished is in your dataset and the run ends SUCCEEDED with a status message saying how many were skipped. Skipped companies are never charged. Raise it for lists of more than a couple of hundred names.

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

Used for the web search (DuckDuckGo) and the YC directory lookup. Company websites, SEC and Bing (the search fallback) are fetched directly, as the Website Contact Extractor fetches websites. The datacenter default is right for DuckDuckGo.

## `secUserAgentContact` (type: `string`):

SEC asks automated clients for a User-Agent naming the requester and a way to reach them — e.g. <code>Acme Research data@acme.com</code>. It is a contact string, not an API key. Left empty, the Actor names itself and its Store page; if SEC refuses that, the SEC rung is skipped for the run (free) and the other rungs carry on.

## Actor input object example

```json
{
  "companies": [
    "Apify",
    "Mozilla",
    "Basecamp",
    "Stripe",
    "Zapier",
    "Notion",
    "Vercel",
    "Cloudflare"
  ],
  "country": "",
  "industryHint": "",
  "maxPagesPerDomain": 4,
  "contactPathHints": [
    "/contact",
    "/contact-us",
    "/about",
    "/imprint",
    "/impressum",
    "/legal"
  ],
  "includePersonalEmails": false,
  "extractPhones": true,
  "extractSocials": true,
  "requestTimeoutSecs": 20,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  },
  "secUserAgentContact": ""
}
```

# Actor output Schema

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

One row per input company: the verified website, how it was resolved, and the business emails, phone numbers, social profiles and contact page found on it. Delivered as JSON items in the default dataset.

# 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",
        "Mozilla",
        "Basecamp",
        "Stripe",
        "Zapier",
        "Notion",
        "Vercel",
        "Cloudflare"
    ],
    "country": "",
    "industryHint": "",
    "maxPagesPerDomain": 4,
    "contactPathHints": [
        "/contact",
        "/contact-us",
        "/about",
        "/imprint",
        "/impressum",
        "/legal"
    ],
    "includePersonalEmails": false,
    "extractPhones": true,
    "extractSocials": true,
    "requestTimeoutSecs": 20,
    "maxRunSecs": 240,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("insight.solutions/company-contact-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",
        "Mozilla",
        "Basecamp",
        "Stripe",
        "Zapier",
        "Notion",
        "Vercel",
        "Cloudflare",
    ],
    "country": "",
    "industryHint": "",
    "maxPagesPerDomain": 4,
    "contactPathHints": [
        "/contact",
        "/contact-us",
        "/about",
        "/imprint",
        "/impressum",
        "/legal",
    ],
    "includePersonalEmails": False,
    "extractPhones": True,
    "extractSocials": True,
    "requestTimeoutSecs": 20,
    "maxRunSecs": 240,
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("insight.solutions/company-contact-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",
    "Mozilla",
    "Basecamp",
    "Stripe",
    "Zapier",
    "Notion",
    "Vercel",
    "Cloudflare"
  ],
  "country": "",
  "industryHint": "",
  "maxPagesPerDomain": 4,
  "contactPathHints": [
    "/contact",
    "/contact-us",
    "/about",
    "/imprint",
    "/impressum",
    "/legal"
  ],
  "includePersonalEmails": false,
  "extractPhones": true,
  "extractSocials": true,
  "requestTimeoutSecs": 20,
  "maxRunSecs": 240,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call insight.solutions/company-contact-finder --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,insight.solutions/company-contact-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/Lxvq3XSjRnLLXtEs0/builds/ruRj3YUlRcVzlYKRc/openapi.json